@digital-ai/devops-page-object-deploy 0.0.7 → 0.0.9

package/dist/main.js

@@ -1,5 +1,6 @@
 var $1UEKj$playwrighttest = require("@playwright/test");
 
+
 function $parcel$export(e, n, v, s) {
   Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
 }
@@ -14,117 +15,2553 @@ class $ae23b16684112d0b$export$2b65d1d97338f32b {
 }
 
 
+class $84f8d1abd29d48fd$export$cb21416f3c2fd176 extends (0, $ae23b16684112d0b$export$2b65d1d97338f32b) {
+    async handleSaveToastOrAlreadyExists() {
+        const toastMessage = this.page.locator('.redux-toastr .rrt-text:visible');
+        try {
+            await toastMessage.waitFor({
+                state: 'visible',
+                timeout: 10000
+            });
+        } catch  {
+            // No toast appeared — assume the operation succeeded silently (e.g. fast CI environments).
+            return;
+        }
+        const toastText = (await toastMessage.textContent())?.trim() ?? '';
+        if (toastText === 'Your change was saved.') return;
+        if (/already exists/i.test(toastText)) {
+            const cancelButton = this.page.getByRole('button', {
+                name: 'Cancel'
+            });
+            if (await cancelButton.isVisible()) await cancelButton.click();
+            else await this.page.locator('i.xl-icon.close-icon').first().click();
+            return;
+        }
+        await (0, $1UEKj$playwrighttest.expect)(toastMessage).toHaveText('Your change was saved.');
+    }
+    async openRootContextMenu(rootId) {
+        await this.closeModalIfPresent();
+        await this.ensureExplorerTreeReady();
+        const rootTitle = this.page.locator(`span[data-id="${rootId}"]`);
+        await rootTitle.scrollIntoViewIfNeeded();
+        await rootTitle.click();
+        const menuButton = this.page.locator(`i.context-menu-button[data-id="${rootId}"]`);
+        await menuButton.scrollIntoViewIfNeeded();
+        for(let attempt = 0; attempt < 3; attempt += 1)try {
+            await menuButton.click({
+                force: true
+            });
+            return;
+        } catch  {
+            if (attempt === 2) throw new Error(`Failed to open context menu for ${rootId}`);
+            await this.page.waitForTimeout(300);
+        }
+    }
+    async ensureExplorerTreeReady() {
+        const applicationsRoot = this.page.locator('div[data-id="Applications"]');
+        try {
+            await applicationsRoot.waitFor({
+                state: 'visible',
+                timeout: 3000
+            });
+            return;
+        } catch  {
+        // Fall through to open Explorer.
+        }
+        const explorerCandidates = [
+            this.page.locator('p.MuiTypography-root', {
+                hasText: 'Explorer'
+            }),
+            this.page.getByRole('link', {
+                name: 'Explorer'
+            }),
+            this.page.getByRole('button', {
+                name: 'Explorer'
+            })
+        ];
+        for (const candidate of explorerCandidates)try {
+            if (await candidate.count() > 0) {
+                await candidate.first().click({
+                    timeout: 10000
+                });
+                break;
+            }
+        } catch  {
+        // Try next candidate.
+        }
+        await applicationsRoot.waitFor({
+            state: 'visible',
+            timeout: 10000
+        });
+    }
+    async closeModalIfPresent() {
+        const modal = this.page.locator('div.xl-react-widget-modal-dialog.in');
+        if (await modal.count() === 0) return;
+        if (!await modal.first().isVisible()) return;
+        const cancelButton = modal.getByRole('button', {
+            name: 'Cancel'
+        }).first();
+        if (await cancelButton.isVisible()) await cancelButton.click();
+        else {
+            const closeIcon = modal.locator('i.xl-icon.close-icon').first();
+            if (await closeIcon.isVisible()) await closeIcon.click();
+        }
+        try {
+            await this.page.locator('body.xl-react-modal-open').waitFor({
+                state: 'hidden',
+                timeout: 10000
+            });
+        } catch  {
+        // Modal may already be closing.
+        }
+    }
+}
+
+
+
+
 class $f280624787ceceed$export$36d69433c4f81145 extends (0, $ae23b16684112d0b$export$2b65d1d97338f32b) {
     async clickUserManagement() {
-        await this.page.locator("p.MuiTypography-root", {
-            hasText: "User management"
+        await this.page.locator('p.MuiTypography-root', {
+            hasText: 'User management'
         }).click();
-        await this.page.getByRole("link", {
-            name: "Users"
+        await this.page.getByRole('link', {
+            name: 'Users'
+        }).click();
+    }
+    async clickExplorer() {
+        await this.page.locator('p.MuiTypography-root', {
+            hasText: 'Explorer'
         }).click();
     }
     async verifyDeployLogoIsPresent() {
-        const logo = this.page.getByAltText("Deploy");
+        const logo = this.page.getByAltText('Deploy');
         await (0, $1UEKj$playwrighttest.expect)(logo).toBeVisible();
     }
     async verifyDeployTextIsPresent() {
-        const title = this.page.getByTitle("digital.ai");
+        const title = this.page.getByTitle('digital.ai');
         await (0, $1UEKj$playwrighttest.expect)(title).toBeVisible();
     }
+    async clickReports() {
+        await this.page.locator('p.MuiTypography-root', {
+            hasText: 'Reports'
+        }).click();
+    }
+    async verifyReportsOnlyAccess() {
+        const sidebar = this.page.locator('.dot-sidebar');
+        await (0, $1UEKj$playwrighttest.expect)(sidebar.getByText('Reports', {
+            exact: true
+        })).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(sidebar.getByText('Explorer', {
+            exact: true
+        })).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(sidebar.getByText('Rules and Macros', {
+            exact: true
+        })).toHaveCount(0);
+        await (0, $1UEKj$playwrighttest.expect)(sidebar.getByText('Gitops', {
+            exact: true
+        })).toHaveCount(0);
+        await (0, $1UEKj$playwrighttest.expect)(sidebar.getByText('Local sources', {
+            exact: true
+        })).toHaveCount(0);
+        await (0, $1UEKj$playwrighttest.expect)(sidebar.getByText('Plugins', {
+            exact: true
+        })).toHaveCount(0);
+        await (0, $1UEKj$playwrighttest.expect)(sidebar.getByText('User management', {
+            exact: true
+        })).toHaveCount(0);
+    }
+    async verifyNoCiDataVisible() {
+        await (0, $1UEKj$playwrighttest.expect)(this.page.getByText('LocalHost', {
+            exact: true
+        })).toHaveCount(0);
+        await (0, $1UEKj$playwrighttest.expect)(this.page.getByText('LocalEnv', {
+            exact: true
+        })).toHaveCount(0);
+        await (0, $1UEKj$playwrighttest.expect)(this.page.getByText('App', {
+            exact: true
+        })).toHaveCount(0);
+    }
 }
 
 
 
 
 class $c949c453826379e3$export$ecdc3cf9d1cfe143 extends (0, $ae23b16684112d0b$export$2b65d1d97338f32b) {
-    /**
-   * Login with username and password
-   * @param userName
-   * @param password
-   */ // this should be refactored to take an object and not disable the rule!!
-    // eslint-disable-next-line max-params
-    async createNewUser(username, fullName, email, password, confirmPassword) {
-        await this.page.locator("p.MuiTypography-root", {
-            hasText: "Users"
-        }).click();
-        await this.page.getByRole("button", {
-            name: "Add user"
-        }).click();
-        await this.page.locator('input[name="username"]').fill(username);
-        await this.page.locator('input[name="fullName"]').fill(fullName);
+    async openUsersTab() {
+        await this.page.locator('p.MuiTypography-root', {
+            hasText: 'Users'
+        }).click();
+    }
+    async waitForToastIfPresent(timeoutVisible = 3000, timeoutHidden = 5000) {
+        const toast = this.page.getByRole('alertdialog');
+        try {
+            await toast.waitFor({
+                state: 'visible',
+                timeout: timeoutVisible
+            });
+            await toast.waitFor({
+                state: 'hidden',
+                timeout: timeoutHidden
+            });
+        } catch  {
+        // Toast is transient; skip if it doesn't appear.
+        }
+    }
+    async waitForModalCloseIfPresent() {
+        try {
+            await this.page.locator('input[name="username"]').waitFor({
+                state: 'hidden',
+                timeout: 5000
+            });
+            await this.page.locator('body.xl-react-modal-open').waitFor({
+                state: 'hidden',
+                timeout: 5000
+            });
+            await this.page.waitForLoadState('networkidle');
+        } catch  {
+        // When user already exists, modal stays open; caller handles error toast.
+        }
+    }
+    async openGlobalPermissions() {
+        await this.page.getByRole('link', {
+            name: 'Global permissions'
+        }).click();
+    }
+    async filterRoleInPermissions(roleName) {
+        const filter = this.page.locator('input[placeholder="Filter by roles"]:visible');
+        await filter.waitFor({
+            state: 'visible'
+        });
+        await (0, $1UEKj$playwrighttest.expect)(filter).toBeEditable();
+        await filter.fill('');
+        await filter.fill(roleName);
+        await (0, $1UEKj$playwrighttest.expect)(filter).toHaveValue(roleName);
+        await filter.press('Enter');
+        await this.page.getByRole('button', {
+            name: 'Refresh'
+        }).click();
+        await this.page.waitForLoadState('networkidle');
+        await this.page.locator('table tbody tr:visible').first().waitFor({
+            state: 'visible'
+        });
+        const escapedRoleName = roleName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const roleCell = this.page.locator('td.permissions-pagination-table-component-role:visible').filter({
+            hasText: new RegExp(`^\\s*${escapedRoleName}\\s*$`)
+        }).first();
+        await (0, $1UEKj$playwrighttest.expect)(roleCell).toBeVisible();
+        return roleCell.locator('xpath=ancestor::tr');
+    }
+    /* Create a new user */ async createNewUser(username, email, password) {
+        await this.openUsersTab();
+        await this.page.getByRole('button', {
+            name: 'Add user'
+        }).click();
+        const usernameInput = this.page.locator('input[name="username"]');
+        await usernameInput.waitFor({
+            state: 'visible'
+        });
+        await usernameInput.fill(username);
+        await this.page.locator('input[name="fullName"]').fill(username);
         await this.page.locator('input[name="email"]').fill(email);
         const passwordInput = this.page.locator('input[name="password"]');
+        const confirmInput = this.page.locator('input[name="confirmPassword"]');
+        await passwordInput.waitFor({
+            state: 'visible'
+        });
         await passwordInput.click({
             force: true
         });
         await passwordInput.fill(password);
-        await this.page.locator('input[name="confirmPassword"]').fill(confirmPassword);
-        await this.page.getByRole("button", {
-            name: "Save"
+        await confirmInput.fill(password);
+        const saveButton = this.page.getByRole('button', {
+            name: 'Save'
+        });
+        try {
+            await (0, $1UEKj$playwrighttest.expect)(saveButton).toBeEnabled({
+                timeout: 5000
+            });
+        } catch  {
+            await passwordInput.fill('');
+            await confirmInput.fill('');
+            await passwordInput.type(password, {
+                delay: 50
+            });
+            await confirmInput.type(password, {
+                delay: 50
+            });
+            await (0, $1UEKj$playwrighttest.expect)(saveButton).toBeEnabled({
+                timeout: 5000
+            });
+        }
+        await saveButton.click();
+        await this.waitForToastIfPresent();
+        await this.waitForModalCloseIfPresent();
+    }
+    /* Verify success message */ async verifySuccessMessage() {
+        const successMessage = this.page.getByRole('alertdialog');
+        try {
+            await successMessage.waitFor({
+                state: 'visible',
+                timeout: 3000
+            });
+        } catch  {
+            // Toast never appeared — skip silently.
+            return;
+        }
+        await (0, $1UEKj$playwrighttest.expect)(successMessage).toHaveText(/User ".*" created/i);
+    }
+    /* Verify user error message */ async verifyUserErrorMessage() {
+        const errorToast = this.page.locator('.rrt-middle-container[role="alertdialog"]').nth(1);
+        try {
+            await errorToast.waitFor({
+                state: 'visible',
+                timeout: 3000
+            });
+        } catch  {
+            // Toast is transient; skip if it never appears.
+            return;
+        }
+        await (0, $1UEKj$playwrighttest.expect)(errorToast).toContainText(/already in use/i);
+    }
+    /* Delete the user and verify it is deleted */ async deleteTheUserAndVerifyItIsDeleted(username) {
+        await this.openUsersTab();
+        const filter = this.page.getByPlaceholder('Filter...');
+        await filter.fill(username);
+        await filter.press('Enter');
+        const escapedUsername = username.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const userRow = this.page.getByRole('row', {
+            name: new RegExp(`\\b${escapedUsername}\\b`)
+        }).first();
+        await userRow.waitFor({
+            state: 'visible'
+        });
+        await userRow.locator('button.delete.xl-icon.table-action').click();
+        const confirmDialog = this.page.locator('.xl-react-widget-modal-dialog.in:visible').filter({
+            hasText: /Delete user/i
+        }).first();
+        await confirmDialog.waitFor({
+            state: 'visible'
+        });
+        await confirmDialog.getByRole('button', {
+            name: 'Delete',
+            exact: true
+        }).click();
+        await confirmDialog.waitFor({
+            state: 'hidden'
+        });
+        const deleteToast = this.page.getByRole('alertdialog').filter({
+            hasText: /deleted/i
+        });
+        await (0, $1UEKj$playwrighttest.expect)(deleteToast).toHaveText(/User ".*" deleted/i);
+        await deleteToast.waitFor({
+            state: 'hidden'
+        });
+        await userRow.waitFor({
+            state: 'detached'
+        });
+    }
+    /* Edit the user and verify the changes */ async editUserAndVerify(username, editfullname) {
+        await this.openUsersTab();
+        const filter = this.page.getByPlaceholder('Filter...');
+        await filter.fill(username);
+        await filter.press('Enter');
+        const escapedUsername = username.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const userRow = this.page.getByRole('row', {
+            name: new RegExp(`\\b${escapedUsername}\\b`)
+        }).first();
+        await userRow.waitFor({
+            state: 'visible'
+        });
+        await userRow.locator('i.icon-edit.dot-i').click();
+        await this.page.locator('input[name="fullName"]').fill(editfullname);
+        const passwordInput = this.page.locator('input[name="password"]');
+        const confirmInput = this.page.locator('input[name="confirmPassword"]');
+        if (await passwordInput.count()) {
+            await passwordInput.click({
+                force: true
+            });
+            await passwordInput.press(process.platform === 'darwin' ? 'Meta+A' : 'Control+A');
+            await passwordInput.press('Backspace');
+        }
+        if (await confirmInput.count()) {
+            await confirmInput.click({
+                force: true
+            });
+            await confirmInput.press(process.platform === 'darwin' ? 'Meta+A' : 'Control+A');
+            await confirmInput.press('Backspace');
+        }
+        const saveButton = this.page.getByRole('button', {
+            name: 'Save',
+            exact: true
+        });
+        await (0, $1UEKj$playwrighttest.expect)(saveButton).toBeEnabled({
+            timeout: 5000
+        });
+        await saveButton.click();
+        const editToast = this.page.getByRole('alertdialog').filter({
+            hasText: 'Your change was saved'
+        });
+        await (0, $1UEKj$playwrighttest.expect)(editToast).toBeVisible();
+    }
+    /* Disable the user by toggling the login permission checkbox */ async disableUser(username) {
+        await this.openUsersTab();
+        const filter = this.page.getByPlaceholder('Filter...');
+        await filter.fill(username);
+        await filter.press('Enter');
+        const escapedUsername = username.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const userRow = this.page.getByRole('row', {
+            name: new RegExp(`\\b${escapedUsername}\\b`)
+        }).first();
+        await userRow.waitFor({
+            state: 'visible'
+        });
+        const checkbox = userRow.getByRole('checkbox');
+        await checkbox.click();
+        await (0, $1UEKj$playwrighttest.expect)(checkbox).not.toBeChecked();
+    }
+    /* Revoke login permission for a role via Global permissions */ async revokeLoginPermission(roleName) {
+        await this.openGlobalPermissions();
+        const roleRow = await this.filterRoleInPermissions(roleName);
+        const normalizedRoleName = roleName.replace(/\s+/g, '_');
+        const loginCheckbox = roleRow.locator(`td.permissions-pagination-table-component-${normalizedRoleName}-4 input[type="checkbox"]`);
+        const saveButton = this.page.getByRole('button', {
+            name: 'Save'
+        });
+        if (await loginCheckbox.isVisible() && await loginCheckbox.isChecked()) {
+            await loginCheckbox.uncheck();
+            await saveButton.click();
+            const saveMessage = this.page.getByRole('alertdialog');
+            await (0, $1UEKj$playwrighttest.expect)(saveMessage).toContainText('Your change was saved');
+            return;
+        }
+        if (await saveButton.isVisible()) await (0, $1UEKj$playwrighttest.expect)(saveButton).toBeDisabled();
+    }
+    /* Grant only login and report view permissions for a role */ async grantOnlyLoginAndReportPermissions(roleName) {
+        await this.openGlobalPermissions();
+        const roleRow = await this.filterRoleInPermissions(roleName);
+        const checkboxes = roleRow.locator('input[type="checkbox"]');
+        const count = await checkboxes.count();
+        for(let i = 0; i < count; i += 1){
+            const checkbox = checkboxes.nth(i);
+            if (await checkbox.isChecked()) await checkbox.uncheck();
+        }
+        await roleRow.locator(`td.permissions-pagination-table-component-${roleName}-4 input[type="checkbox"]`).check();
+        await roleRow.locator(`td.permissions-pagination-table-component-${roleName}-5 input[type="checkbox"]`).check();
+        await this.page.getByRole('button', {
+            name: 'Save'
+        }).click();
+        const saveMessage = this.page.getByRole('alertdialog');
+        await (0, $1UEKj$playwrighttest.expect)(saveMessage).toContainText('Your change was saved');
+    }
+    /* Create a role and assign a principal to it */ async createRoleAndAssignUser(roleName, principal) {
+        await this.page.getByRole('link', {
+            name: 'Roles'
+        }).click();
+        await this.page.getByPlaceholder('Filter by roles').first().waitFor({
+            state: 'visible'
+        });
+        await this.page.locator('body.xl-react-modal-open').waitFor({
+            state: 'hidden'
+        });
+        await this.page.getByRole('button', {
+            name: 'Add role'
+        }).click();
+        const roleDialog = this.page.locator('.add-edit-role-component');
+        await roleDialog.waitFor({
+            state: 'visible'
+        });
+        await roleDialog.locator('input[name="name"]').fill(roleName);
+        const principalsInput = roleDialog.locator('input.react-tagsinput-input');
+        await principalsInput.fill(principal);
+        await principalsInput.press('Enter');
+        await roleDialog.getByRole('button', {
+            name: 'Save'
+        }).click();
+        const saveMessage = this.page.getByRole('alertdialog');
+        await (0, $1UEKj$playwrighttest.expect)(saveMessage).toHaveText(/Role ".*" created/);
+        await saveMessage.waitFor({
+            state: 'hidden'
+        });
+        await roleDialog.waitFor({
+            state: 'hidden'
+        });
+    }
+    /* Delete a role by name */ async deleteRole(roleName) {
+        await this.page.getByRole('link', {
+            name: 'Roles'
+        }).click();
+        const filter = this.page.getByPlaceholder('Filter by roles').first();
+        await filter.fill(roleName);
+        await filter.press('Enter');
+        const escapedRoleName = roleName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const roleRow = this.page.locator('td.roles-table-name').filter({
+            hasText: new RegExp(`^\\s*${escapedRoleName}\\s*$`)
+        }).first().locator('xpath=ancestor::tr');
+        await roleRow.waitFor({
+            state: 'visible'
+        });
+        await roleRow.locator('button.delete.table-action').click();
+        const confirmDelete = this.page.getByRole('button', {
+            name: 'Delete',
+            exact: true
+        });
+        if (await confirmDelete.isVisible()) await confirmDelete.click();
+    }
+}
+
+
+
+class $647b67e126f2dbe0$export$c88e1d16f82516d extends (0, $84f8d1abd29d48fd$export$cb21416f3c2fd176) {
+    /* Helps to navigate to the Overthere LocalHost page */ async navigateToOverthereLocalHostPage() {
+        await this.openRootContextMenu('Infrastructure');
+        await this.page.getByRole('link', {
+            name: 'New'
+        }).click();
+        await this.page.getByRole('link', {
+            name: 'overthere'
+        }).click();
+        await this.page.getByRole('link', {
+            name: 'LocalHost'
+        }).click();
+    }
+    /* Opens the New > overthere > LocalHost form from the Infrastructure tree context menu */ async openNewLocalHost() {
+        await this.closeModalIfPresent();
+        await this.ensureExplorerTreeReady();
+        const infrastructureRoot = this.page.locator('span[data-id="Infrastructure"]');
+        await infrastructureRoot.scrollIntoViewIfNeeded();
+        await infrastructureRoot.click();
+        const contextMenu = this.page.locator('i.context-menu-button[data-id="Infrastructure"]');
+        await contextMenu.scrollIntoViewIfNeeded();
+        await contextMenu.click({
+            force: true
+        });
+        await this.page.getByRole('link', {
+            name: 'New'
+        }).click();
+        await this.page.getByRole('link', {
+            name: 'overthere'
+        }).click();
+        await this.page.getByRole('link', {
+            name: 'LocalHost'
+        }).click();
+    }
+    async openInfrastructureNewLocalHost() {
+        await this.openNewLocalHost();
+    }
+    /* Helps to create a LocalHost of type UNIX/Windows/Zos */ async createHostForGivenType(name, type) {
+        await this.page.locator('input[name="name"]').fill(name);
+        await this.page.locator('label:has-text("Operating system")').locator('xpath=following::input[1]').click();
+        await this.page.getByText(type, {
+            exact: true
+        }).click();
+        await this.page.getByRole('button', {
+            name: 'Save and close'
         }).click();
+        await this.handleSaveToastOrAlreadyExists();
     }
-    async verifySuccessMessage() {
-        const SuccessMessage = this.page.getByRole("alertdialog");
-        await (0, $1UEKj$playwrighttest.expect)(SuccessMessage).toBeVisible();
-        await (0, $1UEKj$playwrighttest.expect)(SuccessMessage).toHaveText(/User ".*" created/i);
+    /**
+   * Runs the "Check connection" control task on the given host node once.
+   * Expects the deployment plan page, executes it, waits for EXECUTED state, then finishes.
+   * @param hostDataId  The full tree data-id, e.g. "Infrastructure/MyHost"
+   */ async runCheckConnection(hostDataId) {
+        // Ensure the tree node is visible by expanding Infrastructure if needed
+        const infraToggle = this.page.locator('div[data-id="Infrastructure"] .infinite-tree-node > a');
+        const hostNode = this.page.locator(`span[data-id="${hostDataId}"]`);
+        for(let attempt = 0; attempt < 3; attempt += 1){
+            if (await hostNode.count() > 0 && await hostNode.isVisible()) break;
+            await infraToggle.click();
+            await this.page.waitForTimeout(500);
+        }
+        // Hover host node to reveal context menu button
+        //await hostNode.scrollIntoViewIfNeeded();
+        await hostNode.hover();
+        const ctxBtn = this.page.locator(`i.context-menu-button[data-id="${hostDataId}"]`);
+        await ctxBtn.waitFor({
+            state: 'visible',
+            timeout: 5000
+        });
+        await ctxBtn.click({
+            force: true
+        });
+        // Click "Check connection" in the context menu
+        await this.page.getByRole('link', {
+            name: 'Check connection'
+        }).click();
+        // Wait for the deployment plan panel and execute
+        await this.page.locator('.xl-react-widget-modal-dialog button.deploy.xl-primary, button.xl-primary:has-text("Execute")').first().waitFor({
+            state: 'visible',
+            timeout: 10000
+        });
+        await this.page.locator('.xl-react-widget-modal-dialog button.deploy.xl-primary, button.xl-primary:has-text("Execute")').first().click();
+        // Wait for EXECUTED status
+        const executedLabel = this.page.locator('span.label', {
+            hasText: 'EXECUTED'
+        }).first();
+        await executedLabel.waitFor({
+            state: 'visible',
+            timeout: 30000
+        });
+        // Finish
+        const finishButton = this.page.locator('button.finish.xl-primary, button:has-text("Finish")').first();
+        if (await finishButton.isVisible()) await finishButton.click();
+        // Wait for modal/plan to close
+        const modal = this.page.locator('div.xl-react-widget-modal-dialog.in');
+        if (await modal.count() > 0) await modal.first().waitFor({
+            state: 'hidden',
+            timeout: 15000
+        });
     }
-    async verifyUserErrorMessage() {
-        await (0, $1UEKj$playwrighttest.expect)(this.page.locator('.rrt-middle-container[role="alertdialog"]').nth(1)).toContainText(/already in use/i);
+}
+
+
+
+class $f8bdd801aee9e08b$export$12530425267834a9 extends (0, $84f8d1abd29d48fd$export$cb21416f3c2fd176) {
+    /* Helps to navigate to the Environments page */ async navigateToEnvironmentsPage() {
+        await this.ensureExplorerTreeReady();
     }
-    async deleteTheUserAndVerifyItIsDeleted(username) {
-        await this.page.locator("p.MuiTypography-root", {
-            hasText: "Users"
+    /* Helps to create a new Environment */ async createEnvironment(environmentName, hostName, dictionaryName) {
+        await this.openRootContextMenu('Environments');
+        await this.page.getByRole('link', {
+            name: 'New'
+        }).click();
+        await this.page.getByRole('link', {
+            name: 'Environment'
+        }).click();
+        await this.page.locator('input[name="name"]').fill(environmentName);
+        await this.page.locator('i.xl-icon.arrow-down-icon.show-all').nth(0).click();
+        await this.page.getByTitle(`Infrastructure/${hostName}`, {
+            exact: true
         }).click();
-        await this.page.waitForTimeout(10000);
-        await this.page.getByPlaceholder("Filter...").fill(username);
-        await this.page.waitForTimeout(10000);
-        await this.page.locator("td.users-table-actions button.delete.xl-icon.table-action").click();
-        await this.page.getByRole("button", {
-            name: "Delete",
+        await this.page.locator('i.xl-icon.arrow-down-icon.show-all').nth(1).click();
+        await this.page.getByTitle(`Environments/${dictionaryName}`, {
             exact: true
         }).click();
-        const DeleteMessage = this.page.getByRole("alertdialog");
-        await (0, $1UEKj$playwrighttest.expect)(DeleteMessage).toBeVisible();
-        await (0, $1UEKj$playwrighttest.expect)(DeleteMessage).toHaveText(/User ".*" deleted/i);
+        await this.page.getByRole('button', {
+            name: 'Save and close'
+        }).click();
+        await this.handleSaveToastOrAlreadyExists();
     }
-    async editUserAndVerify(username, editfullname) {
-        await this.page.locator("p.MuiTypography-root", {
-            hasText: "Users"
+    /* Creates a new udm.Dictionary under Environments with entry usr=admin */ async createDictionary(dictionaryName) {
+        await this.openRootContextMenu('Environments');
+        await this.page.getByRole('link', {
+            name: 'New'
         }).click();
-        await this.page.waitForTimeout(10000);
-        await this.page.getByPlaceholder("Filter...").fill(username);
-        await this.page.waitForTimeout(10000);
-        await this.page.locator("i.icon-edit.dot-i").first().click();
-        await this.page.locator('input[name="fullName"]').fill(editfullname);
-        await this.page.getByRole("button", {
-            name: "Save",
+        await this.page.getByRole('link', {
+            name: 'Dictionary',
             exact: true
         }).click();
-        const EditMessage = this.page.getByRole("alertdialog");
-        await (0, $1UEKj$playwrighttest.expect)(EditMessage).toBeVisible();
-        const editedUsername = this.page.locator("td.users-table-fullName div").textContent();
-        // eslint-disable-next-line no-console
-        console.log(editedUsername);
+        await this.page.locator('input[name="name"]').fill(dictionaryName);
+        // Type the key in the Entries field and press Enter to create the row
+        // (The hint text "Search or create a new key/value" is a div, not a real placeholder)
+        const entriesInput = this.page.getByRole('textbox').nth(3);
+        await entriesInput.fill('usr');
+        await entriesInput.press('Enter');
+        // Fill the value field that appears after the key is created
+        await this.page.getByRole('textbox', {
+            name: 'Add value...'
+        }).fill('admin');
+        await this.page.getByRole('button', {
+            name: 'Save and close'
+        }).click();
+        await this.handleSaveToastOrAlreadyExists();
     }
 }
 
 
-class $28788a34e6bbbe3d$export$b8a61e5c71402559 {
+
+
+class $408106958eb335da$export$1533b625ec0c75e2 extends (0, $84f8d1abd29d48fd$export$cb21416f3c2fd176) {
     constructor(page){
-        this.page = page;
+        super(page);
+    }
+    /* Helps to navigate to the Applications page */ async navigateToApplicationsPage() {
+        await this.openRootContextMenu('Applications');
+        await this.page.getByRole('link', {
+            name: 'New'
+        }).click();
+        await this.page.getByRole('link', {
+            name: 'Application'
+        }).click();
+    }
+    /* Creates a new application */ async createNewApplication(applicationName) {
+        if (await this.nodeExists(`Applications/${applicationName}`)) return;
+        await this.openRootContextMenu('Applications');
+        await this.page.getByRole('link', {
+            name: 'New'
+        }).click();
+        await this.page.getByRole('link', {
+            name: 'Application'
+        }).click();
+        await this.page.locator('input[name="name"]').waitFor({
+            state: 'visible'
+        });
+        await this.page.locator('input[name="name"]').click();
+        await this.page.locator('input[name="name"]').fill(applicationName);
+        await this.page.getByRole('button', {
+            name: 'Save and close'
+        }).click();
+        await this.page.locator('input[name="name"]').waitFor({
+            state: 'hidden',
+            timeout: 5000
+        });
+        await this.handleSaveToastOrAlreadyExists();
+        await this.waitForApplicationNode(applicationName);
+    }
+    /* Creates a new deployment package */ async createNewDeploymentPackage(applicationName, packageName) {
+        const appDataId = `Applications/${applicationName}`;
+        const packageDataId = `Applications/${applicationName}/${packageName}`;
+        if (await this.nodeExists(packageDataId)) return;
+        // Expand Applications
+        await this.ensureExplorerTreeReady();
+        await this.waitForApplicationNode(applicationName);
+        // Hover over app node
+        const appNode = this.page.locator(`span[data-id="${appDataId}"]`);
+        await (0, $1UEKj$playwrighttest.expect)(appNode).toBeVisible();
+        await appNode.scrollIntoViewIfNeeded();
+        await appNode.hover();
+        // Open context menu + create new deployment package
+        const contextMenu = this.page.locator(`i.context-menu-button[data-id="${appDataId}"]`);
+        await (0, $1UEKj$playwrighttest.expect)(contextMenu).toBeVisible();
+        await contextMenu.click();
+        await this.page.getByRole('link', {
+            name: 'New'
+        }).click();
+        await this.page.getByRole('link', {
+            name: 'Deployment Package'
+        }).click();
+        // Fill & save
+        const nameInput = this.page.locator('input[name="name"]');
+        await nameInput.fill(packageName);
+        await this.page.getByRole('button', {
+            name: 'Save and close'
+        }).click();
+        await nameInput.waitFor({
+            state: 'hidden',
+            timeout: 5000
+        });
+        await this.handleSaveToastOrAlreadyExists();
+        await this.waitForPackageNode(applicationName, packageName);
+    }
+    /* Creates a new command application */ async createNewCmdApplication(values) {
+        const appDataId = `Applications/${values[0]}`;
+        const packageDataId = `Applications/${values[0]}/${values[1]}`;
+        const commandDataId = `Applications/${values[0]}/${values[1]}/${values[2]}`;
+        if (await this.nodeExists(commandDataId)) return;
+        // Expand app node and click package
+        await this.ensureExplorerTreeReady();
+        await this.waitForApplicationNode(values[0]);
+        await this.waitForPackageNode(values[0], values[1]);
+        await this.page.locator(`div[data-id="${appDataId}"] .infinite-tree-node > a`).click();
+        await this.clickPackageNodeWithRetry(packageDataId);
+        // Open context menu
+        const packageMenu = this.page.locator(`i.context-menu-button[data-id="${packageDataId}"]`);
+        await (0, $1UEKj$playwrighttest.expect)(packageMenu).toBeVisible();
+        await packageMenu.click();
+        // Create Command application
+        await this.page.getByRole('link', {
+            name: 'New'
+        }).click();
+        await this.page.getByRole('link', {
+            name: 'cmd'
+        }).click();
+        await this.page.getByRole('link', {
+            name: 'Command'
+        }).click();
+        await this.page.locator('input[name="name"]').fill(values[2]);
+        await this.page.locator('textarea[name="commandLine"]').fill(values[3]);
+        // Some server configs default username to {{usr}} placeholder. Use evaluate to
+        // set value directly on DOM + fire React's change event, bypassing visibility checks.
+        await this.page.evaluate(()=>{
+            const inputs = Array.from(document.querySelectorAll('input[name="username"]'));
+            const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
+            for (const input of inputs){
+                setter?.call(input, 'admin');
+                input.dispatchEvent(new Event('input', {
+                    bubbles: true
+                }));
+                input.dispatchEvent(new Event('change', {
+                    bubbles: true
+                }));
+            }
+        });
+        const saveBtn = this.page.locator('button', {
+            hasText: /^Save$/
+        }).first();
+        await (0, $1UEKj$playwrighttest.expect)(saveBtn).toBeEnabled();
+        await saveBtn.click();
+        await this.page.waitForTimeout(3000);
+        await this.handleSaveToastOrAlreadyExists();
+        // Close dialog
+        await this.page.locator('i.xl-icon.close-icon').first().click();
+    }
+    /*Deploy the application*/ async deployApp(values) {
+        const versionNode = `Applications/${values[0]}/${values[1]}`;
+        await this.ensureExplorerTreeReady();
+        await this.waitForPackageNode(values[0], values[1]);
+        await this.openPackageMenuWithRetry(versionNode);
+        await this.page.getByRole('link', {
+            name: 'Deploy',
+            exact: true
+        }).click();
+        await this.page.locator(`input[name="selections"][value="Environments/${values[2]}"]`).click();
+        await this.page.getByRole('button', {
+            name: 'Continue'
+        }).click();
+        // Wait for the deployment properties wizard to fully load and evaluate validation rules
+        await this.page.locator('.errors-wrapper').waitFor({
+            state: 'attached',
+            timeout: 15000
+        });
+        const errorIcon = this.page.locator('a.validation-icons-wrapper.error');
+        // Actively wait for the error icon to appear — isVisible() alone races against wizard rendering
+        let hasError = false;
+        try {
+            await errorIcon.waitFor({
+                state: 'visible',
+                timeout: 5000
+            });
+            hasError = true;
+        } catch  {
+        // No validation errors detected
+        }
+        if (hasError) {
+            await this.page.getByRole('button', {
+                name: 'Deployment Properties'
+            }).click();
+            const usernameInput = this.page.locator('input[name="username"]');
+            await usernameInput.waitFor({
+                state: 'visible'
+            });
+            await usernameInput.fill(values[3]);
+            await this.page.getByRole('button', {
+                name: 'Save'
+            }).click();
+            await errorIcon.waitFor({
+                state: 'hidden',
+                timeout: 10000
+            });
+        }
+        await this.page.locator('button.deploy.xl-primary').waitFor({
+            state: 'visible'
+        });
+        await this.page.locator('button.deploy.xl-primary').click();
+        //Get the task id
+        const taskIdLocator = this.page.locator('div.task-id').first();
+        await (0, $1UEKj$playwrighttest.expect)(taskIdLocator).toBeVisible({
+            timeout: 60000
+        });
+        await (0, $1UEKj$playwrighttest.expect)(taskIdLocator).not.toHaveText('', {
+            timeout: 60000
+        });
+        this.taskId = (await taskIdLocator.textContent() ?? '').trim();
+        //Verify no failure and all are done
+        const labels = this.page.locator('span.label');
+        await (0, $1UEKj$playwrighttest.expect)(labels).toHaveCount(3);
+        await (0, $1UEKj$playwrighttest.expect)(labels).toHaveText([
+            'EXECUTED',
+            'DONE',
+            'DONE'
+        ]);
+        //Get the text executed
+        await this.page.locator('div[data-id="0_1_1"] .infinite-tree-node > a').click();
+        await this.page.getByTitle('Execute Test Command').click();
+        this.executedText = await this.page.locator('div.step-log-body pre').nth(1).innerText();
+        //Verify in monitoring tab searching with the task id
+        await this.page.locator('div[data-id="TASK_MONITOR"] .infinite-tree-node > a').click();
+        await this.page.locator('span[data-id="DEPLOYMENT_TASKS"]').dblclick();
+        await this.page.waitForTimeout(5000);
+        await this.page.locator('div.deployment-task-filter-task-id input[placeholder="Search"]').first().fill(this.taskId);
+        const stateText = await this.page.locator('td.tasks-table-state').first().innerText();
+        (0, $1UEKj$playwrighttest.expect)(stateText.trim()).toBe('Executed');
+        //Click the row to go to deployment screen
+        await this.page.locator('table.table.table-striped tbody tr').first().dblclick();
+        await this.page.locator('button.finish.xl-primary').click();
+    }
+    /* Deploys or redeploys the application in bulk — exact copy of deployApp flow with forceRedeploy */ async deployAppBulk(values) {
+        const versionNode = `Applications/${values[0]}/${values[1]}`;
+        await this.ensureExplorerTreeReady();
+        await this.waitForPackageNode(values[0], values[1]);
+        await this.openPackageMenuWithRetry(versionNode);
+        await this.page.getByRole('link', {
+            name: 'Deploy',
+            exact: true
+        }).click();
+        await this.page.locator(`input[name="selections"][value="Environments/${values[2]}"]`).click();
+        await this.page.getByRole('button', {
+            name: 'Continue'
+        }).click();
+        // Wait for the deployment properties wizard to fully load and evaluate validation rules
+        await this.page.locator('.errors-wrapper').waitFor({
+            state: 'attached',
+            timeout: 15000
+        });
+        const errorIcon = this.page.locator('a.validation-icons-wrapper.error');
+        let hasError = false;
+        try {
+            await errorIcon.waitFor({
+                state: 'visible',
+                timeout: 5000
+            });
+            hasError = true;
+        } catch  {
+        // No validation errors detected
+        }
+        // Always open Deployment Properties to set forceRedeploy=true
+        await this.page.getByRole('button', {
+            name: 'Deployment Properties'
+        }).click();
+        const usernameInput = this.page.locator('input[name="username"]');
+        if (hasError) {
+            await usernameInput.waitFor({
+                state: 'visible'
+            });
+            await usernameInput.fill(values[3]);
+        }
+        const forceRedeployInput = this.page.locator('input[name="forceRedeploy"]');
+        await forceRedeployInput.waitFor({
+            state: 'visible',
+            timeout: 10000
+        });
+        if (!await forceRedeployInput.isChecked()) await forceRedeployInput.check();
+        await this.page.getByRole('button', {
+            name: 'Save'
+        }).click();
+        if (hasError) await errorIcon.waitFor({
+            state: 'hidden',
+            timeout: 10000
+        });
+        await this.page.locator('button.deploy.xl-primary').waitFor({
+            state: 'visible'
+        });
+        await this.page.locator('button.deploy.xl-primary').click();
+        const labels = this.page.locator('span.label');
+        await (0, $1UEKj$playwrighttest.expect)(labels).toHaveCount(3, {
+            timeout: 120000
+        });
+        await (0, $1UEKj$playwrighttest.expect)(labels).toHaveText([
+            'EXECUTED',
+            'DONE',
+            'DONE'
+        ], {
+            timeout: 120000
+        });
+        const finishButton = this.page.locator('button.finish.xl-primary');
+        if (await finishButton.isVisible()) await finishButton.click();
+        await this.page.locator('div.xl-react-widget-modal-dialog.in').waitFor({
+            state: 'hidden',
+            timeout: 30000
+        });
+    }
+    /* Redeploy the same package repeatedly — delegates to deployAppBulk (forceRedeploy already set). 
+  async redeployAppBulk(values: string[]): Promise<void> {
+    await this.deployAppBulk(values);
+  }*/ async verifyApplicationIsVisibleToTheUser(applicationName) {
+        //await this.navigation.homePage.clickExplorer();
+        await this.assertTreeNodeVisibility('Applications', applicationName, {
+            shouldBeVisible: true
+        });
+    }
+    async verifyCiNodesVisibility(nodes, shouldBeVisible, page = this.page) {
+        const { applicationName: applicationName, environmentName: environmentName, infrastructureName: infrastructureName } = nodes;
+        await page.locator('button.dot-avatar').waitFor({
+            state: 'visible',
+            timeout: 30000
+        });
+        const currentUrl = page.url();
+        if (!/#\/explorer/.test(currentUrl)) await page.goto('/#/explorer');
+        await page.waitForURL(/#\/explorer/);
+        await page.locator('div[data-id="Applications"]').waitFor({
+            state: 'visible',
+            timeout: 15000
+        });
+        await this.assertTreeNodeVisibility('Applications', applicationName, {
+            shouldBeVisible: shouldBeVisible,
+            page: page
+        });
+        await this.assertTreeNodeVisibility('Environments', environmentName, {
+            shouldBeVisible: shouldBeVisible,
+            page: page
+        });
+        await this.assertTreeNodeVisibility('Infrastructure', infrastructureName, {
+            shouldBeVisible: shouldBeVisible,
+            page: page
+        });
+    }
+    async assertTreeNodeVisibility(rootName, childName, { page: page = this.page, shouldBeVisible: shouldBeVisible }) {
+        const rootToggle = page.locator(`div[data-id="${rootName}"] .infinite-tree-node > a`);
+        await (0, $1UEKj$playwrighttest.expect)(rootToggle).toBeVisible();
+        await rootToggle.click();
+        await page.locator(`div[data-id="${rootName}"]`).waitFor({
+            state: 'visible'
+        });
+        await page.waitForTimeout(1500);
+        const childNode = page.locator(`span[data-id="${rootName}/${childName}"]`);
+        if (shouldBeVisible) {
+            if (!await childNode.isVisible()) {
+                await rootToggle.click();
+                await page.waitForTimeout(1000);
+            }
+            await (0, $1UEKj$playwrighttest.expect)(childNode).toBeVisible();
+        } else await (0, $1UEKj$playwrighttest.expect)(childNode).toHaveCount(0);
+    }
+    async refreshExplorerTree() {
+        const refreshButton = this.page.getByRole('button', {
+            name: 'Refresh'
+        }).first();
+        if (await refreshButton.isVisible()) {
+            await refreshButton.click();
+            await this.page.waitForLoadState('networkidle');
+        }
+    }
+    async nodeExists(dataId) {
+        await this.ensureExplorerTreeReady();
+        const node = this.page.locator(`span[data-id="${dataId}"]`);
+        if (await node.count() > 0) return true;
+        await this.refreshExplorerTree();
+        return await node.count() > 0;
+    }
+    async waitForApplicationNode(applicationName) {
+        const appDataId = `Applications/${applicationName}`;
+        const appNode = this.page.locator(`span[data-id="${appDataId}"]`);
+        const rootToggle = this.page.locator('div[data-id="Applications"] .infinite-tree-node > a');
+        await this.ensureExplorerTreeReady();
+        await rootToggle.waitFor({
+            state: 'visible'
+        });
+        for(let attempt = 0; attempt < 3; attempt += 1){
+            if (await appNode.count() === 0 || !await appNode.isVisible()) {
+                await rootToggle.click();
+                await this.page.waitForTimeout(500);
+            }
+            try {
+                await (0, $1UEKj$playwrighttest.expect)(appNode).toBeVisible({
+                    timeout: 5000
+                });
+                return;
+            } catch  {
+                await this.refreshExplorerTree();
+            }
+        }
+        await (0, $1UEKj$playwrighttest.expect)(appNode).toBeVisible({
+            timeout: 15000
+        });
+    }
+    async waitForPackageNode(applicationName, packageName) {
+        const packageDataId = `Applications/${applicationName}/${packageName}`;
+        const packageNode = this.page.locator(`span[data-id="${packageDataId}"]`);
+        const appRow = this.page.locator(`div[data-id="Applications/${applicationName}"]`);
+        const appToggle = appRow.locator('.infinite-tree-node > a');
+        // Detects whether the app is already expanded (has any visible child span)
+        const anyChildNode = this.page.locator(`span[data-id^="Applications/${applicationName}/"]`).first();
+        await this.waitForApplicationNode(applicationName);
+        await appRow.scrollIntoViewIfNeeded();
+        await appToggle.waitFor({
+            state: 'visible'
+        });
+        for(let attempt = 0; attempt < 5; attempt += 1){
+            // Only click the toggle if the node is currently collapsed — prevents accidental collapse
+            if (!await anyChildNode.isVisible()) {
+                await appToggle.scrollIntoViewIfNeeded();
+                await appToggle.click({
+                    force: true
+                });
+                await this.page.waitForTimeout(500);
+            }
+            try {
+                await (0, $1UEKj$playwrighttest.expect)(packageNode).toBeVisible({
+                    timeout: 5000
+                });
+                return;
+            } catch  {
+                // Package still not visible — refresh tree and re-expand on next attempt
+                await this.refreshExplorerTree();
+                await this.waitForApplicationNode(applicationName);
+                await appToggle.waitFor({
+                    state: 'visible'
+                });
+            }
+        }
+        await (0, $1UEKj$playwrighttest.expect)(packageNode).toBeVisible({
+            timeout: 15000
+        });
+    }
+    async clickPackageNodeWithRetry(packageDataId) {
+        const appName = packageDataId.split('/')[1];
+        for(let attempt = 0; attempt < 3; attempt += 1){
+            const appRow = this.page.locator(`div[data-id="Applications/${appName}"]`);
+            const appToggle = appRow.locator('.infinite-tree-node > a');
+            try {
+                await appToggle.scrollIntoViewIfNeeded();
+            } catch  {
+            // Tree can re-render between retries; re-query next loop.
+            }
+            await appToggle.click({
+                force: true
+            });
+            const packageNode = this.page.locator(`span[data-id="${packageDataId}"]`).first();
+            await (0, $1UEKj$playwrighttest.expect)(packageNode).toBeVisible({
+                timeout: 5000
+            });
+            try {
+                await packageNode.click();
+                return;
+            } catch  {
+                await this.page.waitForTimeout(300);
+            }
+        }
+        await this.page.locator(`span[data-id="${packageDataId}"]`).first().click();
+    }
+    async openPackageMenuWithRetry(versionDataId) {
+        const appName = versionDataId.split('/')[1];
+        const appToggle = this.page.locator(`div[data-id="Applications/${appName}"] .infinite-tree-node > a`);
+        // The context-menu button is CSS-hidden until the tree row is hovered.
+        // Hover the node row first so the button becomes visible, then click it.
+        const nodeRow = this.page.locator(`div[data-id="${versionDataId}"] .infinite-tree-node`);
+        for(let attempt = 0; attempt < 3; attempt += 1){
+            const menuButton = this.page.locator(`i.context-menu-button[data-id="${versionDataId}"]`).first();
+            try {
+                await nodeRow.hover({
+                    timeout: 5000
+                });
+                await (0, $1UEKj$playwrighttest.expect)(menuButton).toBeVisible({
+                    timeout: 5000
+                });
+                await menuButton.click();
+                return;
+            } catch  {
+                await appToggle.click();
+                await this.page.waitForTimeout(300);
+            }
+        }
+        await this.page.locator(`i.context-menu-button[data-id="${versionDataId}"]`).first().click({
+            force: true
+        });
+    }
+}
+
+
+
+
+class $b2f725a937c99e2d$export$b8a443164510a1b4 extends (0, $ae23b16684112d0b$export$2b65d1d97338f32b) {
+    async openTab(tabLabel, paneId) {
+        const tab = this.page.locator('.app-root .dot-sidebar .dot-list p').filter({
+            hasText: tabLabel
+        }).first();
+        await tab.scrollIntoViewIfNeeded();
+        await tab.click();
+        await this.page.locator(`#pane-${paneId}`).waitFor({
+            state: 'visible',
+            timeout: 20000
+        });
+    }
+    async downloadReport(buttonLabel, paneId, selector) {
+        const pane = this.page.locator(`#pane-${paneId}`);
+        const exportButton = selector ? pane.locator(selector) : pane.getByRole('button', {
+            name: buttonLabel
+        });
+        const fallbackButton = pane.locator('button:has-text("Export")');
+        const downloadPromise = this.page.waitForEvent('download', {
+            timeout: 20000
+        });
+        if (await exportButton.isVisible()) await exportButton.click();
+        else await fallbackButton.first().click();
+        return downloadPromise;
+    }
+    async openDashboardTab() {
+        await this.openTab('Dashboard', 'DashboardTab');
+    }
+    async openDeploymentsTab() {
+        await this.openTab('Deployments', 'DeploymentsTab');
+    }
+    async openControlTasksTab() {
+        await this.openTab('Control tasks', 'ControlTasksTab');
+    }
+    async openAuditReportTab() {
+        await this.openTab('Audit report', 'AuditReportTab');
+    }
+    async downloadDeploymentsExport() {
+        return this.downloadReport('Export report', 'DeploymentsTab');
+    }
+    async downloadControlTasksExport() {
+        return this.downloadReport('Export report', 'ControlTasksTab');
+    }
+    async downloadAuditReportExport() {
+        return this.downloadReport('Export report', 'AuditReportTab');
+    }
+    /* Clicks on the Deployment Tasks section */ async clickDeploymentTasks() {
+        await this.page.locator('p.MuiTypography-root', {
+            hasText: 'Deployments'
+        }).click();
+    }
+    async verifyTheDeploymentValues(values) {
+        await this.page.locator('div.deployment-task-filter-task-id input[placeholder="Search"]:visible').first().fill(values[0]);
+        const escapedApp = values[2].replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const escapedPkg = values[3].replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const packagePattern = new RegExp(`${escapedApp}/${escapedPkg}`, 'i');
+        const row = this.page.locator('table.table-striped tbody tr').filter({
+            has: this.page.locator('td.report-table-package .deployment-report-package', {
+                hasText: packagePattern
+            })
+        }).first();
+        await row.waitFor({
+            state: 'visible',
+            timeout: 5000
+        });
+        const packageCell = row.locator('td.report-table-package .deployment-report-package').first();
+        await (0, $1UEKj$playwrighttest.expect)(packageCell).toContainText(packagePattern);
+        await (0, $1UEKj$playwrighttest.expect)(row.locator('td.report-table-originalType .deployment-report-task-type')).toHaveText(/Initial/i);
+        await (0, $1UEKj$playwrighttest.expect)(row.locator('td.report-table-user .deployment-report-user')).toHaveText('admin');
+        //Click the row
+        await packageCell.dblclick();
+        await this.page.locator('div[data-id="0_1_1"] .infinite-tree-node > a').click();
+        await this.page.getByTitle('Execute Test Command').click();
+        //Get the log text
+        const text = await this.page.locator('div.step-log-body pre').nth(1).innerText();
+        //Verify both the log text are same
+        (0, $1UEKj$playwrighttest.expect)(text).toContain(values[1]);
+    }
+}
+
+
+
+
+class $1b52322f0063c4bc$export$5c1198389e139c11 extends (0, $ae23b16684112d0b$export$2b65d1d97338f32b) {
+    getPane() {
+        return this.page.locator('#pane-ControlTasksTab');
+    }
+    getPagination() {
+        return this.getPane().locator('.react-bootstrap-table-pagination');
+    }
+    getTableBody() {
+        return this.getPane().locator('.react-bootstrap-table tbody');
+    }
+    getLastUpdated() {
+        return this.getPane().locator('.last-updated-component');
+    }
+    // ── Navigation ───────────────────────────────────────────────────────────
+    async verifySelected() {
+        const pane = this.getPane();
+        await (0, $1UEKj$playwrighttest.expect)(pane).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(this.page.locator('.dot-sidebar a[href*="controltasks"], .dot-sidebar .dot-list p', {
+            hasText: 'Control tasks'
+        }).first()).toBeVisible();
+    }
+    // ── Filters ───────────────────────────────────────────────────────────────
+    async verifyFiltersVisible() {
+        const pane = this.getPane();
+        const filtersPanel = pane.locator('.xl-react-redux-table-filters-panel');
+        await (0, $1UEKj$playwrighttest.expect)(filtersPanel).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.control-task-filter-targets .react-tagsinput-input')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.control-task-filter-task-name input[placeholder="Search"]')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.control-task-id input[placeholder="Search"]')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.control-task-filter-start-date')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.control-task-filter-end-date')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.control-task-filter-worker input[placeholder="Search"]')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.control-task-filter-state .react-tagsinput-input')).toBeVisible();
+    }
+    async hideFilters() {
+        const pane = this.getPane();
+        const filtersPanel = pane.locator('.xl-react-redux-table-filters-panel');
+        const hideFiltersButton = pane.getByRole('button', {
+            name: 'Hide filters'
+        });
+        await (0, $1UEKj$playwrighttest.expect)(filtersPanel).toBeVisible();
+        await hideFiltersButton.click();
+        await (0, $1UEKj$playwrighttest.expect)(filtersPanel).toBeHidden();
+    }
+    async showFilters() {
+        const pane = this.getPane();
+        const filtersPanel = pane.locator('.xl-react-redux-table-filters-panel');
+        const showFiltersButton = pane.getByRole('button', {
+            name: 'Show filters'
+        });
+        if (await filtersPanel.isVisible()) return;
+        for(let attempt = 0; attempt < 3; attempt += 1){
+            if (await showFiltersButton.isVisible()) await showFiltersButton.click({
+                force: true
+            });
+            if (await filtersPanel.isVisible()) return;
+            await this.page.waitForTimeout(300);
+        }
+        await (0, $1UEKj$playwrighttest.expect)(filtersPanel).toBeVisible();
+    }
+    async ensureFiltersVisible() {
+        const pane = this.getPane();
+        const filtersPanel = pane.locator('.xl-react-redux-table-filters-panel');
+        if (await filtersPanel.isVisible()) return;
+        const showFiltersButton = pane.getByRole('button', {
+            name: 'Show filters'
+        });
+        if (await showFiltersButton.isVisible()) await showFiltersButton.click({
+            force: true
+        });
+        await (0, $1UEKj$playwrighttest.expect)(filtersPanel).toBeVisible();
+    }
+    // ── Date filters ─────────────────────────────────────────────────────────
+    async setStartDate(value) {
+        const field = this.getPane().locator('.control-task-filter-start-date');
+        await field.click();
+        await field.fill(value);
+        await this.getLastUpdated().click({
+            force: true
+        });
+    }
+    async setEndDate(value) {
+        const field = this.getPane().locator('.control-task-filter-end-date');
+        await field.click();
+        await field.fill(value);
+        await this.getLastUpdated().click({
+            force: true
+        });
+    }
+    async expectStartDateValue(value) {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPane().locator('.control-task-filter-start-date')).toHaveValue(value);
+    }
+    async expectEndDateValue(value) {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPane().locator('.control-task-filter-end-date')).toHaveValue(value);
+    }
+    async checkInvalidStartDateError() {
+        const field = this.getPane().locator('.control-task-filter-start-date');
+        await field.click();
+        await field.press('End');
+        await field.press('a');
+        await this.page.keyboard.press('Escape');
+        await (0, $1UEKj$playwrighttest.expect)(this.getPane().getByText('Example: Dec 1, 2018').first()).toBeVisible();
+    }
+    async checkInvalidEndDateError() {
+        const field = this.getPane().locator('.control-task-filter-end-date');
+        await field.click();
+        await field.press('End');
+        await field.press('b');
+        await this.page.keyboard.press('Escape');
+        await (0, $1UEKj$playwrighttest.expect)(this.getPane().getByText('Example: Dec 1, 2018').first()).toBeVisible();
+    }
+    async expectNoStartDateError() {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPane().getByText('Example: Dec 1, 2018')).toHaveCount(0);
+    }
+    async expectNoEndDateError() {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPane().getByText('Example: Dec 1, 2018')).toHaveCount(0);
+    }
+    // ── Tag filters ───────────────────────────────────────────────────────────
+    async selectTargetsTagsFilter(text, optionName) {
+        await this.selectTagsFilterFirstSuggestion('.control-task-filter-targets .react-tagsinput', text, optionName);
+    }
+    async clearTargetsTagsFirstTag() {
+        const remove = this.getPane().locator('.control-task-filter-targets .react-tagsinput-tag:nth-child(1) .react-tagsinput-remove');
+        if (await remove.count()) await remove.click();
+    }
+    async selectStatesTagsFilter(text, optionName) {
+        await this.selectTagsFilterFirstSuggestion('.control-task-filter-state .react-tagsinput', text, optionName);
+    }
+    async clearStatesTagsFirstTag() {
+        const remove = this.getPane().locator('.control-task-filter-state .react-tagsinput-tag:nth-child(1) .react-tagsinput-remove');
+        if (await remove.count()) await remove.click();
+    }
+    // ── Text filters ──────────────────────────────────────────────────────────
+    async filterByTaskName(name) {
+        await this.getPane().locator('.control-task-filter-task-name input[placeholder="Search"]').fill(name);
+    }
+    async clearTaskName() {
+        await this.filterByTaskName('');
+    }
+    async filterByTaskId(id) {
+        await this.getPane().locator('.control-task-id input[placeholder="Search"]').fill(id);
+    }
+    async clearTaskId() {
+        await this.filterByTaskId('');
+    }
+    async filterByWorker(worker) {
+        await this.getPane().locator('.control-task-filter-worker input[placeholder="Search"]').fill(worker);
+    }
+    async clearWorkerFilter() {
+        await this.filterByWorker('');
+    }
+    // ── Tasks toggle ──────────────────────────────────────────────────────────
+    async clickMyTasks() {
+        await this.getPane().getByRole('button', {
+            name: 'My tasks'
+        }).click();
+    }
+    async clickAllTasks() {
+        await this.getPane().getByRole('button', {
+            name: 'All tasks'
+        }).click();
+    }
+    // ── Toolbar ───────────────────────────────────────────────────────────────
+    async clickRefresh() {
+        await this.getPane().getByRole('button', {
+            name: 'Refresh'
+        }).click();
+    }
+    async verifyLastUpdatedAndRefresh() {
+        const lastUpdated = this.getLastUpdated();
+        await (0, $1UEKj$playwrighttest.expect)(lastUpdated).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(lastUpdated).not.toHaveText('');
+        await this.getPane().getByRole('button', {
+            name: 'Refresh'
+        }).click();
+        await (0, $1UEKj$playwrighttest.expect)(lastUpdated).toBeVisible();
+    }
+    // ── Table assertions ──────────────────────────────────────────────────────
+    async verifyTableHasRowsOrEmpty() {
+        const pane = this.getPane();
+        const table = pane.locator('table.table-striped');
+        await (0, $1UEKj$playwrighttest.expect)(table).toBeVisible();
+        const rows = this.getTableBody().locator('tr');
+        const noDataCell = this.getTableBody().locator('td.react-bs-table-no-data');
+        const emptyState = pane.getByText(/No report data available/i);
+        await (0, $1UEKj$playwrighttest.expect)(async ()=>{
+            if (await rows.count() > 0) return true;
+            if (await noDataCell.count() > 0 && await noDataCell.first().isVisible()) return true;
+            if (await emptyState.count() > 0 && await emptyState.first().isVisible()) return true;
+            return false;
+        }).toBeTruthy();
+    }
+    async verifyTableColumns() {
+        const headers = this.getPane().locator('.react-bootstrap-table thead th');
+        await (0, $1UEKj$playwrighttest.expect)(headers.filter({
+            hasText: 'Control task name'
+        })).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(headers.filter({
+            hasText: 'Target CI'
+        })).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(headers.filter({
+            hasText: 'Description'
+        })).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(headers.filter({
+            hasText: 'User'
+        })).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(headers.filter({
+            hasText: 'State'
+        })).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(headers.filter({
+            hasText: 'Start date'
+        })).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(headers.filter({
+            hasText: 'End date'
+        })).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(headers.filter({
+            hasText: 'Worker'
+        })).toBeVisible();
+    }
+    async waitForTableReady() {
+        await (0, $1UEKj$playwrighttest.expect)(async ()=>{
+            const loading = await this.getPane().getByText('Data loading').count();
+            (0, $1UEKj$playwrighttest.expect)(loading).toBe(0);
+            const table = this.getPane().locator('table.table-striped');
+            (0, $1UEKj$playwrighttest.expect)(await table.count()).toBeGreaterThan(0);
+        }).toPass({
+            timeout: 20000
+        });
+    }
+    async expectNumberOfRows(count) {
+        await this.waitForTableReady();
+        await (0, $1UEKj$playwrighttest.expect)(this.getTableBody().locator('tr')).toHaveCount(count);
+    }
+    async expectAtLeastNumberOfRows(count) {
+        await this.waitForTableReady();
+        await (0, $1UEKj$playwrighttest.expect)(async ()=>{
+            const total = await this.getTableBody().locator('tr').count();
+            (0, $1UEKj$playwrighttest.expect)(total).toBeGreaterThanOrEqual(count);
+        }).toPass({
+            timeout: 30000
+        });
+    }
+    async expectTotal(total) {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPagination().locator('> div').filter({
+            hasText: 'Total:'
+        })).toContainText(`Total: ${total}`);
+    }
+    async expectAtLeastTotal(count) {
+        await this.waitForTableReady();
+        await (0, $1UEKj$playwrighttest.expect)(async ()=>{
+            const text = await this.getPagination().locator('> div').filter({
+                hasText: 'Total:'
+            }).textContent();
+            const match = text?.match(/Total:\s*(\d+)/);
+            const total = match ? Number(match[1]) : 0;
+            (0, $1UEKj$playwrighttest.expect)(total).toBeGreaterThanOrEqual(count);
+        }).toPass();
+    }
+    async getTotalCount() {
+        await this.waitForTableReady();
+        const text = await this.getPagination().locator('> div').filter({
+            hasText: 'Total:'
+        }).textContent();
+        const match = text?.match(/Total:\s*(\d+)/);
+        return match ? Number(match[1]) : 0;
+    }
+    async expectValue(row, column, expected) {
+        const cell = this.getTableBody().locator(`tr:nth-child(${row}) td.report-table-${column}`);
+        await (0, $1UEKj$playwrighttest.expect)(cell).toHaveText(expected);
+    }
+    async expectValueContains(row, column, expected) {
+        const cell = this.getTableBody().locator(`tr:nth-child(${row}) td.report-table-${column}`);
+        await (0, $1UEKj$playwrighttest.expect)(cell).toContainText(expected);
+    }
+    async shouldHaveScrollBar() {
+        await this.waitForTableReady();
+        const container = this.getPane().locator('div.report');
+        const overflowX = await container.evaluate((el)=>window.getComputedStyle(el).overflowX);
+        (0, $1UEKj$playwrighttest.expect)([
+            'auto',
+            'scroll'
+        ]).toContain(overflowX);
+    }
+    // ── Sorting ───────────────────────────────────────────────────────────────
+    async sortBy(column) {
+        await this.getPane().locator(`.react-bootstrap-table thead th.report-table-${column}`).click();
+    }
+    async verifyIsSorted(column) {
+        const sortOrder = this.getPane().locator(`.react-bootstrap-table thead th.report-table-${column} .react-bootstrap-table-sort-order`);
+        await (0, $1UEKj$playwrighttest.expect)(sortOrder).toBeVisible();
+    }
+    async getColumnValues(column) {
+        await this.waitForTableReady();
+        const cells = this.getTableBody().locator(`tr td.report-table-${column}`);
+        const count = await cells.count();
+        const values = [];
+        for(let i = 0; i < count; i += 1)values.push((await cells.nth(i).textContent())?.trim() ?? '');
+        return values;
+    }
+    // ── Pagination ────────────────────────────────────────────────────────────
+    async getLastPageNumber() {
+        await this.waitForTableReady();
+        const links = this.getPagination().getByRole('list').getByRole('link');
+        const count = await links.count();
+        if (count < 2) return 1;
+        const text = await links.nth(count - 2).textContent();
+        const num = Number(text?.trim());
+        return Number.isFinite(num) && num > 0 ? num : 1;
+    }
+    async goToPage(page) {
+        await this.getPagination().getByRole('link', {
+            name: page.toString(),
+            exact: true
+        }).click();
+    }
+    async goToFirstPage() {
+        const firstLink = this.getPagination().getByRole('link', {
+            name: '<<'
+        });
+        if (await firstLink.count()) await firstLink.click();
+        else await this.getPagination().getByRole('link', {
+            name: '1',
+            exact: true
+        }).click();
+    }
+    async goToLastPage() {
+        const lastLink = this.getPagination().getByRole('link', {
+            name: '>>'
+        });
+        if (await lastLink.count()) await lastLink.click();
+        else {
+            const links = this.getPagination().getByRole('list').getByRole('link');
+            const count = await links.count();
+            await links.nth(count - 2).click();
+        }
+    }
+    async goToPreviousPage() {
+        await this.getPagination().getByRole('link', {
+            name: '<',
+            exact: true
+        }).click();
+    }
+    async goToNextPage() {
+        await this.getPagination().getByRole('link', {
+            name: '>',
+            exact: true
+        }).click();
+    }
+    async expectPage(page) {
+        await (0, $1UEKj$playwrighttest.expect)(async ()=>{
+            const pagination = this.getPagination();
+            const activeLink = pagination.locator('li.active').getByRole('link', {
+                name: page.toString(),
+                exact: true
+            });
+            if (await activeLink.count() > 0) return;
+            const ariaCurrent = pagination.locator('[aria-current="page"]').filter({
+                hasText: page.toString()
+            });
+            if (await ariaCurrent.count() > 0) return;
+            // When there is only 1 page, the pagination may not render page links at all.
+            // In that case page 1 is implicitly active.
+            if (page === 1) {
+                const nextLink = pagination.getByRole('link', {
+                    name: '>',
+                    exact: true
+                });
+                const pageLinks = pagination.getByRole('link').filter({
+                    hasText: /^\d+$/
+                });
+                if (await nextLink.count() === 0 && await pageLinks.count() === 0) return;
+            }
+            throw new Error(`Page ${page} not active`);
+        }).toPass({
+            timeout: 30000
+        });
+    }
+    async expectPageLinkVisible(pageNumber) {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPagination().getByRole('link', {
+            name: pageNumber.toString(),
+            exact: true
+        })).toBeVisible();
+    }
+    async expectPaginationLinksVisible() {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPagination().getByRole('link', {
+            name: '>',
+            exact: true
+        })).toBeVisible();
+    }
+    async expectPaginationLinksHidden() {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPagination().getByRole('link', {
+            name: '>',
+            exact: true
+        })).toHaveCount(0);
+    }
+    async setPageSize(size) {
+        await this.openPageSizeMenu();
+        await this.getPagination().getByRole('menu').getByRole('menuitem', {
+            name: size.toString(),
+            exact: true
+        }).click();
+        await this.waitForTableReady();
+    }
+    async expectPageSize(size) {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPagination().getByRole('button', {
+            name: size.toString(),
+            exact: true
+        })).toBeVisible();
+    }
+    async expectPageSizes(sizes) {
+        await this.openPageSizeMenu();
+        const menu = this.getPagination().getByRole('menu');
+        await (0, $1UEKj$playwrighttest.expect)(menu.getByRole('menuitem')).toHaveCount(sizes.length);
+        for (const size of sizes)await (0, $1UEKj$playwrighttest.expect)(menu.getByRole('menuitem', {
+            name: size.toString(),
+            exact: true
+        })).toBeVisible();
+        await this.closePageSizeMenu();
+    }
+    // ── Private helpers ───────────────────────────────────────────────────────
+    async openPageSizeMenu() {
+        const toggle = this.getPagination().locator('.dropdown-toggle');
+        await toggle.click();
+        await this.getPagination().getByRole('menu').waitFor({
+            state: 'visible'
+        });
+    }
+    async closePageSizeMenu() {
+        const menu = this.getPagination().getByRole('menu');
+        if (await menu.isVisible()) await this.getPagination().locator('.dropdown-toggle').click();
+    }
+    async expectTagAdded(tagTitle) {
+        const tags = this.getPane().locator('.xl-react-widget-tags .react-tagsinput-tag');
+        const byTitle = tags.locator(`[title='${tagTitle}']`);
+        const byContainsTitle = tags.filter({
+            hasText: tagTitle.split('/').pop() ?? tagTitle
+        });
+        if (await byTitle.count() > 0) await (0, $1UEKj$playwrighttest.expect)(byTitle.first()).toBeVisible();
+        else await (0, $1UEKj$playwrighttest.expect)(byContainsTitle.first()).toBeVisible();
+    }
+    async selectTagsFilterFirstSuggestion(filterSelector, text, optionName) {
+        const pane = this.getPane();
+        const filter = pane.locator(filterSelector);
+        const input = filter.locator('.xl-react-widget-autocomplete .react-tagsinput-input');
+        await input.click({
+            force: true
+        });
+        await input.fill(text);
+        const suggestionList = pane.locator('.xl-react-autocomplete-suggestion-list');
+        await (0, $1UEKj$playwrighttest.expect)(suggestionList).toBeVisible();
+        const optionByTitle = suggestionList.locator(`.yt-option[title="${optionName}"]`);
+        const optionByText = suggestionList.locator('.yt-option', {
+            hasText: optionName
+        });
+        const gridOption = suggestionList.getByRole('rowgroup').getByText(optionName, {
+            exact: false
+        });
+        let option;
+        if (await optionByTitle.count()) option = optionByTitle.first();
+        else if (await optionByText.count()) option = optionByText.first();
+        else option = gridOption.first();
+        await (0, $1UEKj$playwrighttest.expect)(option).toBeVisible();
+        const iconCheckbox = option.locator('i.xl-icon.icon-s.checkbox');
+        if (await iconCheckbox.count()) await iconCheckbox.click();
+        else await option.click();
+        await this.page.locator('body').click({
+            position: {
+                x: 10,
+                y: 10
+            }
+        });
+        await this.expectTagAdded(optionName);
+    }
+}
+
+
+
+
+class $c8a7aeb49da7ed26$export$a3e02ac2d0adbb20 extends (0, $ae23b16684112d0b$export$2b65d1d97338f32b) {
+    async downloadReport() {
+        const pane = this.page.locator('#pane-DashboardTab');
+        const exportButton = pane.locator('button.export-audit-report');
+        const fallbackButton = pane.locator('button:has-text("Export")');
+        const downloadPromise = this.page.waitForEvent('download', {
+            timeout: 20000
+        });
+        if (await exportButton.isVisible()) await exportButton.click();
+        else await fallbackButton.first().click();
+        return downloadPromise;
+    }
+    async downloadDashboardExport() {
+        return this.downloadReport();
+    }
+    async verifySummarySection() {
+        const pane = this.page.locator('#pane-DashboardTab');
+        const summary = pane.locator('.statistics-block');
+        await (0, $1UEKj$playwrighttest.expect)(pane.getByText('Usage summary for current month', {
+            exact: false
+        })).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('button:has-text("Export")')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(summary.locator('.tile-title[title="Successful deployments"]')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(summary.locator('.tile-title[title="Retried deployments"]')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(summary.locator('.tile-title[title="Rollback deployments"]')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(summary.locator('.tile-title[title="Aborted deployments"]')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.getByText('Deployment status overview', {
+            exact: true
+        })).toBeVisible();
+    }
+    async verifyLast30DaysSection() {
+        const pane = this.page.locator('#pane-DashboardTab');
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('h1.time-period-text', {
+            hasText: /Last 30 days/i
+        })).toBeVisible();
+        const successCard = pane.getByText('Top 10 successful deployments', {
+            exact: true
+        }).first().locator('..');
+        const retriedCard = pane.getByText('Top 10 retried deployments', {
+            exact: true
+        }).first().locator('..');
+        const longestCard = pane.getByText('Top 10 longest deployments', {
+            exact: true
+        }).first().locator('..');
+        await this.expectCardHasDataOrEmpty(successCard);
+        await this.expectCardHasDataOrEmpty(retriedCard);
+        await this.expectCardHasDataOrEmpty(longestCard);
+    }
+    async verifySelected() {
+        const pane = this.page.locator('#pane-DashboardTab');
+        await (0, $1UEKj$playwrighttest.expect)(pane).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(this.page.getByText('Dashboard', {
+            exact: true
+        })).toBeVisible();
+    }
+    async verifyLastUpdatedAndRefresh() {
+        const pane = this.page.locator('#pane-DashboardTab');
+        const lastUpdated = pane.locator('.last-updated-component');
+        await (0, $1UEKj$playwrighttest.expect)(lastUpdated).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(lastUpdated).not.toHaveText('');
+        const refreshButton = pane.getByRole('button', {
+            name: 'Refresh'
+        });
+        await refreshButton.click();
+        await (0, $1UEKj$playwrighttest.expect)(lastUpdated).toBeVisible();
+    }
+    async verifyDateRangeDefault() {
+        const pane = this.page.locator('#pane-DashboardTab');
+        const dateRangeInput = pane.locator('#date-range-input');
+        await (0, $1UEKj$playwrighttest.expect)(dateRangeInput).toHaveValue('Current month');
+    }
+    async selectDateRange(optionLabel) {
+        const pane = this.page.locator('#pane-DashboardTab');
+        const dateRangeInput = pane.locator('#date-range-input');
+        try {
+            await dateRangeInput.selectOption({
+                label: optionLabel
+            });
+            return;
+        } catch  {
+        // Fall back to clicking the open dropdown list.
+        }
+        await dateRangeInput.click();
+        const optionRole = this.page.getByRole('option', {
+            name: optionLabel
+        });
+        const menuItemRole = this.page.getByRole('menuitem', {
+            name: optionLabel
+        });
+        const fallbackOption = this.page.locator('li', {
+            hasText: optionLabel
+        });
+        if (await optionRole.isVisible()) {
+            await optionRole.click();
+            return;
+        }
+        if (await menuItemRole.isVisible()) {
+            await menuItemRole.click();
+            return;
+        }
+        await fallbackOption.first().click();
+    }
+    async verifyDateRangeHeaderContains(label) {
+        const pane = this.page.locator('#pane-DashboardTab');
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.title-header', {
+            hasText: label
+        })).toBeVisible();
+    }
+    async verifyOverviewChartsOrEmpty() {
+        const pane = this.page.locator('#pane-DashboardTab');
+        const statusOverview = pane.getByText('Deployment status overview', {
+            exact: true
+        }).first().locator('..');
+        await this.expectWidgetHasChartOrEmpty(statusOverview);
+        const numberOfDeployments = pane.getByText('Number of deployments over time', {
+            exact: true
+        }).first().locator('..');
+        await this.expectWidgetHasChartOrEmpty(numberOfDeployments);
+        const averageDuration = pane.getByText('Average deployment duration over time', {
+            exact: true
+        }).first().locator('..');
+        await this.expectWidgetHasChartOrEmpty(averageDuration);
+    }
+    async verifyDeploymentStatusLegend() {
+        const pane = this.page.locator('#pane-DashboardTab');
+        const tile = pane.locator('.deployment-status-overview');
+        await (0, $1UEKj$playwrighttest.expect)(tile).toBeVisible();
+        const legendItems = tile.locator('.recharts-legend-item-text');
+        if (await legendItems.count()) {
+            await (0, $1UEKj$playwrighttest.expect)(legendItems.filter({
+                hasText: 'Successful'
+            }).first()).toBeVisible();
+            await (0, $1UEKj$playwrighttest.expect)(legendItems.filter({
+                hasText: 'Retried'
+            }).first()).toBeVisible();
+            await (0, $1UEKj$playwrighttest.expect)(legendItems.filter({
+                hasText: 'Rollback'
+            }).first()).toBeVisible();
+            await (0, $1UEKj$playwrighttest.expect)(legendItems.filter({
+                hasText: 'Aborted'
+            }).first()).toBeVisible();
+            return;
+        }
+        // No-data state: chart, canvas, or no-data widget must be visible
+        const chartOrNoData = tile.locator('svg, canvas, .no-data-widget');
+        await (0, $1UEKj$playwrighttest.expect)(chartOrNoData.first()).toBeVisible();
+    }
+    async verifyButtonsFocusable() {
+        const pane = this.page.locator('#pane-DashboardTab');
+        const exportButton = pane.getByRole('button', {
+            name: 'Export'
+        });
+        const refreshButton = pane.getByRole('button', {
+            name: 'Refresh'
+        });
+        await exportButton.focus();
+        await (0, $1UEKj$playwrighttest.expect)(exportButton).toBeFocused();
+        await refreshButton.focus();
+        await (0, $1UEKj$playwrighttest.expect)(refreshButton).toBeFocused();
+    }
+    async verifyDateRangeOptions() {
+        const pane = this.page.locator('#pane-DashboardTab');
+        const select = pane.locator('#date-range-input');
+        const expectedOptions = [
+            'Current month',
+            'Last 30 days',
+            'Last 90 days',
+            'Last 180 days',
+            'Last 360 days',
+            'Custom date range'
+        ];
+        for (const option of expectedOptions)await (0, $1UEKj$playwrighttest.expect)(select.locator(`option:has-text("${option}")`)).toBeAttached();
+    }
+    async verifyLast6MonthsSection() {
+        const pane = this.page.locator('#pane-DashboardTab');
+        const trendBlock = pane.locator('.time-period-section.trend-block');
+        await (0, $1UEKj$playwrighttest.expect)(trendBlock).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(trendBlock.locator('h1.time-period-text')).toContainText('Last 6 months');
+        const numDeployments = trendBlock.locator('.number-of-deployments-over-time');
+        const avgDuration = trendBlock.locator('.average-deployment-duration-over-time');
+        await (0, $1UEKj$playwrighttest.expect)(numDeployments).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(avgDuration).toBeVisible();
+    }
+    async verifyKpiTileNumbers() {
+        const pane = this.page.locator('#pane-DashboardTab');
+        const tiles = [
+            pane.locator('.successful.text-widget'),
+            pane.locator('.retried.text-widget'),
+            pane.locator('.rollback.text-widget'),
+            pane.locator('.aborted.text-widget')
+        ];
+        for (const tile of tiles){
+            await (0, $1UEKj$playwrighttest.expect)(tile).toBeVisible();
+            await (0, $1UEKj$playwrighttest.expect)(tile.locator('.number')).toBeVisible();
+        }
+    }
+    async verifyCustomDateRangeInputs() {
+        const pane = this.page.locator('#pane-DashboardTab');
+        await pane.locator('#date-range-input').selectOption({
+            label: 'Custom date range'
+        });
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.custom-date-range')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('#custom-range-start-date')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('#custom-range-end-date')).toBeVisible();
+        // Restore default
+        await pane.locator('#date-range-input').selectOption({
+            label: 'Current month'
+        });
+    }
+    async expectCardHasDataOrEmpty(card) {
+        const tableRows = card.locator('table tbody tr');
+        if (await tableRows.count()) {
+            await (0, $1UEKj$playwrighttest.expect)(tableRows.first()).toBeVisible();
+            return;
+        }
+        const rowData = card.locator('.row-data');
+        if (await rowData.count()) {
+            await (0, $1UEKj$playwrighttest.expect)(rowData.first()).toBeAttached();
+            return;
+        }
+        await (0, $1UEKj$playwrighttest.expect)(card.getByText('No data available for the current period', {
+            exact: true
+        })).toBeVisible();
+    }
+    async expectWidgetHasChartOrEmpty(widget) {
+        const chart = widget.locator('svg, canvas');
+        const noData = widget.getByText('No data available for the current period', {
+            exact: true
+        });
+        const chartVisible = await chart.first().isVisible();
+        const noDataVisible = await noData.isVisible();
+        (0, $1UEKj$playwrighttest.expect)(chartVisible || noDataVisible).toBeTruthy();
+    }
+}
+
+
+
+
+class $50eb7c79d31afc08$export$41a993d086bafffd extends (0, $ae23b16684112d0b$export$2b65d1d97338f32b) {
+    getPane() {
+        return this.page.locator('#pane-DeploymentsTab');
+    }
+    getPagination() {
+        return this.getPane().locator('.react-bootstrap-table-pagination');
+    }
+    getTableBody() {
+        return this.getPane().locator('.react-bootstrap-table tbody');
+    }
+    getLastUpdated() {
+        return this.getPane().locator('.last-updated-component');
+    }
+    async resolveDateField(containerSelector) {
+        const container = this.getPane().locator(containerSelector);
+        const input = container.locator('input');
+        if (await input.count()) return input.first();
+        return container;
+    }
+    async verifySelected() {
+        const pane = this.getPane();
+        await (0, $1UEKj$playwrighttest.expect)(pane).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(this.page.getByText('Deployments', {
+            exact: true
+        })).toBeVisible();
+    }
+    async verifyFiltersVisible() {
+        const pane = this.getPane();
+        const filtersPanel = pane.locator('.xl-react-redux-table-filters-panel');
+        await (0, $1UEKj$playwrighttest.expect)(filtersPanel).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.deployment-task-filter-start-date')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.deployment-task-filter-end-date')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.deployment-task-filter-task-id input[placeholder="Search"]')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.deployment-task-filter-worker input[placeholder="Search"]')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.deployment-task-filter-applications .react-tagsinput-input')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.deployment-task-filter-environments .react-tagsinput-input')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.deployment-task-filter-state .react-tagsinput-input')).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(pane.locator('.deployment-task-filter-types .react-tagsinput-input')).toBeVisible();
+        const tasksFilterInput = pane.locator('.deployment-task-filter-tasks .react-tagsinput-input');
+        if (await tasksFilterInput.count()) await (0, $1UEKj$playwrighttest.expect)(tasksFilterInput).toBeVisible();
+    }
+    async verifyLastUpdatedAndRefresh() {
+        const pane = this.getPane();
+        const lastUpdated = this.getLastUpdated();
+        await (0, $1UEKj$playwrighttest.expect)(lastUpdated).toBeVisible();
+        await (0, $1UEKj$playwrighttest.expect)(lastUpdated).not.toHaveText('');
+        const refreshButton = pane.getByRole('button', {
+            name: 'Refresh'
+        });
+        await refreshButton.click();
+        await (0, $1UEKj$playwrighttest.expect)(lastUpdated).toBeVisible();
+    }
+    async verifyTableHasRowsOrEmpty() {
+        const pane = this.getPane();
+        const table = pane.locator('table.table-striped');
+        await (0, $1UEKj$playwrighttest.expect)(table).toBeVisible();
+        const rows = this.getTableBody().locator('tr');
+        const noDataCell = this.getTableBody().locator('tr td.react-bs-table-no-data');
+        const emptyState = pane.getByText(/No data/i);
+        await (0, $1UEKj$playwrighttest.expect)(async ()=>{
+            if (await rows.count()) return true;
+            if (await noDataCell.count() > 0 && await noDataCell.first().isVisible()) return true;
+            if (await emptyState.count() > 0 && await emptyState.first().isVisible()) return true;
+            return false;
+        }).toBeTruthy();
+    }
+    async hideFilters() {
+        const pane = this.getPane();
+        const filtersPanel = pane.locator('.xl-react-redux-table-filters-panel');
+        const hideFiltersButton = pane.getByRole('button', {
+            name: 'Hide filters'
+        });
+        await (0, $1UEKj$playwrighttest.expect)(filtersPanel).toBeVisible();
+        await hideFiltersButton.click();
+        await (0, $1UEKj$playwrighttest.expect)(filtersPanel).toBeHidden();
+    }
+    async showFilters() {
+        const pane = this.getPane();
+        const filtersPanel = pane.locator('.xl-react-redux-table-filters-panel');
+        const showFiltersButton = pane.getByRole('button', {
+            name: 'Show filters'
+        });
+        if (await filtersPanel.isVisible()) return;
+        for(let attempt = 0; attempt < 3; attempt += 1){
+            if (await showFiltersButton.isVisible()) await showFiltersButton.click({
+                force: true
+            });
+            if (await filtersPanel.isVisible()) return;
+            await this.page.waitForTimeout(300);
+        }
+        await (0, $1UEKj$playwrighttest.expect)(filtersPanel).toBeVisible();
+    }
+    async ensureFiltersVisible() {
+        const pane = this.getPane();
+        const filtersPanel = pane.locator('.xl-react-redux-table-filters-panel');
+        if (await filtersPanel.isVisible()) return;
+        const showFiltersButton = pane.getByRole('button', {
+            name: 'Show filters'
+        });
+        if (await showFiltersButton.isVisible()) await showFiltersButton.click({
+            force: true
+        });
+        await (0, $1UEKj$playwrighttest.expect)(filtersPanel).toBeVisible();
+    }
+    async clickRefresh() {
+        const pane = this.getPane();
+        await pane.getByRole('button', {
+            name: 'Refresh'
+        }).click();
+    }
+    async expectTotal(total) {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPagination().locator('> div').filter({
+            hasText: 'Total:'
+        })).toContainText(`Total: ${total}`);
+    }
+    async expectNumberOfRows(count) {
+        await this.waitForTableReady();
+        await (0, $1UEKj$playwrighttest.expect)(this.getTableBody().locator('tr')).toHaveCount(count);
+    }
+    async expectAtLeastNumberOfRows(count) {
+        await this.waitForTableReady();
+        await (0, $1UEKj$playwrighttest.expect)(async ()=>{
+            const total = await this.getTableBody().locator('tr').count();
+            (0, $1UEKj$playwrighttest.expect)(total).toBeGreaterThanOrEqual(count);
+        }).toPass({
+            timeout: 30000
+        });
+    }
+    async expectAtLeastTotal(count) {
+        await this.waitForTableReady();
+        await (0, $1UEKj$playwrighttest.expect)(async ()=>{
+            const text = await this.getPagination().locator('> div').filter({
+                hasText: 'Total:'
+            }).textContent();
+            const match = text?.match(/Total:\s*(\d+)/);
+            const total = match ? Number(match[1]) : 0;
+            (0, $1UEKj$playwrighttest.expect)(total).toBeGreaterThanOrEqual(count);
+        }).toPass();
+    }
+    async expectValue(row, column, expected) {
+        const cell = this.getTableBody().locator(`tr:nth-child(${row}) td.report-table-${column}`);
+        await (0, $1UEKj$playwrighttest.expect)(cell).toHaveText(expected);
+    }
+    async expectValueContains(row, column, expected) {
+        const cell = this.getTableBody().locator(`tr:nth-child(${row}) td.report-table-${column}`);
+        await (0, $1UEKj$playwrighttest.expect)(cell).toContainText(expected);
+    }
+    async sortBy(column) {
+        const header = this.getPane().locator(`.react-bootstrap-table thead th.report-table-${column}`);
+        await header.click();
+    }
+    async isAscendingSorted(column) {
+        const sortOrder = this.getPane().locator(`.react-bootstrap-table thead th.report-table-${column} .react-bootstrap-table-sort-order`);
+        await (0, $1UEKj$playwrighttest.expect)(sortOrder).toBeVisible();
+    }
+    async getColumnValues(column) {
+        await this.waitForTableReady();
+        const cells = this.getTableBody().locator(`tr td.report-table-${column}`);
+        const count = await cells.count();
+        const values = [];
+        for(let i = 0; i < count; i += 1)values.push((await cells.nth(i).textContent())?.trim() ?? '');
+        return values;
+    }
+    async getLastPageNumber() {
+        await this.waitForTableReady();
+        const links = this.getPagination().getByRole('list').getByRole('link');
+        const count = await links.count();
+        if (count < 2) return 1;
+        // links order on page 1: [1, 2, ..., n, >] — last numeric is nth(count-2)
+        const text = await links.nth(count - 2).textContent();
+        const num = Number(text?.trim());
+        return Number.isFinite(num) && num > 0 ? num : 1;
+    }
+    async getTotalCount() {
+        await this.waitForTableReady();
+        const text = await this.getPagination().locator('> div').filter({
+            hasText: 'Total:'
+        }).textContent();
+        const match = text?.match(/Total:\s*(\d+)/);
+        return match ? Number(match[1]) : 0;
+    }
+    async expectPage(page) {
+        await (0, $1UEKj$playwrighttest.expect)(async ()=>{
+            const pagination = this.getPagination();
+            // primary: react-bootstrap li.active with child link
+            const activeLink = pagination.locator('li.active').getByRole('link', {
+                name: page.toString(),
+                exact: true
+            });
+            if (await activeLink.count() > 0) return;
+            // fallback: aria-current="page"
+            const ariaCurrent = pagination.locator('[aria-current="page"]').filter({
+                hasText: page.toString()
+            });
+            if (await ariaCurrent.count() > 0) return;
+            throw new Error(`Page ${page} not active`);
+        }).toPass({
+            timeout: 30000
+        });
+    }
+    async goToPage(page) {
+        await this.getPagination().getByRole('link', {
+            name: page.toString()
+        }).click();
+    }
+    async goToFirstPage() {
+        const firstLink = this.getPagination().getByRole('link', {
+            name: '<<'
+        });
+        if (await firstLink.count()) await firstLink.click();
+        else await this.getPagination().getByRole('link', {
+            name: '1',
+            exact: true
+        }).click();
+    }
+    async goToLastPage() {
+        const lastLink = this.getPagination().getByRole('link', {
+            name: '>>'
+        });
+        if (await lastLink.count()) await lastLink.click();
+        else {
+            const links = this.getPagination().getByRole('list').getByRole('link');
+            const count = await links.count();
+            // last numeric link is second-to-last (last is '>')
+            await links.nth(count - 2).click();
+        }
+    }
+    async goToPreviousPage() {
+        await this.getPagination().getByRole('link', {
+            name: '<',
+            exact: true
+        }).click();
+    }
+    async goToNextPage() {
+        await this.getPagination().getByRole('link', {
+            name: '>',
+            exact: true
+        }).click();
+    }
+    async expectPageLinkVisible(pageNumber) {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPagination().getByRole('link', {
+            name: pageNumber.toString(),
+            exact: true
+        })).toBeVisible();
+    }
+    async expectPaginationLinksVisible() {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPagination().getByRole('link', {
+            name: '>',
+            exact: true
+        })).toBeVisible();
+    }
+    async expectPaginationLinksHidden() {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPagination().getByRole('link', {
+            name: '>',
+            exact: true
+        })).toHaveCount(0);
+    }
+    async expectPageSize(size) {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPagination().getByRole('button', {
+            name: size.toString(),
+            exact: true
+        })).toBeVisible();
+    }
+    async expectPageSizes(sizes) {
+        await this.openPageSizeMenu();
+        const menu = this.getPagination().getByRole('menu');
+        await (0, $1UEKj$playwrighttest.expect)(menu.getByRole('menuitem')).toHaveCount(sizes.length);
+        for (const size of sizes)await (0, $1UEKj$playwrighttest.expect)(menu.getByRole('menuitem', {
+            name: size.toString(),
+            exact: true
+        })).toBeVisible();
+        await this.closePageSizeMenu();
+    }
+    async setPageSize(size) {
+        await this.openPageSizeMenu();
+        await this.getPagination().getByRole('menu').getByRole('menuitem', {
+            name: size.toString(),
+            exact: true
+        }).click();
+        await this.waitForTableReady();
+    }
+    async shouldHaveScrollBar() {
+        await this.waitForTableReady();
+        const container = this.getPane().locator('div.report');
+        const overflowX = await container.evaluate((el)=>window.getComputedStyle(el).overflowX);
+        (0, $1UEKj$playwrighttest.expect)([
+            'auto',
+            'scroll'
+        ]).toContain(overflowX);
+    }
+    async setStartDate(value) {
+        const field = await this.resolveDateField('.deployment-task-filter-start-date');
+        await field.click();
+        await field.fill(value);
+        await this.getLastUpdated().click({
+            force: true
+        });
+    }
+    async setEndDate(value) {
+        const field = await this.resolveDateField('.deployment-task-filter-end-date');
+        await field.click();
+        await field.fill(value);
+        await this.getLastUpdated().click({
+            force: true
+        });
+    }
+    async expectStartDateValue(value) {
+        await this.expectDateFieldValue('.deployment-task-filter-start-date', value);
+    }
+    async expectEndDateValue(value) {
+        await this.expectDateFieldValue('.deployment-task-filter-end-date', value);
+    }
+    async checkInvalidStartDateError() {
+        const field = await this.resolveDateField('.deployment-task-filter-start-date');
+        await field.click(); // opens calendar
+        await field.press('End');
+        await field.press('a'); // append invalid char
+        await this.page.keyboard.press('Escape'); // close calendar → error appears below field
+        await (0, $1UEKj$playwrighttest.expect)(this.getPane().getByText('Example: Dec 1, 2018').first()).toBeVisible();
+    }
+    async checkInvalidEndDateError() {
+        const field = await this.resolveDateField('.deployment-task-filter-end-date');
+        await field.click(); // opens calendar
+        await field.press('End');
+        await field.press('b'); // append invalid char
+        await this.page.keyboard.press('Escape'); // close calendar → error appears below field
+        await (0, $1UEKj$playwrighttest.expect)(this.getPane().getByText('Example: Dec 1, 2018').first()).toBeVisible();
+    }
+    async expectNoStartDateError() {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPane().getByText('Example: Dec 1, 2018')).toHaveCount(0);
+    }
+    async expectNoEndDateError() {
+        await (0, $1UEKj$playwrighttest.expect)(this.getPane().getByText('Example: Dec 1, 2018')).toHaveCount(0);
+    }
+    async selectRadioFilter(label) {
+        await this.ensureFiltersVisible();
+        const pane = this.getPane();
+        const radioGroup = pane.locator('.xl-react-widget-radio-group');
+        const labelLocator = radioGroup.locator(`label[data='${label}']`);
+        if (await labelLocator.count()) {
+            await labelLocator.click();
+            return;
+        }
+        const fallbackByText = radioGroup.getByText(label, {
+            exact: true
+        });
+        if (await fallbackByText.count()) {
+            await fallbackByText.click();
+            return;
+        }
+        const ariaRadio = pane.locator('[role="radio"]', {
+            hasText: label
+        });
+        if (await ariaRadio.count()) await ariaRadio.first().click();
+    }
+    async expectApplicationsRadioSelected() {
+        const radio = this.getPane().locator('.xl-react-widget-radio-group label[data="Application(s)"]');
+        if (await radio.count() === 0) return;
+        await (0, $1UEKj$playwrighttest.expect)(radio).toHaveAttribute('style', /background-color/);
+    }
+    async selectTagsFilterApplications(text, optionName) {
+        await this.selectTagsFilterFirstSuggestion('.deployment-task-filter-applications .react-tagsinput', text, optionName);
+    }
+    async selectTagsFilterEnvironments(text, optionName) {
+        await this.selectTagsFilterFirstSuggestion('.deployment-task-filter-environments .react-tagsinput', text, optionName);
+    }
+    async selectStatesTagsFilterFirstSuggestion(text, optionName) {
+        await this.selectTagsFilterFirstSuggestion('.deployment-task-filter-state .react-tagsinput', text, optionName);
+    }
+    async clearStatesTagsFirstTag() {
+        const remove = this.getPane().locator('.deployment-task-filter-state .react-tagsinput-tag:nth-child(1) .react-tagsinput-remove');
+        if (await remove.count()) await remove.click();
+    }
+    async clearApplicationsTagsFirstTag() {
+        const remove = this.getPane().locator('.deployment-task-filter-applications .react-tagsinput-tag:nth-child(1) .react-tagsinput-remove');
+        if (await remove.count()) await remove.click();
+    }
+    async clearEnvironmentsTagsFirstTag() {
+        const remove = this.getPane().locator('.deployment-task-filter-environments .react-tagsinput-tag:nth-child(1) .react-tagsinput-remove');
+        if (await remove.count()) await remove.click();
+    }
+    async setTaskId(taskId) {
+        const input = this.getPane().locator('.deployment-task-filter-task-id input');
+        await input.fill(taskId);
+        await (0, $1UEKj$playwrighttest.expect)(input).toHaveValue(taskId);
+    }
+    async setWorkerName(workerName) {
+        const input = this.getPane().locator('.deployment-task-filter-worker input');
+        await input.fill(workerName);
+        await (0, $1UEKj$playwrighttest.expect)(input).toHaveValue(workerName);
+    }
+    async clearWorkerName() {
+        await this.setWorkerName('');
+    }
+    async expectTagAdded(tagTitle) {
+        const tags = this.getPane().locator('.xl-react-widget-tags .react-tagsinput-tag');
+        const byTitle = tags.locator(`[title='${tagTitle}']`);
+        const byContainsTitle = tags.filter({
+            hasText: tagTitle.split('/').pop() ?? tagTitle
+        });
+        const count = await byTitle.count();
+        if (count > 0) await (0, $1UEKj$playwrighttest.expect)(byTitle.first()).toBeVisible();
+        else await (0, $1UEKj$playwrighttest.expect)(byContainsTitle.first()).toBeVisible();
+    }
+    async selectTagsFilterFirstSuggestion(filterSelector, text, optionName) {
+        const pane = this.getPane();
+        const filter = pane.locator(filterSelector);
+        const input = filter.locator('.xl-react-widget-autocomplete .react-tagsinput-input');
+        await input.click({
+            force: true
+        });
+        await input.fill(text);
+        const suggestionList = pane.locator('.xl-react-autocomplete-suggestion-list');
+        await (0, $1UEKj$playwrighttest.expect)(suggestionList).toBeVisible();
+        // Try .yt-option first (State/Type filters), then aria grid row (Application/Environment filters)
+        const optionByTitle = suggestionList.locator(`.yt-option[title="${optionName}"]`);
+        const optionByText = suggestionList.locator('.yt-option', {
+            hasText: optionName
+        });
+        const gridOption = suggestionList.getByRole('rowgroup').getByText(optionName, {
+            exact: false
+        });
+        let option;
+        if (await optionByTitle.count()) option = optionByTitle.first();
+        else if (await optionByText.count()) option = optionByText.first();
+        else option = gridOption.first();
+        await (0, $1UEKj$playwrighttest.expect)(option).toBeVisible();
+        const iconCheckbox = option.locator('i.xl-icon.icon-s.checkbox');
+        if (await iconCheckbox.count()) await iconCheckbox.click();
+        else await option.click();
+        await this.page.locator('body').click({
+            position: {
+                x: 10,
+                y: 10
+            }
+        });
+        await this.expectTagAdded(optionName);
+    }
+    async waitForTableReady() {
+        // Poll until loading indicator is gone AND table content (rows or empty state) is present
+        await (0, $1UEKj$playwrighttest.expect)(async ()=>{
+            const loading = await this.getPane().getByText('Data loading').count();
+            if (loading > 0) throw new Error('Still loading');
+            const rows = await this.getTableBody().locator('tr').count();
+            const noData = await this.getTableBody().locator('td.react-bs-table-no-data').count();
+            if (rows === 0 && noData === 0) throw new Error('No table content yet');
+        }).toPass({
+            timeout: 60000
+        });
+    }
+    async openPageSizeMenu() {
+        const btn = this.getPagination().getByRole('toolbar').getByRole('button');
+        const expanded = await btn.getAttribute('aria-expanded');
+        if (expanded !== 'true') {
+            await btn.click();
+            await (0, $1UEKj$playwrighttest.expect)(this.getPagination().getByRole('menu')).toBeVisible();
+        }
+    }
+    async closePageSizeMenu() {
+        const btn = this.getPagination().getByRole('toolbar').getByRole('button');
+        const expanded = await btn.getAttribute('aria-expanded');
+        if (expanded === 'true') {
+            await btn.click();
+            await (0, $1UEKj$playwrighttest.expect)(this.getPagination().getByRole('menu')).toBeHidden();
+        }
+    }
+    async expectDateFieldValue(containerSelector, value) {
+        const container = this.getPane().locator(containerSelector);
+        const input = container.locator('input');
+        if (await input.count() > 0) {
+            await (0, $1UEKj$playwrighttest.expect)(input.first()).toHaveValue(value);
+            return;
+        }
+        await (0, $1UEKj$playwrighttest.expect)(container).toHaveValue(value);
+    }
+}
+
+
+
+class $9204952bd68f68e5$export$e37b272c81a10693 extends (0, $84f8d1abd29d48fd$export$cb21416f3c2fd176) {
+    /* Navigates to the Infrastructure Edit Permissions page via the tree context menu */ async navigateToPage() {
+        await this.openRootContextMenu('Infrastructure');
+        await this.page.getByRole('link', {
+            name: 'Edit Permissions'
+        }).click();
+    }
+    async navigateToInfraEditPermissionPage() {
+        await this.navigateToPage();
+    }
+    /* Gives the permissions to a role */ async givePermissionsToRole(roleName) {
+        const filter = this.page.getByPlaceholder('Filter by roles').first();
+        await filter.waitFor({
+            state: 'visible'
+        });
+        await filter.scrollIntoViewIfNeeded();
+        await filter.fill(roleName);
+        const roleRow = this.page.locator('table.table-striped tbody tr').first();
+        const checkboxes = roleRow.locator('input[type="checkbox"]');
+        const count = await checkboxes.count();
+        for(let i = 0; i < count; i += 1){
+            const checkbox = checkboxes.nth(i);
+            if (!await checkbox.isChecked()) await checkbox.check();
+        }
+        await this.page.getByRole('button', {
+            name: 'Save and close'
+        }).click();
+        await this.handleSaveToastOrAlreadyExists();
+    }
+}
+
+
+
+class $05857e702fc1e333$export$c919546f4bf88f35 extends (0, $84f8d1abd29d48fd$export$cb21416f3c2fd176) {
+    /* Navigates to the Environments Edit Permissions page via the tree context menu */ async navigateToPage() {
+        await this.openRootContextMenu('Environments');
+        await this.page.getByRole('link', {
+            name: 'Edit Permissions'
+        }).click();
+    }
+    async navigateToEnvEditPermissionPage() {
+        await this.navigateToPage();
+    }
+    /* Gives the permissions to a role */ async givePermissionsToRole(roleName) {
+        const filter = this.page.getByPlaceholder('Filter by roles').first();
+        await filter.waitFor({
+            state: 'visible'
+        });
+        await filter.scrollIntoViewIfNeeded();
+        await filter.fill(roleName);
+        const roleRow = this.page.locator('table.table-striped tbody tr').first();
+        const labels = [
+            'deploy initial',
+            'read',
+            'repo edit'
+        ];
+        const headers = this.page.locator('table.table-striped thead th');
+        const headerCount = await headers.count();
+        const headerTexts = [];
+        for(let i = 0; i < headerCount; i += 1)headerTexts.push((await headers.nth(i).innerText()).trim().toLowerCase());
+        for (const label of labels){
+            const colIndex = headerTexts.findIndex((text)=>text.includes(label));
+            if (colIndex === -1) throw new Error(`Permission column not found: ${label}`);
+            const checkbox = roleRow.locator('td').nth(colIndex).locator('input[type="checkbox"]');
+            if (!await checkbox.isChecked()) await checkbox.check();
+        }
+        await this.page.getByRole('button', {
+            name: 'Save and close'
+        }).click();
+        await this.handleSaveToastOrAlreadyExists();
+    }
+}
+
+
+
+class $7735c50a40aa728e$export$ecd8b3e50e92d781 extends (0, $84f8d1abd29d48fd$export$cb21416f3c2fd176) {
+    /* Navigates to the Applications Edit Permissions page via the tree context menu */ async navigateToPage() {
+        await this.openRootContextMenu('Applications');
+        await this.page.getByRole('link', {
+            name: 'Edit Permissions'
+        }).click();
+    }
+    async navigateToAppEditPermissionPage() {
+        await this.navigateToPage();
+    }
+    /* Gives the permissions to a role */ async givePermissionsToRole(roleName) {
+        const filter = this.page.getByPlaceholder('Filter by roles').first();
+        await filter.waitFor({
+            state: 'visible'
+        });
+        await filter.scrollIntoViewIfNeeded();
+        await filter.fill(roleName);
+        const roleRow = this.page.locator('table.table-striped tbody tr').first();
+        const labels = [
+            'read',
+            'repo edit'
+        ];
+        const headers = this.page.locator('table.table-striped thead th');
+        const headerCount = await headers.count();
+        const headerTexts = [];
+        for(let i = 0; i < headerCount; i += 1)headerTexts.push((await headers.nth(i).innerText()).trim().toLowerCase());
+        for (const label of labels){
+            const colIndex = headerTexts.findIndex((text)=>text.includes(label));
+            if (colIndex === -1) throw new Error(`Permission column not found: ${label}`);
+            const checkbox = roleRow.locator('td').nth(colIndex).locator('input[type="checkbox"]');
+            if (!await checkbox.isChecked()) await checkbox.check();
+        }
+        await this.page.getByRole('button', {
+            name: 'Save and close'
+        }).click();
+        await this.handleSaveToastOrAlreadyExists();
+    }
+}
+
+
+class $28788a34e6bbbe3d$export$b8a61e5c71402559 extends (0, $84f8d1abd29d48fd$export$cb21416f3c2fd176) {
+    constructor(page){
+        super(page);
         this.homePage = new (0, $f280624787ceceed$export$36d69433c4f81145)(page);
         this.userPage = new (0, $c949c453826379e3$export$ecdc3cf9d1cfe143)(page);
+        this.overthereLocalHostPage = new (0, $647b67e126f2dbe0$export$c88e1d16f82516d)(page);
+        this.environmentsPage = new (0, $f8bdd801aee9e08b$export$12530425267834a9)(page);
+        this.applicationsPage = new (0, $408106958eb335da$export$1533b625ec0c75e2)(page);
+        this.reportsPage = new (0, $b2f725a937c99e2d$export$b8a443164510a1b4)(page);
+        this.reportsControlTasksPage = new (0, $1b52322f0063c4bc$export$5c1198389e139c11)(page);
+        this.reportsDashboardPage = new (0, $c8a7aeb49da7ed26$export$a3e02ac2d0adbb20)(page);
+        this.reportsDeploymentsPage = new (0, $50eb7c79d31afc08$export$41a993d086bafffd)(page);
+        this.infrastructureEditPermissionsPage = new (0, $9204952bd68f68e5$export$e37b272c81a10693)(page);
+        this.environmentEditPermissionsPage = new (0, $05857e702fc1e333$export$c919546f4bf88f35)(page);
+        this.applicationEditPermissionsPage = new (0, $7735c50a40aa728e$export$ecd8b3e50e92d781)(page);
     }
     async navigateToHomePage() {
-        await this.page.goto("/home");
+        await this.page.goto('/home');
     }
     async navigateToUserPage() {
-        await this.page.locator("p.MuiTypography-root", {
-            hasText: "User management"
+        await this.page.locator('p.MuiTypography-root', {
+            hasText: 'User management'
         }).click();
     }
     async clickCollapseSideView() {
-        const collapseButton = this.page.getByTestId("back-button");
+        const collapseButton = this.page.getByTestId('back-button');
         await collapseButton.click();
     }
 }
@@ -133,53 +2570,71 @@ class $28788a34e6bbbe3d$export$b8a61e5c71402559 {
 
 
 class $365fc3920b0d055f$export$f14c0e3f98d164c0 extends (0, $ae23b16684112d0b$export$2b65d1d97338f32b) {
-    /**
-   * Login with username and password
-   * @param userName
-   * @param password
-   */ async login(userName, password) {
-        await this.page.goto("/#/login");
-        await (0, $1UEKj$playwrighttest.expect)(this.page).toHaveTitle("Digital.ai Deploy");
-        await this.page.getByPlaceholder("user").fill(userName, {
-            timeout: 1000
-        });
-        await this.page.getByPlaceholder("Password").fill(password, {
+    /* Login with username and password*/ async login(userName, password, pageOverride) {
+        const p = pageOverride ?? this.page;
+        await p.goto('/#/login');
+        await (0, $1UEKj$playwrighttest.expect)(p).toHaveTitle('Digital.ai Deploy');
+        await p.getByPlaceholder('user').fill(userName, {
+            timeout: 10000
+        });
+        await p.getByPlaceholder('Password').fill(password, {
             timeout: 10000
         });
-        await this.page.getByRole("button", {
-            name: "Log in"
+        await p.getByRole('button', {
+            name: 'Log in'
         }).click({
             timeout: 10000
         });
     }
-    async verifyInvalidPasswordMessage() {
-        const errorMessage = this.page.getByText("The username and/or password you have entered is incorrect.");
+    /* Verify invalid password message */ async verifyInvalidPasswordMessage() {
+        const errorMessage = this.page.getByText('The username and/or password you have entered is incorrect.');
         await (0, $1UEKj$playwrighttest.expect)(errorMessage).toBeVisible();
     }
-    /**
-   * Logout as authenticated user
-   */ async logout() {
-        await this.page.locator("button.dot-avatar").click();
-        await this.page.getByText("Log out", {
+    /* Verify the error message shown when a disabled user attempts to log in */ async verifyDisabledUserLoginError(pageOverride) {
+        const p = pageOverride ?? this.page;
+        const errorMessage = p.getByText('Your account is currently disabled. Please contact your Deploy administrator for further assistance.');
+        await (0, $1UEKj$playwrighttest.expect)(errorMessage).toBeVisible();
+    }
+    /* Verify the error message shown when a user without login permission attempts to log in */ async verifyNoLoginPermissionError(pageOverride) {
+        const p = pageOverride ?? this.page;
+        const errorMessage = p.locator('div.error-message.permission-error');
+        await (0, $1UEKj$playwrighttest.expect)(errorMessage).toBeVisible({
+            timeout: 20000
+        });
+    }
+    /* Logout as authenticated user */ async logout() {
+        await this.page.locator('button.dot-avatar').click();
+        await this.page.getByText('Log out', {
             exact: true
         }).click();
-        await (0, $1UEKj$playwrighttest.expect)(this.page.getByText("Log in").first()).toBeVisible();
+        await this.page.waitForURL('**/#/login', {
+            timeout: 15000
+        });
+        await this.page.reload();
+        await this.page.waitForLoadState('networkidle');
+        await this.page.waitForURL('**/#/login', {
+            timeout: 15000
+        });
+        await this.page.getByPlaceholder('user').waitFor({
+            state: 'visible',
+            timeout: 15000
+        });
     }
 }
 
 
 const $3352700e95ddc19e$export$e0969da9b8fb378d = (0, $1UEKj$playwrighttest.test).extend({
-    fixtures: async ({ page: page  }, use)=>{
+    fixtures: async ({ page: page }, use)=>{
         const fixtures = new $3352700e95ddc19e$var$Fixtures(page);
         await use(fixtures);
         return fixtures;
     },
-    loginPage: async ({ page: page  }, use)=>{
+    loginPage: async ({ page: page }, use)=>{
         const loginPage = new (0, $365fc3920b0d055f$export$f14c0e3f98d164c0)(page);
         await use(loginPage);
         return loginPage;
     },
-    navigation: async ({ page: page  }, use)=>{
+    navigation: async ({ page: page }, use)=>{
         const navigationPage = new (0, $28788a34e6bbbe3d$export$b8a61e5c71402559)(page);
         await use(navigationPage);
         return navigationPage;