@camunda/e2e-test-suite 0.0.202 → 0.0.203

package/dist/pages/8.10/OperateHomePage.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateHomePage = void 0;
+const test_1 = require("@playwright/test");
+const clickLocatorWithRetry_1 = require("../../utils/assertionHelpers/clickLocatorWithRetry");
+const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
+class OperateHomePage {
+    page;
+    operateHeader;
+    processesTab;
+    informationDialog;
+    editVariableButton;
+    variableValueInput;
+    saveVariableButton;
+    editVariableSpinner;
+    operateBanner;
+    noPermissionsMessage;
+    processPageHeading;
+    constructor(page) {
+        this.page = page;
+        this.operateHeader = page.getByRole('link', { name: 'Camunda Operate' });
+        this.processesTab = page.getByRole('link', {
+            name: 'Processes',
+            exact: true,
+        });
+        this.informationDialog = page.getByRole('button', {
+            name: 'Close this dialog',
+        });
+        this.editVariableButton = page.getByTestId('edit-variable-button');
+        this.variableValueInput = page.getByTestId('edit-variable-value');
+        this.saveVariableButton = page.getByLabel('Save variable');
+        this.editVariableSpinner = page
+            .getByTestId('variable-operation-spinner')
+            .locator('circle')
+            .nth(1);
+        this.operateBanner = page.getByRole('link', { name: 'Camunda logo Operate' });
+        this.noPermissionsMessage = page
+            .getByText('You don’t have access to this component')
+            .first();
+        this.processPageHeading = page
+            .getByTestId('expanded-panel')
+            .getByText('Process', { exact: true });
+    }
+    async clickProcessesTab() {
+        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.processesTab);
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.processPageHeading, {
+            preAction: async () => {
+                await (0, test_1.expect)(this.processesTab).toBeVisible({ timeout: 10000 });
+                await this.processesTab.click({ timeout: 10000 });
+            },
+        });
+    }
+    async closeInformationDialog() {
+        await this.informationDialog.click();
+    }
+    async clickEditVariableButton(variableName) {
+        const editVariableButton = 'Edit variable ' + variableName;
+        await this.page.getByLabel(editVariableButton).click();
+    }
+    async clickVariableValueInput() {
+        await this.variableValueInput.click();
+    }
+    async clearVariableValueInput() {
+        await this.variableValueInput.clear();
+    }
+    async fillVariableValueInput(value) {
+        await this.variableValueInput.fill(value);
+    }
+    async clickSaveVariableButton() {
+        await this.saveVariableButton.click();
+    }
+}
+exports.OperateHomePage = OperateHomePage;

package/dist/pages/8.10/OperateProcessInstancePage.d.ts

@@ -0,0 +1,23 @@
+import { Page, Locator } from '@playwright/test';
+declare class OperateProcessInstancePage {
+    private page;
+    readonly diagram: Locator;
+    readonly completedIcon: Locator;
+    readonly diagramSpinner: Locator;
+    readonly activeIcon: Locator;
+    readonly incidentIcon: Locator;
+    readonly userTaskOpenTasklistLink: Locator;
+    readonly taskDetailsPopOver: Locator;
+    readonly connectorResultVariableName: (name: string) => Locator;
+    readonly variablesList: Locator;
+    readonly messageVariable: Locator;
+    constructor(page: Page);
+    connectorResultVariableValue(variableName: string): Promise<Locator>;
+    reload(): Promise<void>;
+    assertProcessCompleteStatusWithRetry(timeout?: number, maxRetries?: number): Promise<void>;
+    assertProcessVariableContainsText(variableName: string, text: string): Promise<void>;
+    clickDiagramTask(taskName: string): Promise<void>;
+    assertActiveTokenIsPresent(): Promise<void>;
+    assertDetailsPopoverIsVisible(): Promise<void>;
+}
+export { OperateProcessInstancePage };

package/dist/pages/8.10/OperateProcessInstancePage.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateProcessInstancePage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class OperateProcessInstancePage {
+    page;
+    diagram;
+    completedIcon;
+    diagramSpinner;
+    activeIcon;
+    incidentIcon;
+    userTaskOpenTasklistLink;
+    taskDetailsPopOver;
+    connectorResultVariableName;
+    variablesList;
+    messageVariable;
+    constructor(page) {
+        this.page = page;
+        this.diagram = page.getByTestId('diagram');
+        this.completedIcon = page
+            .getByTestId('instance-header')
+            .getByTestId('COMPLETED-icon');
+        this.diagramSpinner = page.getByTestId('diagram-spinner');
+        this.activeIcon = page
+            .getByTestId('instance-header')
+            .getByTestId('ACTIVE-icon');
+        this.incidentIcon = page
+            .getByTestId('instance-header')
+            .getByTestId('INCIDENT-icon');
+        this.userTaskOpenTasklistLink = page.getByRole('link', {
+            name: 'Open Tasklist',
+        });
+        this.taskDetailsPopOver = page.getByTestId('popover');
+        this.connectorResultVariableName = (name) => page.getByTestId('variable-' + name);
+        this.variablesList = page.getByTestId('variables-list');
+        this.messageVariable = page.getByTestId('variable-message');
+    }
+    async connectorResultVariableValue(variableName) {
+        return await this.page.getByTestId(variableName).locator('td').last();
+    }
+    async reload() {
+        await this.page.reload();
+    }
+    async assertProcessCompleteStatusWithRetry(timeout = 60000, maxRetries = 10) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                await (0, test_1.expect)(this.completedIcon).toBeVisible({
+                    timeout: timeout,
+                });
+                return;
+            }
+            catch (error) {
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Process complete status attempt ${attempt + 1} failed. Retrying...`);
+                    await this.page.reload();
+                    await (0, sleep_1.sleep)(5000);
+                }
+                else {
+                    throw new Error(`Assertion failed after ${maxRetries} attempts`);
+                }
+            }
+        }
+    }
+    async assertProcessVariableContainsText(variableName, text) {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                await (0, test_1.expect)(this.page.getByTestId(`variable-${variableName}`)).toContainText(text, { timeout: 30000 });
+                return;
+            }
+            catch (error) {
+                console.log(`Failed to assert variable ${variableName}` + error);
+                await this.page.reload();
+                await (0, sleep_1.sleep)(10000);
+            }
+        }
+        throw new Error(`Failed to assert variable ${variableName} after ${maxRetries} attempts.`);
+    }
+    async clickDiagramTask(taskName) {
+        const diagramTask = this.diagram.getByText(taskName);
+        await (0, test_1.expect)(diagramTask).toBeVisible();
+        await diagramTask.click();
+    }
+    async assertActiveTokenIsPresent() {
+        await (0, test_1.expect)(this.activeIcon).toBeVisible({ timeout: 60000 });
+    }
+    async assertDetailsPopoverIsVisible() {
+        await (0, test_1.expect)(this.taskDetailsPopOver).toBeVisible({
+            timeout: 60000,
+        });
+    }
+}
+exports.OperateProcessInstancePage = OperateProcessInstancePage;

package/dist/pages/8.10/OperateProcessesPage.d.ts

@@ -0,0 +1,25 @@
+import { Page, Locator } from '@playwright/test';
+declare class OperateProcessesPage {
+    private page;
+    readonly processResultCount: Locator;
+    readonly processActiveCheckbox: Locator;
+    readonly processCompletedCheckbox: Locator;
+    readonly processRunningInstancesCheckbox: Locator;
+    readonly processIncidentsCheckbox: Locator;
+    readonly processPageHeading: Locator;
+    readonly noMatchingInstancesMessage: Locator;
+    readonly processFinishedInstancesCheckbox: Locator;
+    readonly processInstanceLink: (name: string) => Locator;
+    readonly moreFiltersButton: Locator;
+    readonly processInstanceKeyTextBox: Locator;
+    constructor(page: Page);
+    private getMoreFilterValueLocator;
+    clickProcessActiveCheckbox(): Promise<void>;
+    clickProcessCompletedCheckbox(): Promise<void>;
+    clickProcessIncidentsCheckbox(): Promise<void>;
+    clickRunningProcessInstancesCheckbox(): Promise<void>;
+    clickFinishedProcessInstancesCheckbox(): Promise<void>;
+    clickProcessInstanceLink(processName: string): Promise<void>;
+    applyMoreFilters(filter: string, value: string): Promise<void>;
+}
+export { OperateProcessesPage };

package/dist/pages/8.10/OperateProcessesPage.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateProcessesPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class OperateProcessesPage {
+    page;
+    processResultCount;
+    processActiveCheckbox;
+    processCompletedCheckbox;
+    processRunningInstancesCheckbox;
+    processIncidentsCheckbox;
+    processPageHeading;
+    noMatchingInstancesMessage;
+    processFinishedInstancesCheckbox;
+    processInstanceLink;
+    moreFiltersButton;
+    processInstanceKeyTextBox;
+    constructor(page) {
+        this.page = page;
+        this.processResultCount = page.getByTestId('result-count');
+        this.processInstanceLink = (name) => this.page
+            .getByRole('row')
+            .filter({ hasText: name })
+            .first()
+            .getByRole('link', { name: /^View instance \d+/ });
+        this.processActiveCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Active' });
+        this.processCompletedCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Completed' });
+        this.processRunningInstancesCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Running Instances' });
+        this.processIncidentsCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Incidents' });
+        this.processPageHeading = page
+            .getByTestId('expanded-panel')
+            .getByText('Process', { exact: true });
+        this.noMatchingInstancesMessage = page.getByText('There are no Instances matching this filter set');
+        this.processFinishedInstancesCheckbox = page
+            .getByTestId('filter-finished-instances')
+            .getByRole('checkbox');
+        this.moreFiltersButton = page.getByRole('button', { name: 'More filters' });
+        this.processInstanceKeyTextBox = page.locator('#ids');
+    }
+    getMoreFilterValueLocator(filter) {
+        switch (filter.trim()) {
+            case 'Process Instance Key(s)':
+                return this.processInstanceKeyTextBox;
+            default:
+                throw new Error(`Unsupported filter: "${filter}". Add a mapping in getMoreFilterValueLocator().`);
+        }
+    }
+    async clickProcessActiveCheckbox() {
+        await this.processActiveCheckbox.click();
+    }
+    async clickProcessCompletedCheckbox() {
+        await this.processCompletedCheckbox.click({ timeout: 60000 });
+        await (0, sleep_1.sleep)(1000);
+    }
+    async clickProcessIncidentsCheckbox() {
+        await this.processIncidentsCheckbox.click();
+    }
+    async clickRunningProcessInstancesCheckbox() {
+        await this.processRunningInstancesCheckbox.click();
+    }
+    async clickFinishedProcessInstancesCheckbox() {
+        await this.processFinishedInstancesCheckbox.click();
+    }
+    async clickProcessInstanceLink(processName) {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                await (0, test_1.expect)(this.processInstanceLink(processName)).toBeVisible({
+                    timeout: 60000,
+                });
+                await this.processInstanceLink(processName).click({ timeout: 60000 });
+                await (0, test_1.expect)(this.page.getByText('Instance History').first()).toBeVisible({
+                    timeout: 10000,
+                });
+                return;
+            }
+            catch (error) {
+                console.error(`Click attempt ${retries + 1} failed: ${error}`);
+                await this.page.reload();
+                await (0, sleep_1.sleep)(10000);
+            }
+        }
+        throw new Error(`Failed to click the link after ${maxRetries} attempts.`);
+    }
+    async applyMoreFilters(filter, value) {
+        await this.moreFiltersButton.click();
+        await this.page.getByRole('menuitem', { name: filter }).click();
+        const valueInput = this.getMoreFilterValueLocator(filter);
+        await (0, test_1.expect)(valueInput).toBeVisible({ timeout: 10000 });
+        await valueInput.fill(value);
+        await (0, sleep_1.sleep)(2000);
+    }
+}
+exports.OperateProcessesPage = OperateProcessesPage;

package/dist/pages/8.10/OptimizeCollectionsPage.d.ts

@@ -0,0 +1,17 @@
+import { Page, Locator } from '@playwright/test';
+declare class OptimizeCollectionsPage {
+    private page;
+    readonly collectionsPageHeader: Locator;
+    readonly createNewButton: Locator;
+    readonly reportOption: Locator;
+    readonly modalCloseButton: Locator;
+    readonly processReport: Locator;
+    readonly collectionsLink: Locator;
+    constructor(page: Page);
+    clickCollectionsLink(): Promise<void>;
+    clickCreateNewButton(): Promise<void>;
+    clickCreateNewButtonWithRetry(): Promise<void>;
+    clickReportOption(): Promise<void>;
+    clickMostRecentProcessReport(reportName: string): Promise<void>;
+}
+export { OptimizeCollectionsPage };

package/dist/pages/8.10/OptimizeCollectionsPage.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeCollectionsPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class OptimizeCollectionsPage {
+    page;
+    collectionsPageHeader;
+    createNewButton;
+    reportOption;
+    modalCloseButton;
+    processReport;
+    collectionsLink;
+    constructor(page) {
+        this.page = page;
+        this.collectionsPageHeader = page.getByRole('heading', {
+            name: 'Collections, Dashboards, and Reports',
+        });
+        this.createNewButton = page.getByRole('button', {
+            name: 'Create new',
+            exact: true,
+        });
+        this.reportOption = page.getByText('Report', { exact: true });
+        this.modalCloseButton = page.locator('button').filter({ hasText: /^Close$/ });
+        this.processReport = page.getByText('Process Report').first();
+        this.collectionsLink = page
+            .getByRole('banner')
+            .getByRole('link', { name: 'Collections' });
+    }
+    async clickCollectionsLink() {
+        await (0, test_1.expect)(this.collectionsLink).toBeVisible({ timeout: 60000 });
+        await this.collectionsLink.click({ timeout: 60000 });
+    }
+    async clickCreateNewButton() {
+        await (0, test_1.expect)(this.createNewButton).toBeVisible({ timeout: 60000 });
+        await this.createNewButton.click({ timeout: 60000 });
+    }
+    async clickCreateNewButtonWithRetry() {
+        const maxRetries = 5;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                if (await this.modalCloseButton.isVisible({ timeout: 15000 })) {
+                    await this.modalCloseButton.click({ timeout: 60000 });
+                }
+                await this.clickCollectionsLink();
+                await this.clickCreateNewButton();
+                return;
+            }
+            catch (error) {
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Attempt ${attempt + 1} failed. Retrying...`);
+                    await this.page.reload();
+                    await (0, sleep_1.sleep)(60000);
+                }
+                else {
+                    throw new Error(`Assertion failed after ${maxRetries} attempts: ` + error);
+                }
+            }
+        }
+    }
+    async clickReportOption() {
+        await this.reportOption.click();
+    }
+    async clickMostRecentProcessReport(reportName) {
+        await this.page.getByText(reportName).click({ timeout: 60000 });
+    }
+}
+exports.OptimizeCollectionsPage = OptimizeCollectionsPage;

package/dist/pages/8.10/OptimizeDashboardPage.d.ts

@@ -0,0 +1,11 @@
+import { Page, Locator } from '@playwright/test';
+declare class OptimizeDashboardPage {
+    private page;
+    readonly filterTable: Locator;
+    constructor(page: Page);
+    clickFilterTable(): Promise<void>;
+    fillFilterTable(processName: string): Promise<void>;
+    processLinkAssertion(processName: string, maxRetries: number, retryDelay?: number): Promise<void>;
+    processOwnerNameAssertion(processName: string, userEmail: string): Promise<void>;
+}
+export { OptimizeDashboardPage };

package/dist/pages/8.10/OptimizeDashboardPage.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeDashboardPage = void 0;
+const test_1 = require("@playwright/test");
+class OptimizeDashboardPage {
+    page;
+    filterTable;
+    constructor(page) {
+        this.page = page;
+        this.filterTable = page.getByPlaceholder('Filter table');
+    }
+    async clickFilterTable() {
+        await this.filterTable.click({ timeout: 120000 });
+    }
+    async fillFilterTable(processName) {
+        await this.filterTable.fill(processName, { timeout: 60000 });
+        await this.filterTable.press('Enter');
+    }
+    async processLinkAssertion(processName, maxRetries, retryDelay = 60000) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                await this.page.reload();
+                await this.clickFilterTable();
+                await this.fillFilterTable(processName);
+                await (0, test_1.expect)(this.page.getByRole('link', { name: processName })).toBeVisible({ timeout: 70000 });
+                return;
+            }
+            catch (error) {
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Attempt ${attempt + 1} failed for asserting process link in Optimize. Retrying...`);
+                    await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                }
+                else {
+                    throw new Error(`Process link in Optimize assertion failed after ${maxRetries} attempts`);
+                }
+            }
+        }
+    }
+    async processOwnerNameAssertion(processName, userEmail) {
+        const maxRetries = 15;
+        const retryDelay = 60000;
+        const localPart = userEmail.split('@')[0];
+        const uuid = localPart.replace('qa-user-', '');
+        const result = !uuid ? 'QA Camunda' : `QA User ${uuid}`;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                await (0, test_1.expect)(this.page.getByRole('row', {
+                    name: `${processName}\nProcess\n\t${result}`,
+                })).toBeVisible({ timeout: 90000 });
+                return;
+            }
+            catch (error) {
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Attempt ${attempt + 1} failed for asserting owner name ${result} assertion for ${processName} in Optimize.. Retrying...`);
+                    await this.page.reload();
+                    await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                }
+                else {
+                    throw new Error(`Owner name ${result} assertion for ${processName} failed after ${maxRetries} attempts`);
+                }
+            }
+        }
+    }
+}
+exports.OptimizeDashboardPage = OptimizeDashboardPage;

package/dist/pages/8.10/OptimizeHomePage.d.ts

@@ -0,0 +1,13 @@
+import { Page, Locator } from '@playwright/test';
+declare class OptimizeHomePage {
+    private page;
+    readonly collectionsLink: Locator;
+    readonly dashboardLink: Locator;
+    readonly modalCloseButton: Locator;
+    readonly optimizeBanner: Locator;
+    readonly noPermissionsMessage: Locator;
+    constructor(page: Page);
+    clickCollectionsLink(): Promise<void>;
+    clickDashboardLink(): Promise<void>;
+}
+export { OptimizeHomePage };

package/dist/pages/8.10/OptimizeHomePage.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeHomePage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class OptimizeHomePage {
+    page;
+    collectionsLink;
+    dashboardLink;
+    modalCloseButton;
+    optimizeBanner;
+    noPermissionsMessage;
+    constructor(page) {
+        this.page = page;
+        this.collectionsLink = page
+            .getByRole('banner')
+            .getByRole('link', { name: 'Collections' });
+        this.dashboardLink = page.getByRole('link', { name: 'Dashboards' });
+        this.modalCloseButton = page.locator('button').filter({ hasText: /^Close$/ });
+        this.optimizeBanner = page.getByRole('link', {
+            name: 'Camunda logo Optimize',
+        });
+        this.noPermissionsMessage = page.getByText('default backend - 404');
+    }
+    async clickCollectionsLink() {
+        if (await this.modalCloseButton.isVisible({ timeout: 60000 })) {
+            await this.modalCloseButton.click();
+        }
+        await this.collectionsLink.click({ timeout: 60000 });
+    }
+    async clickDashboardLink() {
+        const maxRetries = 5;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                if (await this.modalCloseButton.isVisible({ timeout: 15000 })) {
+                    await this.modalCloseButton.click({ timeout: 60000 });
+                }
+                await (0, test_1.expect)(this.dashboardLink).toBeVisible({ timeout: 60000 });
+                await this.dashboardLink.click({ timeout: 60000 });
+                return;
+            }
+            catch (error) {
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Attempt ${attempt + 1} failed. Retrying...`);
+                    await this.page.reload();
+                    await (0, sleep_1.sleep)(60000);
+                }
+                else {
+                    throw new Error(`Assertion failed after ${maxRetries} attempts: ` + error);
+                }
+            }
+        }
+    }
+}
+exports.OptimizeHomePage = OptimizeHomePage;

package/dist/pages/8.10/OptimizeReportPage.d.ts

@@ -0,0 +1,48 @@
+import { Page, Locator } from '@playwright/test';
+declare class OptimizeReportPage {
+    private page;
+    readonly processSelectionButton: Locator;
+    readonly userTaskProcess: Locator;
+    readonly versionSelection: Locator;
+    readonly alwaysDisplayLatestSelection: Locator;
+    readonly createReportLink: Locator;
+    readonly durationButton: Locator;
+    readonly countOption: Locator;
+    readonly processInstanceButton: Locator;
+    readonly userTaskOption: Locator;
+    readonly heatMapButton: Locator;
+    readonly numberButton: Locator;
+    readonly tableOption: Locator;
+    readonly reportName: Locator;
+    readonly saveButton: Locator;
+    readonly oneUserTaskInstance: Locator;
+    readonly twoUserTaskInstance: Locator;
+    readonly cancelButton: Locator;
+    readonly createNewButton: Locator;
+    readonly reportOption: Locator;
+    readonly processInstanceCount: Locator;
+    readonly blankReportButton: Locator;
+    readonly selectDropdown: Locator;
+    constructor(page: Page);
+    clickProcessSelectionButton(): Promise<void>;
+    clickUserTaskProcess(processName: string): Promise<void>;
+    clickVersionSelection(): Promise<void>;
+    clickAlwaysDisplayLatestSelection(): Promise<void>;
+    clickCreateReportLink(): Promise<void>;
+    clickDurationButton(): Promise<void>;
+    clickCountOption(): Promise<void>;
+    clickProcessInstanceButton(): Promise<void>;
+    clickUserTaskOption(): Promise<void>;
+    clickHeatMapButton(): Promise<void>;
+    clickNumberButton(): Promise<void>;
+    clickTableOption(): Promise<void>;
+    clickReportName(): Promise<void>;
+    clearReportName(): Promise<void>;
+    fillReportName(name: string): Promise<void>;
+    clickSaveButton(): Promise<void>;
+    waitUntilLocatorIsVisible(locator: Locator, tab: Page): Promise<void>;
+    waitUntilProcessIsVisible(locator: Locator, tab: Page): Promise<void>;
+    clickBlankReportButton(): Promise<void>;
+    clickSelectDropdown(): Promise<void>;
+}
+export { OptimizeReportPage };