@digital-ai/devops-page-object-release 0.0.0-pikachu-20250811111032 → 0.0.0-pikachu-20250814100204

package/dist/types.d.ts

@@ -0,0 +1,2271 @@
+import { Page, Locator, APIResponse } from "@playwright/test";
+import path from "path";
+import { APIRequestContext } from "playwright-core";
+declare class WithPage {
+    protected readonly page: Page;
+    constructor(page: Page);
+}
+declare class ReleaseCreatePage extends WithPage {
+    releaseForm: Locator;
+    constructor(page: Page);
+    setName(releaseName: string): Promise<void>;
+    setDescription(description: string): Promise<void>;
+    setOwner(ownerName: string): Promise<void>;
+    create(): Promise<void>;
+    expectVariablesCountToBe(count: number): Promise<void>;
+    expectContainingVariable(variableName: string, value: string): Promise<void>;
+    selectTemplate(templateName: string): Promise<void>;
+    removeTemplate(): Promise<void>;
+    setValueForVariables(variableName: string, value: string): Promise<void>;
+    setVariable(variable: string, value: string): Promise<void>;
+    resetVariableValues(): Promise<void>;
+    clickOnPrefillVariables(): Promise<void>;
+    selectPreviousRelease(releaseName: string): Promise<void>;
+    expectPrefillWarning(message: string): Promise<void>;
+}
+declare class ReleasesHeaderPage extends WithPage {
+    constructor(page: Page);
+    getHeaderSelector(): string;
+    getBaseDrawerSelector(): string;
+    getFilterDrawerSelector(): string;
+    getStatusInputSelector(): string;
+    getBasePopperSelector(): string;
+    getSelectAllStatusesButtonSelector(): string;
+    getTitleInputSelector(): string;
+    getRiskLevelInputSelector(): string;
+    setReleaseStatusFilter(statuses: string[]): Promise<this>;
+    setReleaseTagsFilter(tags: string[]): Promise<this>;
+    setTaskTagsFilter(tags: string[]): Promise<this>;
+    setRiskLevelFilter(riskLevel: string): Promise<this>;
+    filterReleaseByTitle(releaseTitle: string): Promise<void>;
+    clearTitleFilter(): Promise<this>;
+    openFilterDrawer(): Promise<this>;
+    closeFilterDrawer(): Promise<this>;
+    clearAllFilters(): Promise<this>;
+    clearAllStatusFilters(): Promise<this>;
+    selectAllStatusFilters(): Promise<this>;
+    gotoListView(): Promise<void>;
+    gotoCalendarView(): Promise<void>;
+    clickOnReleasesPageTab(tabName: 'List' | 'Archived' | 'Calendar'): Promise<this>;
+    toggleFilterFlaggedOnly(): Promise<this>;
+}
+declare class ReleasesListPage extends ReleasesHeaderPage {
+    releaseCreatePage: ReleaseCreatePage;
+    buttonNewRelease: Locator;
+    constructor(page: Page);
+    expectNumberOfReleases(releaseTitle: string, amount: number): Promise<void>;
+    expectReleaseStarted(releaseTitle: string): Promise<void>;
+    expectReleaseStatusInProgress(releaseTitle: string): Promise<void>;
+    expectReleaseAborted(releaseTitle: string): Promise<void>;
+    expectReleaseFailed(releaseTitle: string): Promise<void>;
+    expectReleaseFailing(releaseTitle: string): Promise<void>;
+    expectReleaseCompleted(releaseTitle: string): Promise<void>;
+    expectRedirectToReleasesList(): Promise<void>;
+    openReleaseByName(releaseTitle: string): Promise<ReleasePage>;
+    createNewRelease(releaseName: string, description: string): Promise<void>;
+    createNewReleaseWithOwner(releaseName: string, description: string, ownerName: string): Promise<void>;
+    openReleasesList(): Promise<this>;
+    clickReleaseOptions(releaseTitle: string): Promise<this>;
+    clickAddToRelease(): Promise<this>;
+    checkAddDisabled(): Promise<this>;
+    selectReleaseGroup(rgTitle: string): Promise<this>;
+    clickAddToReleaseGroup(): Promise<this>;
+}
+declare class TriggersPage extends WithPage {
+    openRelatedReleasesOf(title: string): Promise<ReleasesListPage>;
+}
+declare class DateUtil extends WithPage {
+    constructor(page: Page);
+    openDatePicker(selector: string): Promise<void>;
+    /**
+     * Setting date, month and year from calendar picker
+     */
+    setDate(date?: string, monthYear?: string): Promise<void>;
+    expectDurationToBe(duration: string): Promise<void>;
+    setDuration(days?: string, hours?: string, mins?: string): Promise<void>;
+    expectTimeToBe(selector: Locator, format: string, date: Date | string): Promise<void>;
+    /**
+     *
+     * @returns Getting current month and year in the format "MonthName YYYY"
+     */
+    getCurrentMonthYear(): Promise<string>;
+    /**
+     *
+     * @returns Getting current date in the format "dd MonthName YYYY"
+     */
+    getCurrentDate(): Promise<string>;
+    /**
+     *
+     * @param days Number of days to add to current date within the current month
+     * @returns
+     */
+    getFutureDate(days: number): Promise<string>;
+    removeDate(selector: Locator): Promise<void>;
+    expectDateNotDeletable(selector: Locator): Promise<void>;
+    expectDateToBe(selector: Locator, date: Date | string): Promise<void>;
+    expectDateToBeInferred(selector: Locator): Promise<void>;
+    expectNoDate(selector: Locator): Promise<void>;
+    expectInputContainingDate(inputLocator: Locator, date: Date | string): Promise<void>;
+}
+declare class VariablePage extends WithPage {
+    addListValue: Locator;
+    addVariableValue: Locator;
+    listAddButton: Locator;
+    dateUtil: DateUtil;
+    constructor(page: Page);
+    openVariable(variableKey: string): Promise<VariableModal>;
+    addNewVariable(variableName: string, labelname: string, description?: string): Promise<void>;
+    addNewVariableInFolder(variableName: string, labelname: string, description?: string): Promise<void>;
+    selectVariableTextType(valueName: string, multiline?: boolean): Promise<void>;
+    selectVariableListboxType(possiblevalue: Array<string> | string, defaultValue: string, required?: true): Promise<void>;
+    selectVariablePasswordType(possiblevalue: string): Promise<void>;
+    selectVariableCheckboxType(): Promise<void>;
+    selectVariableNumberType(possiblevalue: string): Promise<void>;
+    selectVariableMultiListType(possiblevalue1: string, possiblevalue2: string): Promise<void>;
+    selectVariableByDate(date: string, monthYear: string): Promise<void>;
+    setDate(date?: string, monthYear?: string): Promise<void>;
+    addVariableKeyValueMap(keys1: string, values1: string): Promise<void>;
+    addVariableSet(possiblevalue1: string): Promise<void>;
+    submitTheVariable(): Promise<void>;
+    expectVariableWithNameValueAndType(name: string, value: string, type: string): Promise<void>;
+    clickEditVariable(variableName: string): Promise<VariableModal>;
+    clickDeleteVariable(variableName: string): Promise<DeleteVariableModel>;
+    expectVariablesCountToBe(count: number): Promise<void>;
+    expectVariableNotPresent(variableName: string): Promise<void>;
+    clearReleaseVariableSearch(): Promise<void>;
+    switchPossibleValuesToVariable(variableName: string): Promise<void>;
+    selectVariableListboxTypeWithVariable(variableName: string, defaultValue: string, required?: boolean): Promise<void>;
+    clickMultiline(): Promise<void>;
+    searchFolderVariable(variableName: string): Promise<void>;
+    clearFolderVarSearch(): Promise<void>;
+    clickFolderVariableButton(): Promise<void>;
+    clickReleaseVariableButton(): Promise<void>;
+}
+declare class VariableModal extends WithPage {
+    dateUtil: DateUtil;
+    constructor(page: Page);
+    expectValueToBe(value: string): Promise<void>;
+    expectValueToContain(value: string): Promise<void>;
+    close(): Promise<void>;
+    expectPossibleValues(possiblevalue: Array<string> | string): Promise<void>;
+    expectPossibleVariableValues(possibleVariableValue: string): Promise<void>;
+    addPossibleValue(value: Array<string> | string): Promise<void>;
+    selectVariableValue(defaultValue: string): Promise<void>;
+    save(): Promise<void>;
+    createPossibleValuesVariable(variableName: string): Promise<void>;
+    expectVariableValueToBe(value: string): Promise<void>;
+    expectNoVariablesInList(): Promise<void>;
+    expectNameInput(value: string): Promise<void>;
+    expectLabel(value: string): Promise<void>;
+    expectRequired(value: boolean): Promise<void>;
+    setDescription(description: string): Promise<void>;
+    setLabel(labelValue: string): Promise<void>;
+    setDate(date: string, monthYear: string): Promise<void>;
+    setValue(value: string): Promise<void>;
+    clearValue(): Promise<void>;
+    clickMultiline(): Promise<void>;
+    setValueForMultilinePassword(value: string): Promise<void>;
+}
+declare class DeleteVariableModel extends WithPage {
+    model: VariableModal;
+    dateUtil: DateUtil;
+    constructor(page: Page);
+    deleteVariable(): Promise<void>;
+    replaceItWithVariable(variable: string): Promise<void>;
+    replaceItwithValue(value: string): Promise<void>;
+    clickReplaceAndDelete(): Promise<void>;
+    addValue(value: string): Promise<void>;
+    remove(value: string): Promise<void>;
+    expectReplacementPromptDisplayed(): Promise<void>;
+    close(): Promise<void>;
+    removeItemOnSet(value: string): Promise<void>;
+    addValueForSet(key: string, value: string): Promise<void>;
+    replaceWithIntegerValue(value: string): Promise<void>;
+    replaceForBooleanValue(): Promise<void>;
+    deleteBySettingDate(date: string, monthYear: string): Promise<void>;
+}
+declare class ActivityRail extends WithPage {
+    commentFilterInput: Locator;
+    filterIconButton: Locator;
+    markdownWrapper: Locator;
+    sortButton: Locator;
+    systemListItem: Locator;
+    tooltipPopper: Locator;
+    userListItem: Locator;
+    viewAllListItem: Locator;
+    constructor(page: Page);
+    expectCommentToContain(comment: string, shouldContain?: boolean): Promise<void>;
+    expectCommentToContainAtPosition(comment: string, positionIndex: number): Promise<this>;
+    expectCommentToContainLink(hrefLink: RegExp): Promise<void>;
+    expectTaskIsCommentable(isCommentable: boolean): Promise<void>;
+    addComment(comment: string): Promise<this>;
+    searchComments(filter: string): Promise<this>;
+    clickOnFilterIconButton(): Promise<this>;
+    clickOnUserListItemFilter(): Promise<this>;
+    clickOnSystemListItemFilter(): Promise<this>;
+    clickOnViewAllListItemFilter(): Promise<this>;
+    clickOnSortIconButton(): Promise<this>;
+    expectAuthorCommentsToBe(author: string): Promise<this>;
+    expectSortIconButtonToHaveTooltipText(tooltipText: string): Promise<this>;
+    expectCommentsDateTimeToBe(comment: string, date: string): Promise<this>;
+}
+declare class AttachmentRail extends WithPage {
+    expectWithAttachment(filename: string): Promise<void>;
+    getAttachmentsListCount(): Promise<number>;
+    uploadFile(filePath: string): Promise<void>;
+    downloadFile(filename: string): Promise<void>;
+    deleteAttachment(fileName: string): Promise<void>;
+    expectWithNoAttachment(tempFile: string): Promise<void>;
+}
+declare class AttributeRail extends WithPage {
+    constructor(page: Page);
+    clickAddAttribute(): Promise<void>;
+    expectAttributeEditable(): Promise<void>;
+    addTag(tagName: string): Promise<void>;
+    expectContainsTag(tagName: Array<string> | string): Promise<void>;
+    selectAttributeType(type: string): Promise<void>;
+    fillInputValue(labelName: string, value: string): Promise<void>;
+    saveAttributes(): Promise<void>;
+    cancelAttribute(): Promise<void>;
+    setInputTextField(fieldId: string, value: string): Promise<void>;
+    expectFacetCountToBe(count: number): Promise<void>;
+    expectFieldValueToBe(fieldId: string, value: string): Promise<void>;
+    clickEditExistingFacet(facetName: string): Promise<void>;
+    deleteFacet(faceName: string): Promise<void>;
+}
+declare class ConditionRail extends WithPage {
+    railLocator: Locator;
+    preconditionToggle: Locator;
+    textEditor: Locator;
+    saveButton: Locator;
+    constructor(page: Page);
+    enablePrecondition(): Promise<void>;
+    disablePrecondition(): Promise<void>;
+    setPrecondition(script: string): Promise<void>;
+    expectPreconditionEditable(editable: boolean): Promise<void>;
+    enableFailureHandler(): Promise<void>;
+    expectEnabledFailureHandlerToggle(): Promise<void>;
+    expectDisabledFailureHandlerToggle(): Promise<void>;
+    clickFailureHandler(): Promise<this>;
+    clickPrecondition(): Promise<this>;
+    expectFailureHandlerHasDefaults(): Promise<this>;
+    selectPostAction(action: string): Promise<this>;
+    enterFailureHandlerScript(script: string): Promise<this>;
+    expectScriptToContain(script: string): Promise<void>;
+    expectFailureHandlerEditable(): Promise<this>;
+}
+declare class ConfigRail extends WithPage {
+    railLocator: Locator;
+    constructor(page: Page);
+    openInputProperties(): Promise<void>;
+    openOutputProperties(): Promise<void>;
+    getValueFromCi(propertyName: string): Promise<string>;
+    getAllOptionsFromCi(propertyName: string): Promise<string[]>;
+    setValueFromCi(propertyName: string, value: string): Promise<void>;
+    getValueFromString(propertyName: string): Promise<string | null>;
+    setValueFromString(propertyName: string, value: string): Promise<void>;
+    setValueFromLargeString(propertyName: string, value: string): Promise<void>;
+    setValueFromPassword(propertyName: string, value: string): Promise<void>;
+    setAndCreateVariable(propertyName: string, variableName: string): Promise<void>;
+    setVariable(propertyName: string, variableName: string): Promise<void>;
+    expectValueFromString(propertyName: string, propertyValue: string): Promise<void>;
+}
+declare class OverviewRail extends WithPage {
+    dependency: Dependency;
+    modal: ModalWindow;
+    railLocator: Locator;
+    scriptTextArea: Locator;
+    constructor(page: Page);
+    openInputProperties(): Promise<void>;
+    openOutputProperties(): Promise<void>;
+    getValueFromCi(propertyName: string): Promise<string>;
+    getAllOptionsFromCi(propertyName: string): Promise<string[]>;
+    setValueFromCi(propertyName: string, value: string): Promise<void>;
+    clickCreateNewCiInVariable(propertyName: string): Promise<void>;
+    getValueFromString(propertyName: string): Promise<string | null>;
+    getStringListField(propertyName: string): Promise<StringList>;
+    getStringSetField(propertyName: string): Promise<StringSet>;
+    getStringMapField(propertyName: string): Promise<StringMap>;
+    setValueFromString(propertyName: string, value: string): Promise<void>;
+    setValueFromLargeString(propertyName: string, value: string): Promise<void>;
+    setValueForBody(value: string): Promise<void>;
+    setValueFromPassword(propertyName: string, value: string): Promise<void>;
+    selectVariableFromOption(objectID: string, variable: string): Promise<void>;
+    setValueForDateVariable(variable: string, date: string): Promise<this>;
+    createNewVariableForField(objectID: string, variable: string): Promise<void>;
+    createReleaseIdInOutputProperties(propertyName: string, variableName: string): Promise<void>;
+    expectValueInOutputProperties(variableId: string, value: string, expected?: boolean): Promise<void>;
+    expectValueInInputProperties(propertyName: string, value: string, expected?: boolean): Promise<void>;
+    selectReleaseIdInOutputProperties(objectID: string, variableName: string): Promise<void>;
+    expectVariable(propertyName: string, expected?: boolean): Promise<void>;
+    expectAlertMessage(alertMessage: string): Promise<void>;
+    expectValueFromString(propertyName: string, propertyValue: string): Promise<void>;
+    expectValueFromResultString(propertyName: string, value: string): Promise<this>;
+    expectDisabledInputField(propertyName: string): Promise<this>;
+    expectRiskProfileValue(value: string): Promise<void>;
+    expectTo(value: string): Promise<void>;
+    expectAutoCompleteFieldValue(label: string, value: string[] | string): Promise<void>;
+    expectFieldValue(fieldName: string, value: string): Promise<void>;
+    expectSubjectToBe(value: string): Promise<void>;
+    expectBodyToBe(value: string): Promise<void>;
+    expectReleaseTitleToBe(value: string): Promise<void>;
+    setBody(value: string): Promise<void>;
+    setReleaseTags(tags: Array<string> | string): Promise<void>;
+    setScript(script: string): Promise<void>;
+    expectScriptToContain(script: string): Promise<void>;
+    enterScriptForAutoComplete(script: string): Promise<void>;
+    openScriptEditorInSeparateWindow(): Promise<void>;
+    closeFullscreenScriptWindowWithESC(): Promise<void>;
+    closeFullscreenScriptWindow(): Promise<void>;
+    abort(comment: string): Promise<void>;
+    expectDependenciesDisplayed(dependencies: any[]): Promise<void>;
+    expectDependencyStatus(option?: boolean): Promise<void>;
+    expectResolvedDependency(): Promise<void>;
+    expectUnresolvedDependency(): Promise<void>;
+    expectCanDeleteDependency(title: string, canDelete?: boolean): Promise<void>;
+    expectDependencyContextualMenu(option?: boolean): Promise<void>;
+    expectDependencyContextualMenuFor(title: string, option?: boolean): Promise<void>;
+    removeDependency(title: string): Promise<void>;
+    expectDependencyNotToBeVisible(): Promise<void>;
+    getDependencyCount(): Promise<number>;
+    addDependency(): Promise<void>;
+    addCondition(): Promise<void>;
+    expectDependencyText(dependencies: string, isVisible?: boolean): Promise<void>;
+    clickEditDependency(dependencies: string): Promise<void>;
+    validateAutoCompleteOptionsInDescription(descriptionName: string, expectedVariableCount: number, variableToSelection?: string): Promise<void>;
+    validateAutoCompleteOptions(fieldLabel: string, value: string, expectedVariableCount: number, variableToSelect?: string): Promise<void>;
+    setReleaseTitle(releaseName: string): Promise<void>;
+    setFolder(folderName: string): Promise<void>;
+    setTemplate(templateName: string): Promise<void>;
+    clearTemplate(): Promise<void>;
+    errorMsgVisible(errorMessage: string): Promise<void>;
+    isButtonVisible(buttonName: string, visible?: boolean): Promise<void>;
+    cancelDialogWindow(): Promise<void>;
+    acceptDialogWindow(): Promise<void>;
+    setRiskProfile(RiskProfile: string): Promise<void>;
+    expectTemplate(template: string): Promise<void>;
+    setAutoCompletePassword(passwordValue: string): Promise<void>;
+    setAutoCompleteField(fieldLabel: string, value: string): Promise<void>;
+    setNewAutoCompleteField(fieldLabel: string, value: string): Promise<void>;
+    setTextField(fieldID: string, value: string): Promise<void>;
+    setEmailField(fieldName: string, value: string): Promise<void>;
+    selectValueFromOption(fieldId: string, value: string): Promise<void>;
+    abortButtonVisibility(visible?: boolean): Promise<void>;
+    setPattern(patternName: string): Promise<void>;
+    setStartDate(date: string): Promise<void>;
+    setEndDate(date: string): Promise<void>;
+    enableFallback(): Promise<void>;
+    expectDescription(description: string): Promise<void>;
+    editDescription(description: string): Promise<void>;
+    expectedGateConditionDisplayed(title: string, isVisible?: boolean): Promise<void>;
+    expectedGateConditionChecked(title: string, expected?: boolean): Promise<void>;
+    removeCondition(title: string): Promise<void>;
+    checkGateCondition(title: string): Promise<void>;
+    expectScriptEditable(): Promise<void>;
+    expectInputPropertiesEditable(propertyName: Array<string> | string): Promise<void>;
+    setSelectField(fieldName: string, fieldValue: string): Promise<void>;
+    expectStartReleaseToBe(value: string): Promise<void>;
+    setStartReleaseVariable(value: string): Promise<void>;
+    close(): Promise<void>;
+    deselectValue(ObjectID: string): Promise<this>;
+    expectEditVariableList(isVisible?: boolean): Promise<this>;
+    clickEditVariableList(): Promise<this>;
+    removeVariable(variableName: string): Promise<this>;
+    saveVariable(): Promise<this>;
+    selectVariable(variable: Array<string> | string): Promise<this>;
+    setValueForUserInputField(propertyName: string, value: string): Promise<void>;
+    toggleIgnoreVariableInterpolation(): Promise<void>;
+}
+declare class ModalWindow extends WithPage {
+    saveLocator: Locator;
+    modalLocator: Locator;
+    constructor(page: Page);
+    setInputTextField(propertyName: string, value: string): Promise<void>;
+    save(): Promise<void>;
+}
+declare class Dependency extends WithPage {
+    constructor(page: Page);
+    getRelease(): Promise<string | null>;
+    getPhase(): Promise<string | null>;
+    getTask(): Promise<string | null>;
+    setRelease(releaseTitle: string): Promise<void>;
+    save(): Promise<void>;
+    setPhase(phaseTitle: string): Promise<void>;
+    setTask(taskTitle: string): Promise<void>;
+    clearPhase(): Promise<void>;
+    expectVariableModeEnabled(mode: boolean): Promise<void>;
+    clickVariable(): Promise<void>;
+    expectMinimumOptions(options: any[]): Promise<void>;
+    enterNewVariable(variableName: string): Promise<void>;
+    selectVariable(variableName: string): Promise<void>;
+}
+declare class StringList extends WithPage {
+    propertyName: string;
+    constructor(propertyName: string, page: Page);
+    setValueFromStringList(value: string): Promise<this>;
+    expectStringListCount(count: number): Promise<this>;
+    removeValueFromStringList(value: string): Promise<this>;
+    expectInputFieldDisabled(): Promise<this>;
+    expectValueFromStringList(value: string): Promise<this>;
+}
+declare class StringSet extends WithPage {
+    propertyName: string;
+    constructor(propertyName: string, page: Page);
+    setValueFromStringSet(value: string): Promise<this>;
+    expectInputFieldDisabled(): Promise<this>;
+    expectAddButtonDisabled(): Promise<this>;
+    expectStringSetCount(count: number): Promise<this>;
+    removeValueFromStringSet(key: string): Promise<this>;
+}
+declare class StringMap extends WithPage {
+    propertyName: string;
+    constructor(propertyName: string, page: Page);
+    setValueFromMap(key: string, value: string): Promise<void>;
+    removeValueFromMap(key: string): Promise<this>;
+    expectStringMapCount(count: number): Promise<this>;
+    expectAddButtonDisabledForMap(key: string, value: string): Promise<this>;
+    expectInputFieldDisabledForMap(): Promise<this>;
+}
+declare class SchedulingRail extends WithPage {
+    dateUtil: DateUtil;
+    constructor(page: Page);
+    expectStartDateToBeDisplayed(): Promise<void>;
+    expectStartDateToBe(date: string): Promise<void>;
+    expectStartDateWarningBannerToNotBePresent(): Promise<void>;
+    expectStartDateWarningBanner(text: string, originalScheduledStartDate?: string): Promise<void>;
+    expectEndDateToBeDisplayed(): Promise<void>;
+    switchWaitForScheduledDate(): Promise<void>;
+    expectWaitForScheduledDateToBeChecked(): Promise<void>;
+    expectWaitForScheduledDateToBeUnchecked(): Promise<void>;
+    setDueTime(day?: string, hour?: string, minute?: string): Promise<void>;
+    setStartDate(date: string, monthYear: string): Promise<void>;
+    setEndDate(date: string, monthYear: string): Promise<void>;
+    setDate(date: string, monthYear: string): Promise<void>;
+    checkDelayDuringBlackoutPeriod(): Promise<void>;
+    unCheckDelayDuringBlackoutPeriod(): Promise<void>;
+    checkEnvironmentAvailability(): Promise<void>;
+    unCheckEnvironmentAvailability(): Promise<void>;
+}
+declare class HistoryRail extends WithPage {
+    logsFilterInput: Locator;
+    logContentWrapper: Locator;
+    sortButton: Locator;
+    constructor(page: Page);
+    expectLogToContain(log: string, shouldContain?: boolean): Promise<void>;
+    expectLogToContainAtPosition(log: string, positionIndex: number): Promise<this>;
+    searchLogs(filter: string): Promise<this>;
+    clickOnSortIconButton(): Promise<this>;
+}
+type Rail = 'Overview' | 'Activity' | 'Config' | 'Scheduling' | 'Conditions' | 'Attributes' | 'Attach' | 'Tags' | 'History';
+declare class TaskDrawer extends WithPage {
+    activity: ActivityRail;
+    attachment: AttachmentRail;
+    attribute: AttributeRail;
+    cancelButton: Locator;
+    commentBox: Locator;
+    completeButton: Locator;
+    confirm: Locator;
+    config: ConfigRail;
+    condition: ConditionRail;
+    failMenu: Locator;
+    history: HistoryRail;
+    retryButton: Locator;
+    openMenu: Locator;
+    overview: OverviewRail;
+    scheduling: SchedulingRail;
+    skipMenu: Locator;
+    startButton: Locator;
+    taskDrawerLocator: Locator;
+    constructor(page: Page);
+    waitForTaskDrawer(): Promise<void>;
+    openOverviewRail(): Promise<void>;
+    openActivityRail(): Promise<void>;
+    openSchedulingRail(): Promise<SchedulingRail>;
+    openConditionRail(): Promise<void>;
+    openAttributesRail(): Promise<void>;
+    openAttachRail(): Promise<void>;
+    openTagsRail(): Promise<void>;
+    openHistoryRail(): Promise<void>;
+    openRail(rail: Rail): Promise<void>;
+    close(): Promise<void>;
+    retryTask(comment: string): Promise<void>;
+    skipTask(comment: string): Promise<void>;
+    failTask(comment: string): Promise<void>;
+    completeTask(comment: string): Promise<void>;
+    startNow(comment: string): Promise<void>;
+    startNowWithBlackout(comment: string): Promise<void>;
+    expectTaskTitle(taskTitle: string): Promise<void>;
+    expectCompleteButtonEnabled(): Promise<void>;
+    expectCompleteButtonNotEnabled(): Promise<void>;
+    expectButtonNotVisible(buttonName: string): Promise<this>;
+    expectSkipMenuNotEnabled(): Promise<void>;
+    setTitle(title: string): Promise<void>;
+    expectTaskTitleEditable(): Promise<this>;
+    expectTypeToContain(taskType: string): Promise<void>;
+    clickExpand(): Promise<void>;
+    clickShrink(): Promise<void>;
+    expectAssignedTo(username: string): Promise<void>;
+    expectStartButtonToBeEnabled(isEnabled?: boolean): Promise<void>;
+    startTask(comment: string): Promise<void>;
+    clickOnStartDate(): Promise<void>;
+    removeStartDate(): Promise<void>;
+    setStartDate(date: string): Promise<void>;
+    assignToMe(userName: string, existingUsername: string): Promise<void>;
+    expectAssigneeToBeEnabled(): Promise<void>;
+    removeAssignToUser(userName: string): Promise<this>;
+    assignToTeam(existingTeamName: string, teamName: string): Promise<this>;
+    expectAssignedToTeam(teamName: string): Promise<void>;
+    removeAssignedTeam(teamName: string): Promise<this>;
+    setFlag(flagName: string, flagComment: string): Promise<void>;
+    expectFlaggedWith(flagName: string, flagComment: string): Promise<void>;
+    expectStartDateToBeDisplayed(): Promise<void>;
+    expectStartDayToBeInAvatar(expectedDay: string): Promise<void>;
+    expectEndDayToBeInAvatar(expectedDay: string): Promise<void>;
+    expectEndDateToBeDisplayed(): Promise<void>;
+    expectStartDateAndEndDateToBeDisplayed(): Promise<void>;
+    expectPhaseAndTaskTitleToContain(phaseName: string, taskTitle: string): Promise<void>;
+    expectTaskStatusLine(statusLine: string): Promise<void>;
+    expectTaskStatusLineHref(link: RegExp): Promise<void>;
+    expectNoTaskActionButton(): Promise<void>;
+    clickTaskOptionIcon(): Promise<void>;
+    deleteTaskFromOption(): Promise<void>;
+    duplicateTaskFromOption(): Promise<void>;
+    expectOptionNotVisible(option: string): Promise<void>;
+    refresh(): Promise<void>;
+    expectRefreshButtonNotVisible(): Promise<void>;
+}
+declare class ReleaseGanttPage extends WithPage {
+    releaseHeader: Locator;
+    taskDrawer: TaskDrawer;
+    constructor(page: Page);
+    enableShowDates(): Promise<void>;
+    disableShowDates(): Promise<void>;
+    expectPlanningDataColumnsHidden(): Promise<void>;
+    expectPlanningDateColumnsShown(): Promise<void>;
+    expectReleaseOnBreadcrumb(title: string): Promise<void>;
+    expectPhaseDisplayed(phaseName: string): Promise<void>;
+    expectTaskDisplayed(taskName: string, isDisplayed?: boolean): Promise<void>;
+    expandGanttTree(title: string): Promise<void>;
+    expectDifferentWidth(title1: string, title2: string): Promise<void>;
+    expectSameWidth(title1: string, title2: string): Promise<void>;
+    expectElementWithClasses(title: string, classes: Array<string>): Promise<void>;
+    resizeToDayIndex(title: string, index: number): Promise<void>;
+    expectLinksToBeDisplayed(countOfLinks: number): Promise<void>;
+    expectLeftHandleVisibility(title: string, visible: boolean): Promise<void>;
+    expectRightHandleVisibility(title: string, visible: boolean): Promise<void>;
+    openTaskDrawer(title: string): Promise<TaskDrawer>;
+    openPhaseDetails(phaseName: string): Promise<void>;
+    getRow(phaseName: string): GanttRow;
+}
+declare class GanttRow extends WithPage {
+    dateUtil: DateUtil;
+    constructor(page: Page, phaseName: string);
+    setStartDate(date?: string, monthYear?: string): Promise<void>;
+    setEndDate(date?: string, monthYear?: string): Promise<void>;
+    expectStartDateToBe(date: Date | string): Promise<void>;
+    expectEndDateToBe(date: Date | string): Promise<void>;
+    removeStartDate(): Promise<void>;
+    removeEndDate(): Promise<void>;
+    expectStartDateToBeInferred(): Promise<void>;
+    expectEndDateToBeInferred(): Promise<void>;
+    expectStartDateNotDeletable(): Promise<void>;
+    expectEndDateNotDeletable(): Promise<void>;
+    expectDurationToBe(duration: string): Promise<void>;
+    clickDuration(): Promise<void>;
+    removeDuration(): Promise<void>;
+    expectNoDuration(): Promise<void>;
+}
+declare class ReleasePropertiesPage extends WithPage {
+    constructor(page: Page);
+    editReleaseName(name: string): Promise<void>;
+    setDescription(description: string): Promise<void>;
+    setScriptUsername(username: string): Promise<void>;
+    setScriptUserPassword(password: string): Promise<void>;
+    save(): Promise<void>;
+    reset(): Promise<void>;
+    expectWithAttachment(filename: string): Promise<void>;
+    getAttachmentsListCount(): Promise<number>;
+    uploadFile(filePath: string): Promise<void>;
+    expectWithNoAttachment(filename: string): Promise<void>;
+    downloadFile(filename: string): Promise<void>;
+    deleteAttachment(fileName: string): Promise<void>;
+    expectVariableDisplayed(variable: string, present: boolean): Promise<void>;
+    setScheduledStartDate(date?: string, monthYear?: string): Promise<void>;
+    setScheduledStartTime(hrs?: string, mins?: string, meridian?: string): Promise<void>;
+    setDuration(days?: string, hours?: string, mins?: string): Promise<void>;
+    expectScheduledStartDateToBe(date: string): Promise<void>;
+    expectScheduledStartTimeToBe(date: string): Promise<void>;
+    expectDueDateToBe(date: string): Promise<void>;
+    expectedDueDateTime(time: string): Promise<void>;
+    expectDurationToBe(duration: string): Promise<void>;
+    setDueDate(hrs?: string, min?: string, meridian?: string): Promise<void>;
+    checkAbortOnFailure(): Promise<void>;
+    expectDescriptionToBe(description: string): Promise<void>;
+    expectReleaseNameToBe(name: string): Promise<void>;
+    expectStartDateReadonly(): Promise<void>;
+    expectEndDateReadonly(): Promise<void>;
+    setOwner(user: string): Promise<void>;
+    expectPageTitleToBeInBreadcrumbLink(releaseName: string): Promise<void>;
+    reloadPage(): Promise<void>;
+    expectOwnerToBe(user: string): Promise<void>;
+    expectReleaseTaggedWith(tagName: string): Promise<void>;
+    expectTemplateTitleToBe(templateTitle: string): Promise<void>;
+    expectRiskProfileTitleToBe(riskProfile: string): Promise<void>;
+    expectStartFromReleaseToBe(parentRelease: string): Promise<void>;
+    expectTemplateURLToBe(templateURL: string): Promise<void>;
+    expectStartFromReleaseURLToBe(parentReleaseURL: string): Promise<void>;
+}
+declare class ReleaseTeamsAndPermissionsPage extends WithPage {
+    saveButton: Locator;
+    resetButton: Locator;
+    constructor(page: Page);
+    expectSaveButtonDisabled(): Promise<void>;
+    expectUserIsAssignedToTeam(teamName: string, userName: string): Promise<void>;
+}
+declare class ReleaseTableViewPage extends WithPage {
+    commentBox: Locator;
+    contextMenuButton: Locator;
+    completeButton: Locator;
+    dateUtil: DateUtil;
+    refreshButton: Locator;
+    taskDrawer: TaskDrawer;
+    constructor(page: Page);
+    openContextMenuForTask(taskTitle: string): Promise<void>;
+    callMenuOptionsForTask(taskTitle: string, option: string, taskGroup?: string, taskType?: string): Promise<void>;
+    expectAssignToUser(taskTitle: string, username: string): Promise<void>;
+    expectToHasGateIcon(taskTitle: string): Promise<void>;
+    expectTaskRowCountToBe(title: string, expectedCount: number): Promise<void>;
+    setHeaderFilter(columnTitle: string, valueToFilter: string): Promise<void>;
+    expectRowCountToBe(cellCount: number): Promise<void>;
+    filterStartDate(date: string, monthYear: string): Promise<void>;
+    filterEndDate(date: string, monthYear: string): Promise<void>;
+    openTaskDrawer(taskTitle: string): Promise<TaskDrawer>;
+    collapseNthRowByIndex(Indexnumber: number): Promise<void>;
+    closePhaseModal(): Promise<void>;
+    expectTaskToHaveStatus(taskTitle: string, status: string): Promise<void>;
+    expectOverdueOnEndDate(taskTitle: string): Promise<void>;
+    selectTask(taskTitle: string): Promise<void>;
+    expectSelectedTasksCounter(text: string): Promise<void>;
+    clearSelection(): Promise<this>;
+    assignSelectedTasks(owner?: string, team?: string): Promise<this>;
+    expectSuccessMessage(successMessage: string): Promise<this>;
+    completeSelectedTasks(comment: string): Promise<this>;
+    selectFromMoreActions(menuItem: string): Promise<this>;
+    addCommentToSelectedTask(comment: string): Promise<this>;
+    selectSubtasks(item: string): Promise<this>;
+    shiftSelectFromTo(taskFrom: string, taskTo: string): Promise<this>;
+    isContextualMenuItemEnabled(menuName: string, taskTitle: string): Promise<void>;
+    isContextualMenuItemDisabled(menuName: string, taskTitle: string): Promise<void>;
+    closeContextMenu(): Promise<void>;
+    expectDisabledActions(actionName: string): Promise<this>;
+    expectDisabledActionsOnMoreActionsMenu(menuItem: Array<string> | string): Promise<this>;
+}
+declare class Util extends WithPage {
+    tempDir: string;
+    content: string;
+    closeIcon: Locator;
+    constructor(page: Page);
+    createTempFile(fileName: path.ParsedPath | string, testInfo: any): Promise<void>;
+    expandAllFolders(): Promise<void>;
+    openSideNavMenu(menuItem: string): Promise<void>;
+    openNestedMenuItem(nestedMenuItem: string): Promise<void>;
+    clickCloseIcon(): Promise<void>;
+    clickOnStatusField(): Promise<void>;
+    clickOnStatus(statusNames: string[]): Promise<void>;
+    clickOnStatusClearAll(): Promise<void>;
+    clickOnStatusSelectAll(): Promise<void>;
+    setOrderBy(orderBy: string): Promise<void>;
+    setSearchFilter(filterText: string): Promise<void>;
+    clearSearchFilter(): Promise<void>;
+    leaveWithoutSaving(): Promise<void>;
+}
+declare class ReleasePage extends WithPage {
+    addPhaseBtn: Locator;
+    createPage: ReleaseCreatePage;
+    ganttPage: ReleaseGanttPage;
+    tableView: ReleaseTableViewPage;
+    taskDrawer: TaskDrawer;
+    teamsPermissions: ReleaseTeamsAndPermissionsPage;
+    phaseTitle: Locator;
+    properties: ReleasePropertiesPage;
+    variables: VariablePage;
+    util: Util;
+    constructor(page: Page);
+    openTriggers(): Promise<TriggersPage>;
+    abort(comment?: string): Promise<void>;
+    getPhase(phaseName: string): Phase;
+    expectPhaseCountToBe(expectedPhaseCount: number): Promise<void>;
+    expectVariableToBeFound(variableName: string): Promise<void>;
+    expectNotFlagged(): Promise<void>;
+    expectRiskFlagOnTaskCard(): Promise<void>;
+    expectBlackoutIconOnTaskCard(taskTitle: string): Promise<void>;
+    expectFlagOnCompletedTaskCard(): Promise<void>;
+    refresh(): Promise<void>;
+    start(): Promise<void>;
+    waitForCompletion(timeout?: number): Promise<void>;
+    waitForTaskCompleted(taskTitle: string, timeout?: number): Promise<void>;
+    waitForTaskNeedsInput(taskTitle: string): Promise<void>;
+    waitForTaskCompletedInAdvance(taskTitle: string, timeout?: number): Promise<void>;
+    waitForTaskInProgress(taskTitle: string, timeout?: number): Promise<void>;
+    waitForTaskFailed(taskTitle: string, timeout?: number): Promise<void>;
+    waitForTaskFailing(taskTitle: string): Promise<void>;
+    waitForTaskSkipped(taskTitle: string, timeout?: number): Promise<void>;
+    waitForTaskSkippedInAdvance(taskTitle: string, timeout?: number): Promise<void>;
+    waitForTaskAborted(taskTitle: string, timeout?: number): Promise<void>;
+    waitForStatusLine(statusLine: string, timeout?: number): Promise<void>;
+    expectTaskStatusLineToContain(taskTitle: string, info: string): Promise<void>;
+    expectTaskStatusLineToContainHref(taskTitle: string, link: RegExp): Promise<void>;
+    waitForTaskStarted(taskTitle: string, timeout?: number): Promise<void>;
+    waitForTaskPlanned(title: string): Promise<void>;
+    clickOnStatusLine(statusLine: string): Promise<void>;
+    expectTaskCompletedInAdvance(taskTitle: string): Promise<void>;
+    expectTaskPending(taskTitle: string): Promise<void>;
+    expectCurrentTaskToContain(taskTitle: string): Promise<void>;
+    openManualTaskDetails(title: string): Promise<void>;
+    reopenTask(comment: string): Promise<void>;
+    openTaskDrawer(taskName: string): Promise<TaskDrawer>;
+    openTaskDrawerFromTableView(taskName: string): Promise<TaskDrawer>;
+    openTaskDrawerFromGrantt(taskName: string): Promise<TaskDrawer>;
+    openVariables(): Promise<void>;
+    openProperties(): Promise<void>;
+    openReleaseFlow(): Promise<void>;
+    openRelationships(): Promise<void>;
+    openTeamsPermissions(): Promise<void>;
+    openDashboard(): Promise<void>;
+    openHistory(): Promise<void>;
+    openTask(taskName: string): Promise<void>;
+    collapseAllTaskView(): Promise<void>;
+    expandAllTaskView(): Promise<void>;
+    expectTemplateLabelNotToBePresent(): Promise<void>;
+    expectAbortedStatusToBePresent(): Promise<void>;
+    expectInProgressStatusToBePresent(): Promise<void>;
+    expectFailedStatusToBePresent(): Promise<void>;
+    openTableView(): Promise<void>;
+    openPlannerView(): Promise<void>;
+    expandGanttFolder(): Promise<void>;
+    backToRelease(): Promise<void>;
+    expectTitleToBeInBreadcrumbLink(title: string): Promise<void>;
+    expectHasPhase(title: string): Promise<void>;
+    addNewPhase(phaseName?: string): Promise<void>;
+    renamePhase(oldPhaseName: string, newPhaseName: string): Promise<void>;
+    exportRelease(exportAs?: string): Promise<void>;
+    expectTaskToBePresent(taskName: string): Promise<void>;
+    expectTaskNotToBePresent(taskName: string): Promise<void>;
+    toggleTaskFilter(filterOption: string): Promise<void>;
+    clickFilterOptions(): Promise<void>;
+    expectTaskToHaveFailed(title: string, failCount: number): Promise<void>;
+    expectTaskToHaveBeenDelayed(title: string): Promise<void>;
+    expectOnePhaseDisplayed(): Promise<void>;
+    restartPhases(): Promise<RestartPhaseModel>;
+    expectAddPhaseNotVisible(): Promise<void>;
+    expectAddTaskNotVisible(): Promise<void>;
+    expectTaskCount(count: number): Promise<void>;
+    expectCurrentTaskCount(count: number): Promise<void>;
+}
+declare class Phase extends WithPage {
+    commentBox: Locator;
+    contextMenuButton: Locator;
+    dateUtil: DateUtil;
+    constructor(page: Page, phaseName: string);
+    setTitle(title: string): Promise<void>;
+    isMenuItemEnabled(menuName: string, taskTitle: string, group?: boolean): Promise<void>;
+    isMenuItemDisabled(menuName: string, taskTitle: string, group?: boolean): Promise<void>;
+    expectMenuItemIsNotVisible(menuName: string, taskTitle: string): Promise<void>;
+    expectMenuItemIsVisible(menuName: string, taskTitle: string): Promise<void>;
+    expectSubmenuItemIsVisible(parentMenuItem: string, menuName: string, taskTitle: string): Promise<void>;
+    clickSubmenuItemForTask(parentMenuItem: string, menuName: string, taskTitle: string): Promise<void>;
+    expectSnackbarSuccessMessage(message: string): Promise<void>;
+    closeContextMenu(): Promise<void>;
+    expectTaskBorderWithColor(taskName: string, color: string): Promise<void>;
+    pasteTaskFromTaskGenerator(): Promise<void>;
+    addTaskInPhase(taskTitle: string, taskGroup: string, taskType: string): Promise<void>;
+    getNumberOfTasks(): Promise<number>;
+    expectToHaveNoneditableTitle(phaseTitle: string): Promise<void>;
+    expectToHaveTitle(phaseTitle: string): Promise<void>;
+    openContextMenuForTask(taskTitle: string, group?: boolean): Promise<void>;
+    skipFromContextMenu(comment: string, taskTitle: string): Promise<void>;
+    completeFromContextMenu(taskTitle: string, comment: string): Promise<void>;
+    changeTypeFromContextMenu(taskTitle: string, taskGroup: string, taskType: string): Promise<this>;
+    unlockFromContextMenu(taskTitle: string, group?: boolean): Promise<void>;
+    lockFromContextMenu(taskTitle: string, group?: boolean): Promise<void>;
+    expectChangeTypeContextMenuDisabled(taskTitle: string, taskGroup: string, taskType: string): Promise<this>;
+    expectGateCheckMark(): Promise<this>;
+    expectLockCheckMark(taskTitle: string, isVisible?: boolean): Promise<this>;
+    expectFailureHandlerCheckMar(taskTitle: string, isVisible?: boolean): Promise<this>;
+    expectNoOptionInChangeType(taskTitle: string, taskGroup: string): Promise<this>;
+    assignToMeFromContextMenu(taskTitle: string): Promise<void>;
+    duplicateFromContextMenu(taskTitle: string): Promise<void>;
+    expectTemplateLabelNotToBePresent(): Promise<void>;
+    openPhaseDetails(): Promise<void>;
+    close(): Promise<void>;
+    expectStartDateToBeDisplayed(): Promise<void>;
+    expectDueDateToBeDisplayed(): Promise<void>;
+    expectEndDateToBeDisplayed(): Promise<void>;
+    setTitleFromPhaseDetails(title: string): Promise<void>;
+    setDueDateFromPhaseDetails(date?: string, monthYear?: string): Promise<void>;
+    setScheduledStartDateFromPhaseDetails(date?: string, monthYear?: string): Promise<void>;
+    expectDurationToBe(duration: string): Promise<void>;
+    setDurationFromPhaseDetails(days?: string, hours?: string, mins?: string): Promise<void>;
+    expectDueTimeToBe(format: string, date: Date | string): Promise<void>;
+    deleteTaskInPhase(taskName: string): Promise<void>;
+    deletePhase(phaseName: string): Promise<void>;
+    expectCompletedPhase(): Promise<void>;
+    clickViewAllCompletedPhase(): Promise<void>;
+    expectTaskToBePresent(taskName: string, visible?: boolean): Promise<void>;
+    expectContainingTask(taskName: string, exist?: boolean): Promise<void>;
+    addTaskInGroup(currentGroupType: string, taskTitle: string, taskGroup: string, taskType: string): Promise<void>;
+    openContextMenuForTaskInGroup(groupName: string, taskTitle: string): Promise<void>;
+    duplicateFromContextualMenuInGroup(groupName: string, taskTitle: string): Promise<this>;
+    deleteFromContextualMenuInGroup(groupName: string, taskTitle: string): Promise<this>;
+    duplicatePhase(): Promise<void>;
+    expectActionsDisabled(): Promise<void>;
+    expectTaskFailureManualPermission(): Promise<void>;
+    expectCurrentTaskCount(count: number): Promise<void>;
+    expectCompletedTaskCount(count: number): Promise<void>;
+    expectFailedTaskCount(count: number): Promise<void>;
+    expectFailingTaskCount(count: number): Promise<void>;
+    expectSkippedTaskCount(count: number): Promise<void>;
+}
+declare class RestartPhaseModel extends WithPage {
+    continueBtn: Locator;
+    constructor(page: Page);
+    fromPhase(phase: string): Promise<void>;
+    fromTask(task: string): Promise<void>;
+    expectNoTaskSelectorVisible(): Promise<void>;
+    continue(): Promise<void>;
+    resumeNow(): Promise<void>;
+    resumeLater(): Promise<void>;
+}
+declare class ApplicationsPage extends WithPage {
+    goToApplicationsPage(): Promise<this>;
+    addNewApplication(applicationName: string): Promise<this>;
+    verifyApplicationisCreated(applicationName: string): Promise<this>;
+    createApplicationAndLinkEnvironment(environmentName: string, applicationName: string): Promise<this>;
+}
+declare class DataRandomGenerator {
+    static codePointA: number;
+    static codePointZ: number;
+    static getString(): string;
+    static getNumber(min: number, max: number): number;
+    static getAlphabetsString(length: number): string;
+}
+declare class FolderDeliveryPage extends WithPage {
+    util: Util;
+    addName: Locator;
+    addDescription: Locator;
+    searchForDelivery: Locator;
+    constructor(page: Page);
+    filterDeliveryByName(deliveryName: string): Promise<void>;
+    editDelivery(deliveryName: string, newDeliveryName: string): Promise<void>;
+    deleteDelivery(deliveryName: string): Promise<void>;
+    expectDeliveryDisplayed(deliveryName: string): Promise<void>;
+    openDeliveries(): Promise<void>;
+    resetFilter(): Promise<void>;
+    setOrderBy(orderBy: string): Promise<void>;
+    openDeliveryFlow(title: string): Promise<void>;
+    completeStage(stageTitle: string, trackedItems?: string[]): Promise<this>;
+    reopenStage(stageTitle: string): Promise<this>;
+    verifyStageContextMenuIsPresent(titles: string[]): Promise<void>;
+    openFolderPath(folderPath: string): Promise<void>;
+    openDeliveryFromFolder(title: string): Promise<void>;
+}
+declare class FolderGroupsPage extends WithPage {
+    util: Util;
+    newReleaseGroupButton: Locator;
+    dateUtil: DateUtil;
+    dateMonth: Date;
+    constructor(page: Page);
+    createGroup(groupName: string, startDate?: string, endDate?: string): Promise<void>;
+    addReleaseToGroup(releaseName: string): Promise<void>;
+    editReleaseGroupName(newGroupName: string): Promise<void>;
+    enterGroupName(groupName: string): Promise<void>;
+    enterStartDate(date: string, monthYear: string): Promise<void>;
+    enterEndDate(date: string, monthYear: string): Promise<void>;
+    clickCreate(): Promise<void>;
+    expectSuccessMessageOnReleaseGroupCreation(): Promise<void>;
+    expectSuccessMessageOnAddingReleaseToGroup(): Promise<void>;
+    expectSuccessMessageOnUpdatingGroup(): Promise<void>;
+    closeNotificationBanner(): Promise<void>;
+    searchReleaseGroupByTitle(title: string): Promise<void>;
+    deleteReleaseGroup(title: string): Promise<void>;
+    clickReleaseGroupEdit(title: string): Promise<void>;
+    clickSave(): Promise<void>;
+    clickCancel(): Promise<void>;
+    clickOnStatusField(): Promise<void>;
+    statusFilter(statusNames: string[]): Promise<void>;
+    clickOnStatusClearAll(): Promise<void>;
+    clickOnStatusSelectAll(): Promise<void>;
+}
+declare class FolderPatternPage extends WithPage {
+    util: Util;
+    addName: Locator;
+    addDescription: Locator;
+    constructor(page: Page);
+    clickNewDeliveryPattern(): Promise<void>;
+    setPatternName(patternName: string): Promise<void>;
+    setPatternDescription(patternDescription: string): Promise<void>;
+    enableAutoComplete(): Promise<void>;
+    disableAutoComplete(): Promise<void>;
+    setDuration(month: number, days: number, hours: number): Promise<void>;
+    createNewPattern(patternName: string, patternDescription: string): Promise<void>;
+    clickEditPatternIcon(patternName: string): Promise<void>;
+    clickCopyPatternIcon(patternName: string): Promise<void>;
+    filterPatternByName(patternName: string): Promise<void>;
+    openProperties(): Promise<Properties>;
+    back(): Promise<void>;
+    copyPattern(existingPatternName: string, NewPatternName: string): Promise<void>;
+    clickDeletePattern(patternName: string): Promise<void>;
+    createNewDelivery(deliveryName: string, deliveryDes?: string, setAutoComplete?: true): Promise<void>;
+}
+declare class Properties extends WithPage {
+    addName: Locator;
+    addDescription: Locator;
+    constructor(page: Page);
+    editName(name: string): Promise<void>;
+    editDescription(description: string): Promise<void>;
+    editDuration(month: number, days: number, hours: number): Promise<void>;
+    save(): Promise<void>;
+}
+declare class FolderNotificationPage extends WithPage {
+    inheritCheckbox: Locator;
+    util: Util;
+    constructor(page: Page);
+    checkInheritNotifications(): Promise<void>;
+    uncheckInheritNotifications(): Promise<void>;
+    expectRecipientsNotToBeEditable(eventName: string): Promise<void>;
+    deleteTeam(eventName: string, teamName: string): Promise<void>;
+    expectEditMessageIsVisible(eventName: string): Promise<void>;
+    addTeam(eventName: string, teamName: string): Promise<void>;
+    clickEditMessage(eventName: string): Promise<void>;
+    editPriority(eventName: string, priority: string): Promise<void>;
+}
+declare class FolderPage extends WithPage {
+    deliveryPage: FolderDeliveryPage;
+    expandButton: Locator;
+    notificationPage: FolderNotificationPage;
+    patternPage: FolderPatternPage;
+    folderGroupsPage: FolderGroupsPage;
+    util: Util;
+    variables: VariablePage;
+    constructor(page: Page);
+    getFolderSearchInputLocator(): Locator;
+    openFoldersPage(): Promise<this>;
+    backToAllFolders(): Promise<this>;
+    createFolder(folderName: string): Promise<this>;
+    openFolder(folderName: string): Promise<this>;
+    openGroups(): Promise<FolderGroupsPage>;
+    createGroup(groupName: string): Promise<this>;
+    selectPlannedStatus(): Promise<this>;
+    expectReleaseGroupisDisplayed(title: string): Promise<this>;
+    createSubFolder(parentFolder: string, subFolderName: string): Promise<void>;
+    renameFolder(existingFolderName: string, newFolderName: string): Promise<void>;
+    deleteFolder(folderName: string): Promise<void>;
+    searchFolderByName(folderName: string): Promise<void>;
+    openPatterns(): Promise<FolderPatternPage>;
+    clickFolderOptions(folderName: string, option: string): Promise<void>;
+    clickExpandButton(): Promise<void>;
+    openDeliveriesOverview(): Promise<FolderDeliveryPage>;
+    openNotifications(): Promise<void>;
+    openTemplates(): Promise<void>;
+    openRelease(): Promise<void>;
+    expectReleaseStarted(releaseName: string): Promise<void>;
+    openVariables(): Promise<VariablePage>;
+    openCustomDashboard(): Promise<void>;
+    openReleaseByName(releaseName: string): Promise<void>;
+}
+declare class GlobalVariable extends WithPage {
+    addListValue: Locator;
+    listAddButton: Locator;
+    addVariableValue: Locator;
+    addVariablelabel: Locator;
+    constructor(page: Page);
+    addVariableText(valuename: string): Promise<void>;
+    addVariableListbox(possiblevalue: string): Promise<void>;
+    addVariablePassword(possiblevalue: string): Promise<void>;
+    addVariableCheckbox(): Promise<void>;
+    addVariableNumber(possiblevalue: string): Promise<void>;
+    addVariableList(possiblevalue1: string, possiblevalue2: string): Promise<void>;
+    addVariableMultiList(possiblevalue1: string, possiblevalue2: string): Promise<void>;
+    addVariableDate(): Promise<void>;
+    setDate(date?: string, monthYear?: string): Promise<void>;
+    addVariableKeyValueMap(keys1: string, values1: string): Promise<void>;
+    addVariableSet(possiblevalue1: string): Promise<void>;
+    addNewVariable(variableName: string, labelname: string, description: string): Promise<void>;
+    verifyGlobalVariableCreation(variableName: string): Promise<void>;
+    submitTheVariable(): Promise<void>;
+    deleteGlobalVariable(variableName: string): Promise<void>;
+    editVariable(variableName: string, editedvariabletext: string): Promise<void>;
+}
+declare class HomePage extends WithPage {
+    configureButton: Locator;
+    viewModeButton: Locator;
+    constructor(page: Page);
+    verifyHomePage(): Promise<void>;
+    verifyConfigureButton(): Promise<void>;
+    addReleaseTiles(): Promise<void>;
+    addWorkflowTiles(): Promise<void>;
+    addApplicationTiles(): Promise<void>;
+    addTemplateTiles(): Promise<void>;
+    addAnnouncementTiles(): Promise<void>;
+    addAnaslyticsTiles(): Promise<void>;
+    /**
+     * Remove the tiles from the home page
+     * @param tileName name of the tile to be removed
+     * tileName TileName should be "Releases", "Workflows", "Applications", "Templates", "Announcements", "Analytics"
+     */
+    removeTiles(tileName: string): Promise<void>;
+    verifyWhatsNewButton(): Promise<void>;
+}
+declare class HeaderPage extends WithPage {
+    announcementIcon: Locator;
+    settingsIcon: Locator;
+    aboutMenu: Locator;
+    util: Util;
+    constructor(page: Page);
+    verifyVersionNumber(versionNumber: string): Promise<void>;
+    verifyProductAnnouncements(): Promise<void>;
+    clickHelpIcon(): Promise<void>;
+    verifyOnlineDocumentation(): Promise<void>;
+    verifySupportRequest(): Promise<void>;
+    verifySuggestAFeature(): Promise<void>;
+    verifyDigitalAiWebsite(): Promise<void>;
+    clickAvatarIcon(username: string): Promise<void>;
+    verifyUser(userFullName: string): Promise<void>;
+    clickAccessTokens(): Promise<void>;
+    getVersionNumber(): Promise<string>;
+}
+declare class ManagePluginsPage extends WithPage {
+    util: Util;
+    constructor(page: Page);
+    openPluginGallery(): Promise<void>;
+    openInstalledPlugins(): Promise<void>;
+    searchForPlugins(searchText: string): Promise<void>;
+    refreshPluginList(): Promise<void>;
+    clickInstallNow(pluginName: string): Promise<void>;
+    expectRestartInfo(): Promise<void>;
+    expectNewPluginInstallationInfo(pluginName: string): Promise<void>;
+    clickUpload(): Promise<void>;
+}
+declare class PersonalAccessTokenPage extends WithPage {
+    openPersonalAccessTokenPage(): Promise<this>;
+    addNewToken(tokenName: string): Promise<this>;
+}
+declare class PersonalSettingsPage extends WithPage {
+    util: Util;
+    constructor(page: Page);
+    openProfile(): Promise<void>;
+    openAccessToken(): Promise<void>;
+    expectEmailDefined(email: string): Promise<PersonalSettingsPage>;
+    expectNoEmailDefined(): Promise<PersonalSettingsPage>;
+    expectFullNameDefined(fullName: string): Promise<PersonalSettingsPage>;
+    expectNoFullNameDefined(): Promise<PersonalSettingsPage>;
+    expectPasswordNotToBe(password: string): Promise<PersonalSettingsPage>;
+    expectDateFormatToBe(dateFormat: string): Promise<PersonalSettingsPage>;
+    expectTimeFormatToBe(timeFormat: string): Promise<PersonalSettingsPage>;
+    expectFirstDayOfWeekToBe(firstDayOfWeek: string): Promise<PersonalSettingsPage>;
+    save(): Promise<PersonalSettingsPage>;
+    setEmail(email: string): Promise<PersonalSettingsPage>;
+    setFullName(fullName: string): Promise<PersonalSettingsPage>;
+    setPassword(previousPassword: string, password: string): Promise<PersonalSettingsPage>;
+    refresh(): Promise<PersonalSettingsPage>;
+    editUserProfile(email: string): Promise<void>;
+    generateNewAccessToken(tokenName: string, expiryOptions: string): Promise<void>;
+    deleteAccessToken(tokenName: string): Promise<void>;
+}
+declare class UserModal extends WithPage {
+    userName: Locator;
+    name: Locator;
+    email: Locator;
+    password: Locator;
+    cnfPassword: Locator;
+    saveButton: Locator;
+    cancelButton: Locator;
+    deleteButton: Locator;
+    constructor(page: Page);
+    setUserName(username: string): Promise<void>;
+    setFullName(fullName: string): Promise<void>;
+    setEmail(email: string): Promise<void>;
+    setPassword(password: string): Promise<void>;
+    setCurrentPassword(password: string): Promise<void>;
+    setConfirmPassword(cnfPassword: string): Promise<void>;
+    save(): Promise<void>;
+    cancel(): Promise<void>;
+    delete(): Promise<void>;
+    expectSaveButtonEnabled(): Promise<void>;
+    expectSaveButtonDisabled(): Promise<void>;
+    expectErrorMessage(errorMsg: string): Promise<void>;
+    expectNewPasswordBoxDisabled(): Promise<this>;
+    expectConfirmPasswordHelperText(text: string): Promise<void>;
+}
+declare class UsersPage extends WithPage {
+    page: Page;
+    modal: UserModal;
+    util: Util;
+    constructor(page: Page);
+    openUsersPage(): Promise<void>;
+    toggleLoginPermission(username: string): Promise<void>;
+    addUser(): Promise<UserModal>;
+    createUser(username: string, password: string): Promise<void>;
+    filterUser(username: string): Promise<void>;
+    expectToHaveFilteredUser(username: string): Promise<void>;
+    expectToHaveLoginPermission(username: string): Promise<void>;
+    deleteUser(username: string): Promise<void>;
+    openRoles(): Promise<void>;
+    openPermissions(): Promise<void>;
+    openTaskAccess(): Promise<void>;
+    expectUsers(users: Array<{
+        email?: string;
+        external: boolean;
+        externalId?: string;
+        fullName?: string;
+        name: string;
+    }>): Promise<void>;
+    expectNoUser(username: string): Promise<void>;
+    updateUser(username: string): Promise<UserModal>;
+    sortByColumn(columnName: string, columnIndex: number): Promise<this>;
+    expectColumnVisible(column: string, visible?: boolean): Promise<this>;
+}
+declare class WorkflowCatalogPage extends WithPage {
+    constructor(page: Page);
+    installReleaseRunner(headingName: string): Promise<void>;
+    abortInstallation(): Promise<void>;
+}
+declare class SettingsMenu extends WithPage {
+    settingsIcon: Locator;
+    configureSystemMessageMenu: Locator;
+    usersAndPermissionMenu: Locator;
+    managePluginMenu: Locator;
+    systemSettingsMenu: Locator;
+    taskManagerMenu: Locator;
+    runnerMenu: Locator;
+    viewSystemInfoMenu: Locator;
+    getDataSupportMenu: Locator;
+    renewLicenseMenu: Locator;
+    aboutMenu: Locator;
+    closeIcon: Locator;
+    installRunnerButton: Locator;
+    workflowCatalogPage: WorkflowCatalogPage;
+    constructor(page: Page);
+    openUsersAndPermissions(): Promise<void>;
+    openManagePlugin(): Promise<void>;
+    openSystemSettings(): Promise<void>;
+    openRunner(): Promise<void>;
+    openConfigureSystemMessage(): Promise<void>;
+    closeConfigureSystemMessage(): Promise<void>;
+    configureSystemMessage(message: string): Promise<void>;
+    disableSystemMessage(): Promise<void>;
+    openTaskManager(): Promise<void>;
+    openViewSystemInformation(): Promise<void>;
+    openGetDataForSupport(): Promise<void>;
+    downloadSupportData(): Promise<void>;
+    openRenewLicense(): Promise<void>;
+    getVersionNumber(): Promise<string>;
+    openAbout(): Promise<Modal>;
+}
+declare class Modal {
+    modalBody: Locator;
+    closeIcon: Locator;
+    constructor(page: Page);
+    closeModal(): Promise<void>;
+    validateLicenseInfo(): Promise<void>;
+}
+declare class TaskDetails extends WithPage {
+    constructor(page: Page);
+}
+declare class ReleaseCalendarPage extends ReleasesHeaderPage {
+    openReleaseCalendarPage(): Promise<this>;
+    exportCalendar(): Promise<void>;
+    cancelCalendarExport(): Promise<number>;
+    verifyDayView(): Promise<void>;
+    verifyYearView(): Promise<void>;
+    verifyMonthView(): Promise<void>;
+    verifyPageContent(title: string): Promise<void>;
+    viewRelease(release_title: string, release_id: string): Promise<void>;
+    viewDependency(source_release: string, dest_release: string): Promise<void>;
+    downloadIcsCalendar(release_title: string): Promise<number>;
+    openBlackoutPeriod(date: string): Promise<BlackoutPeriod>;
+}
+declare class BlackoutPeriod extends WithPage {
+    dateField: string;
+    constructor(date: string, page: Page);
+    edit(): Promise<this>;
+    delete(): Promise<this>;
+    findBlackout(): Promise<void>;
+    setEndDate(date: Date): Promise<this>;
+    save(): Promise<this>;
+}
+declare class ReleaseGroupPage extends WithPage {
+    setStatus(status: string): Promise<void>;
+    openReleaseGroup(title: string): Promise<void>;
+    expectReleaseGroupStatus(status: string): Promise<void>;
+    expectReleaseGroupDisplayed(title: string): Promise<void>;
+    expectReleaseGroupNotDisplayed(title: string): Promise<void>;
+    searchReleaseGroupByTitle(title: string): Promise<void>;
+    deleteReleaseGroup(title: string): Promise<void>;
+    clickReleaseGroupEdit(title: string): Promise<void>;
+    enterReleaseGroupDetails(new_title: string): Promise<void>;
+    clickSaveButton(): Promise<void>;
+    clickCancelButton(): Promise<void>;
+}
+declare class ReleaseGroupTimelinePage extends WithPage {
+    expectReleaseDisplayed(title: string): Promise<void>;
+    expectReleaseNotDisplayed(title: string): Promise<void>;
+    expectPhaseDisplayed(title: string): Promise<void>;
+    openContextMenu(title: string): Promise<void>;
+    removeFromReleaseGroup(): Promise<void>;
+    expectNumberOfReleases(num_of_release: number): Promise<void>;
+    openAddReleaseList(): Promise<void>;
+    filterReleases(title: string): Promise<void>;
+    expectNumberOfReleasesOnModal(num_of_release: number): Promise<void>;
+    selectAllReleaseCheckbox(): Promise<void>;
+    addReleasesToGroup(): Promise<void>;
+}
+declare class ReleaseVariablesPage extends WithPage {
+    addListValue: Locator;
+    addVariableValue: Locator;
+    listAddButton: Locator;
+    dateUtil: DateUtil;
+    constructor(page: Page);
+    openVariable(variableKey: string): Promise<ReleaseVariableModal>;
+    addNewVariable(variableName: string, labelname: string, description?: string): Promise<void>;
+    selectVariableTextType(valuename: string): Promise<void>;
+    selectVariableListboxType(possiblevalue: Array<string> | string, defaultValue: string, required?: boolean): Promise<void>;
+    selectVariablePasswordType(possiblevalue: string): Promise<void>;
+    selectVariableCheckboxType(): Promise<void>;
+    selectVariableNumberType(possiblevalue: string): Promise<void>;
+    selectVariableMultiListType(possiblevalue1: string, possiblevalue2: string): Promise<void>;
+    addVariableDate(): Promise<void>;
+    setDate(date?: string, monthYear?: string): Promise<void>;
+    addVariableKeyValueMap(keys1: string, values1: string): Promise<void>;
+    addVariableSet(possiblevalue1: string): Promise<void>;
+    submitTheVariable(): Promise<void>;
+    expectVariableWithNameValueAndType(name: string, value: string, type: string): Promise<void>;
+    clickEditVariable(variableName: string): Promise<ReleaseVariableModal>;
+    clickDeleteVariable(variableName: string): Promise<_DeleteVariableModel1>;
+    expectVariablesCountToBe(count: number): Promise<void>;
+    expectVariableNotPresent(variableName: string): Promise<void>;
+    clearSearch(): Promise<void>;
+    switchPossibleValuesToVariable(variableName: string): Promise<void>;
+    selectVariableListboxTypeWithVariable(variableName: string, defaultValue: string, required?: boolean): Promise<void>;
+}
+declare class ReleaseVariableModal extends WithPage {
+    dateUtil: DateUtil;
+    constructor(page: Page);
+    expectValueToBe(value: string): Promise<void>;
+    expectValueToContain(value: string): Promise<void>;
+    close(): Promise<void>;
+    expectPossibleValues(possiblevalue: Array<string> | string): Promise<void>;
+    expectPossibleVariableValues(possiblevariablevalue: string): Promise<void>;
+    addPossibleValue(value: Array<string> | string): Promise<void>;
+    selectVariableValue(defaultValue: string): Promise<void>;
+    save(): Promise<void>;
+    createPossibleValuesVariable(variableName: string): Promise<void>;
+    expectVariableValueToBe(value: string): Promise<void>;
+    expectNoVariablesInList(): Promise<void>;
+    expectNameInput(value: string): Promise<void>;
+    expectLabel(value: string): Promise<void>;
+    expectRequired(value: boolean): Promise<void>;
+    setDescription(description: string): Promise<void>;
+    setLabel(labelValue: string): Promise<void>;
+    setDate(date: string, monthYear: string): Promise<void>;
+    setValue(value: string): Promise<void>;
+}
+declare class _DeleteVariableModel1 extends WithPage {
+    model: ReleaseVariableModal;
+    dateUtil: DateUtil;
+    constructor(page: Page);
+    deleteVariable(): Promise<void>;
+    replaceItWithVariable(variable: string): Promise<void>;
+    replaceItwithValue(value: string): Promise<void>;
+    clickReplaceAndDelete(): Promise<void>;
+    addValue(value: string): Promise<void>;
+    remove(value: string): Promise<void>;
+    expectReplacementPromptDisplayed(): Promise<void>;
+    close(): Promise<void>;
+    removeItemOnSet(value: string): Promise<void>;
+    addValueForSet(key: string, value: string): Promise<void>;
+    replaceWithIntegerValue(value: string): Promise<void>;
+    replaceForBooleanValue(): Promise<void>;
+    deleteBySettingDate(date: string, monthYear: string): Promise<void>;
+}
+declare class TaskListPage extends WithPage {
+    commentBox: Locator;
+    gridView: GridView;
+    taskDrawer: TaskDrawer;
+    constructor(page: Page);
+    openTask(taskName: string): Promise<void>;
+    complete(taskName: string, comment: string): Promise<void>;
+    skip(taskName: string, comment: string): Promise<void>;
+    fail(taskName: string, comment: string): Promise<void>;
+    waitForTaskFailed(taskName: string): Promise<void>;
+    waitForTaskInProgress(taskName: string): Promise<void>;
+    openTaskInReleaseView(taskName: string): Promise<void>;
+    openCalendarViaTaskDueDate(taskName: string): Promise<void>;
+    openTaskDrawer(taskName: string): Promise<void>;
+    filterTaskByTitle(taskname: string): Promise<void>;
+    filterTasksByTag(tag: string, taskTitleForValidation: string): Promise<void>;
+    filterTasksByReleaseTitle(releaseTitle: string): Promise<void>;
+    openSingleTask(taskId: string, showDetails?: boolean): Promise<void>;
+    expectReleaseLinksDisplayed(releaseTitle: string, displayed?: boolean): Promise<void>;
+    openTaskList(): Promise<void>;
+    clickOnAssigneeButton(title: string): Promise<void>;
+    clickOnAssignedToMe(): Promise<void>;
+    clickOnAssignedToMyTeams(): Promise<void>;
+    clickOnAssignedToAllAvailable(): Promise<void>;
+    expectTaskToNotBeDisplayed(taskTitle: string): Promise<void>;
+    expectTaskToBeDisplayed(taskTitle: string): Promise<void>;
+    expectTasksToBeDisplayed(tasks: {
+        [key: string]: boolean;
+    }): Promise<void>;
+    expectTasksDisplayedInOrder(expectedTasks: {
+        releaseTitle: string;
+        taskPosition: number;
+        taskTitle: string;
+    }[]): Promise<void>;
+    setOrderBy(orderBy: string): Promise<void>;
+    expectTaskCountForRelease(releaseTitle: string, expectedCount: number): Promise<void>;
+    setSearchFilter(filterText: string): Promise<void>;
+    clearSearchFilter(): Promise<void>;
+    setTagsFilter(filterText: string): Promise<void>;
+    clickOnStatusField(): Promise<void>;
+    clickOnStatus(statusNames: string[]): Promise<void>;
+    clickOnStatusClearAll(): Promise<void>;
+    clickOnStatusSelectAll(): Promise<void>;
+    assignTaskToMe(title: string): Promise<void>;
+    expectTaskAssignedToMe(title: string): Promise<void>;
+    expectTaskAssignedTo(title: string, user: string): Promise<void>;
+    expectTaskTitle(taskTitle: string): Promise<void>;
+    clickOnTasksLabel(): Promise<void>;
+    expectGroupView(expected?: boolean): Promise<void>;
+    changeGroupView(): Promise<void>;
+    enableGroupByReleaseView(): Promise<void>;
+    disableGroupByReleaseView(): Promise<void>;
+    switchToGridView(): Promise<GridView>;
+}
+declare class GridView extends WithPage {
+    taskDrawer: TaskDrawer;
+    constructor(page: Page);
+    expectTaskCountInGridView(count: number): Promise<void>;
+    expectTaskDetailsInGridView(taskId: string, taskStatus: string, taskTitle: string, assignedTo?: string, release?: string, phase?: string, startDate?: string): Promise<this>;
+    openTaskDrawerFromGridView(taskId: string, taskTitle: string): Promise<TaskDrawer>;
+    openContextualMenu(taskId: string): Promise<void>;
+    expectContextMenuHas(taskId: string, enabled: Array<string>, disabled: Array<string>): Promise<this>;
+    waitForTaskNotDisplayed(taskId: string): Promise<this>;
+    triggerContextMenuAction(action: string): Promise<this>;
+}
+declare class TemplatePropertiesPage extends WithPage {
+    dateUtil: DateUtil;
+    scheduledStartDate: Locator;
+    constructor(page: Page);
+    getAttachmentsListCount(): Promise<number>;
+    uploadFile(filePath: string): Promise<void>;
+    expectWithAttachment(filename: string): Promise<void>;
+    expectWithNoAttachment(filename: string): Promise<void>;
+    downloadFile(filename: string): Promise<void>;
+    deleteAttachment(fileName: string): Promise<void>;
+    save(): Promise<void>;
+    reset(): Promise<void>;
+    removeDueDate(): Promise<void>;
+    setScheduledStartDate(date: string, monthYear: string): Promise<void>;
+    setDuration(days?: string, hours?: string, mins?: string): Promise<void>;
+    expectScheduledStartDateToBe(date: string): Promise<void>;
+    expectDueDateToBe(date: string): Promise<void>;
+    expectedDueDateTime(time: string): Promise<void>;
+    expectDurationToBe(duration: string): Promise<void>;
+    setUsername(username: string): Promise<void>;
+    setPassword(password: string): Promise<void>;
+    expectScriptUsernameToBe(username: string): Promise<void>;
+    expectScriptUserPasswordToBe(password: string): Promise<void>;
+}
+declare class TemplateCreatePage extends WithPage {
+    constructor(page: Page);
+    setName(name: string): Promise<void>;
+    setDescription(description: string): Promise<void>;
+    create(): Promise<void>;
+}
+declare class TemplateTriggerPage extends WithPage {
+    create: CreateNewTriggerPage;
+    constructor(page: Page);
+    expectAllowConcurrentReleasesFromTrigger(expectedValue: boolean): Promise<void>;
+    setAllowConcurrentReleasesFromTriggerAndSubmit(checked: boolean): Promise<void>;
+    expectTriggersVisible(amount: number): Promise<void>;
+    expectNoNewTriggerButtonShown(): Promise<void>;
+    clickAddTrigger(): Promise<CreateNewTriggerPage>;
+    openContextualMenuForTrigger(triggerName: string): Promise<this>;
+    selectContextualMenuItem(triggerName: string, menuItem: string): Promise<this>;
+}
+declare class CreateNewTriggerPage extends WithPage {
+    constructor(page: Page);
+    setTriggerTitle(title: string): Promise<void>;
+    setTriggerType(triggerType: string): Promise<void>;
+    setFieldInput(field: string, value: string): Promise<void>;
+    setValuesForVariable(variableId: string, value: string): Promise<this>;
+    save(): Promise<void>;
+}
+declare class TemplateVariablesPage extends WithPage {
+    constructor(page: Page);
+    clickEditVariable(variableName: string): Promise<TemplateVariableModal>;
+}
+declare class TemplateVariableModal extends WithPage {
+    setLabel(label: string): Promise<void>;
+    setDefalutValue(value: string): Promise<void>;
+    save(): Promise<void>;
+}
+declare class TemplatePage extends WithPage {
+    taskDrawer: TaskDrawer;
+    phaseTitle: Locator;
+    properties: TemplatePropertiesPage;
+    createTemplatePage: TemplateCreatePage;
+    triggers: TemplateTriggerPage;
+    util: Util;
+    variables: TemplateVariablesPage;
+    plannerView: ReleaseGanttPage;
+    constructor(page: Page);
+    openTaskDrawer(taskName: string): Promise<TaskDrawer>;
+    openTaskDrawerFromTableView(taskName: string): Promise<TaskDrawer>;
+    openTaskDrawerFromGrantt(taskName: string): Promise<TaskDrawer>;
+    openProperties(): Promise<void>;
+    openVariables(): Promise<void>;
+    openRelationships(): Promise<void>;
+    openTeamsPermissions(): Promise<void>;
+    openDashboard(): Promise<void>;
+    openHistory(): Promise<void>;
+    openTriggers(): Promise<void>;
+    backToTemplate(): Promise<void>;
+    expectTemplateLabelToBePresent(): Promise<void>;
+    expectSubPage(menuItem: string, toBePresent: boolean): Promise<void>;
+    openFlowView(): Promise<void>;
+    openTableView(): Promise<void>;
+    openPlannerView(): Promise<ReleaseGanttPage>;
+    openCodeView(): Promise<void>;
+    expandGanttFolder(): Promise<void>;
+    addNewPhase(phaseName?: string): Promise<void>;
+    renamePhase(oldPhaseName: string, newPhaseName: string): Promise<void>;
+    clickNewRelease(): Promise<void>;
+    getPhase(phaseName: string): _Phase1;
+}
+declare class _Phase1 extends WithPage {
+    constructor(page: Page, phaseName: string);
+    setTitle(title: string): Promise<void>;
+    expectTaskBorderWithColor(taskName: string, color: string): Promise<void>;
+    /**
+     *
+     * @param taskTitle Title of the task
+     * @param taskType : Type of the task
+     * @param taskTypeSelector : Selector of the task
+     */
+    addTaskInPhase(taskTitle: string, taskGroup: string, taskType: string): Promise<void>;
+    getNumberOfTasks(): Promise<number>;
+    expectToHaveNoneditableTitle(phaseTitle: string): Promise<void>;
+    expectToHaveTitle(phaseTitle: string): Promise<void>;
+    deleteTaskInPhase(taskName: string): Promise<void>;
+    deletePhase(phaseName: string): Promise<void>;
+}
+declare class TemplateListPage extends WithPage {
+    templatePage: TemplatePage;
+    constructor(page: Page);
+    openTemplatesList(filter: string): Promise<void>;
+    searchBy(criteria: string): Promise<void>;
+    copy(originTitle: string, targetTitle: string): Promise<void>;
+    move(templateName: string, targetFolder: string): Promise<void>;
+    metaInformation(templateName: string, validationMsg?: string): Promise<void>;
+    expectTemplateVisible(title: string, expected?: boolean): Promise<void>;
+    delete(title: string): Promise<void>;
+    clickCreateNewTemplate(): Promise<void>;
+    openTemplateByName(templateName: string): Promise<void>;
+    clickNewReleaseIcon(templateName: string): Promise<void>;
+    createTemplate(templateName: string, description: string): Promise<void>;
+    filterByTitle(templateName: string): Promise<void>;
+}
+declare class RolesModal extends WithPage {
+    roleName: Locator;
+    newRoleName: Locator;
+    addPrincipal: Locator;
+    saveButton: Locator;
+    editIcon: Locator;
+    deleteButton: Locator;
+    searchRoles: Locator;
+    constructor(page: Page);
+    setRoleName(roleName: string): Promise<void>;
+    editRoleName(newRoleName: string): Promise<void>;
+    setPrincipal(addPrincipal: string): Promise<void>;
+    searchRoleByRoleName(searchRoles: string): Promise<void>;
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}
+declare class RolesPage extends WithPage {
+    page: Page;
+    newRoleButton: Locator;
+    modal: RolesModal;
+    constructor(page: Page);
+    createRole(roleName: string, addPrincipal: string): Promise<void>;
+    editRole(roleName: string, newRoleName: string): Promise<void>;
+    searchRoleByRoleName(searchRoles: string): Promise<void>;
+    searchRoleByAssignedUsername(searchRolesByUsername: string): Promise<void>;
+    deleteRole(roleName: string): Promise<void>;
+    expectToViewRolesPage(): Promise<void>;
+    expectToViewCreatedRole(roleName: string): Promise<void>;
+    expectToViewEditedRole(roleName: string): Promise<void>;
+    expectRoleToBeDeleted(roleName: string): Promise<void>;
+    expectToViewSearchedRole(roleName: string): Promise<void>;
+    expectToViewSearchedRoleByUsername(userName: string): Promise<void>;
+}
+declare class RisksPage extends WithPage {
+    constructor(page: Page);
+    getValue(classIdentifier: string): Promise<string>;
+    setPointerValue(elem: Locator, value: number, isIncrease: boolean): Promise<void>;
+    setValue(identifier: string, newValue: number): Promise<void>;
+    checkValue(identifier: string, value: number): Promise<void>;
+    shouldHaveEditButton(present?: boolean): Promise<void>;
+    shouldHaveSaveButton(present?: boolean): Promise<void>;
+    startEditGlobalRiskThreshold(): Promise<void>;
+    setInitialValues(): Promise<void>;
+    changeValuesAndSave(minValue: number, maxValue: number): Promise<void>;
+    checkValuesChanged(minValue: number, maxValue: number): Promise<void>;
+    expectRiskProfileToBePresent(title: string, present?: boolean): Promise<void>;
+    expectDefaultRiskProfileToBeFirst(): Promise<void>;
+    openRiskProfile(title: string): Promise<RisksProfilePage>;
+    shouldHaveCopyButtonEnabledForRiskProfile(title: string, enabled?: boolean): Promise<void>;
+    shouldHaveDeleteButtonEnabledForRiskProfile(title: string, enabled?: boolean): Promise<void>;
+    clickNewRiskProfile(): Promise<RisksProfilePage>;
+    deleteRiskProfile(title: string): Promise<void>;
+    expectSuccessMessageOnRisksPage(): Promise<void>;
+    copyRiskProfile(title: string): Promise<void>;
+    expectSuccessMessageOnUpdateRiskProfile(): Promise<void>;
+    filter(filterText: string): Promise<void>;
+    shouldHaveNVisibleRiskProfiles(numberOfVisibleRiskProfiles: number): Promise<void>;
+    shouldHaveNewRiskProfileButton(present?: boolean): Promise<void>;
+    closeNotificationBanner(): Promise<void>;
+}
+declare class RisksProfilePage extends WithPage {
+    shouldBeEditable(editable: boolean): Promise<void>;
+    setName(name: string): Promise<void>;
+    save(): Promise<void>;
+}
+declare class advancedSettingsPage extends WithPage {
+    constructor(page: Page);
+}
+declare class experimentalSettingsPage extends WithPage {
+    settings: SystemSettingsPage;
+    constructor(page: Page);
+    getFeatureControl(feature: string, control: string): Promise<Locator>;
+    expectFeatureToBeEnabled(feature: string, state: boolean, control: string): Promise<this>;
+    expectSaveToBeEnabled(state: boolean): Promise<this>;
+    expectResetToBeEnabled(state: boolean): Promise<this>;
+    disableFeature(feature: string, control: string): Promise<this>;
+    expectToBeSaved(): Promise<this>;
+}
+declare class TaskSettingsPage extends WithPage {
+    settings: SystemSettingsPage;
+    constructor(page: Page);
+    setStatusPollingInterval(value: string): Promise<this>;
+    setListPollingInterval(value: string): Promise<this>;
+    expectStatusPollingInterval(value: string): Promise<this>;
+    expectListPollingInterval(value: string): Promise<this>;
+    restoreDefaultPollingSettings(): Promise<this>;
+}
+declare class ReportsSettingsPage extends WithPage {
+    settings: SystemSettingsPage;
+    constructor(page: Page);
+    setWarningThreshold(value: string): Promise<this>;
+    setErrorThreshold(value: string): Promise<this>;
+    setCriticalPhaseThreshold(value: string): Promise<this>;
+    expectWarningThreshold(value: string): Promise<this>;
+    expectErrorThreshold(value: string): Promise<this>;
+    expectCriticalPhaseThreshold(value: string): Promise<this>;
+    restoreDefaultReportSettings(): Promise<void>;
+}
+declare class ReleaseAndTriggersPage extends WithPage {
+    settings: SystemSettingsPage;
+    constructor(page: Page);
+    setArchivingSettingsDeleteIntervalUnit(value: string): Promise<this>;
+    expectArchivePurgeEnableState(value: boolean): Promise<this>;
+    setArchivePurgeEnableState(value: boolean): Promise<this>;
+    expectConfirmEnableArchivePurgeModal(): Promise<this>;
+    confirmEnableArchivePurgeModal(): Promise<this>;
+    cancelEnableArchivePurgeModal(): Promise<this>;
+    setMaxArchiveRetentionPeriodIntervalUnit(value: string): Promise<this>;
+    setMaxArchiveRetentionPeriodInterval(value: string): Promise<this>;
+    expectInputFieldToBeDisabled(fieldName: string): Promise<this>;
+}
+declare class NotificationPage extends WithPage {
+    constructor(page: Page);
+    getTasksTableElement(): Promise<Locator>;
+    getTasksTableRows(): Promise<Locator>;
+    getEventElement(eventName: string): Promise<Locator>;
+    getEventRowElement(eventName: string): Promise<Locator>;
+    findAddTagInputElementOnRow(eventRowElement: Locator): Promise<Locator>;
+    getTasksEventIdSearchInput(): Promise<Locator>;
+    getSuggestedRoleElement(roleName: string): Promise<Locator>;
+    getRoleElementFromEvent(eventName: string, roleName: string): Promise<Locator>;
+    getCloseTagElements(): Promise<Locator>;
+    getEditMessageElements(): Promise<Locator>;
+    findEditMessageLinkElementOnRow(eventRowElement: Locator): Promise<Locator>;
+    typeRoleTagNameInEventInput(eventName: string, roleName: string): Promise<this>;
+    clearRoleTagNameInEventInput(eventName: string): Promise<this>;
+    filterTaskTableByEventId(filterText: string): Promise<this>;
+    expectSuggestedRoleToBeVisible(roleName: string, shouldBeVisible?: boolean): Promise<this>;
+    expectRoleTagToBePresentOnEvent(eventName: string, roleName: string, shouldBePresent?: boolean): Promise<this>;
+    expectTaskEventTableToHaveNumberOfRows(numberOfRows: number): Promise<this>;
+    expectTablesToBeInReadOnlyMode(shouldBeReadOnly?: boolean): Promise<this>;
+    removeRoleTagFromEvent(eventName: string, roleName: string): Promise<this>;
+    toConstantFormat(input: string): Promise<string>;
+}
+declare class NotificationModalPage extends NotificationPage {
+    constructor(page: Page);
+    findBodySaveElement(): Promise<Locator>;
+    findBodyCloseElement(): Promise<Locator>;
+    expectBodyTextareaControlsToExist(shouldExist?: boolean): Promise<this>;
+    getPriorityDropdownElement(): Promise<Locator>;
+    getPriorityDropdownItemElement(priority: string): Promise<Locator>;
+    getModalCancelButtonElement(): Promise<Locator>;
+    getModalSaveButtonElement(): Promise<Locator>;
+    setPriority(priority: string): Promise<this>;
+    expectModalSaveButtonToBeEnabled(shouldBeEnabled?: boolean): Promise<this>;
+    expectModalCancelButtonToBeEnabled(shouldBeEnabled?: boolean): Promise<this>;
+    hasPriority(priority: string): Promise<this>;
+    setSubject(subject: string): Promise<this>;
+    hasSubject(subject: string): Promise<this>;
+    writeIntoBodyTextarea(bodyText: string): Promise<this>;
+    saveTextInsideOfBodyTextarea(): Promise<this>;
+    setBody(body: string): Promise<this>;
+    hasBody(body: string): Promise<this>;
+    save(): Promise<this>;
+    cancel(): Promise<this>;
+    confirmLeave(): Promise<this>;
+    expectNotificationSettingsModalToBeVisible(shouldBeVisible?: boolean): Promise<this>;
+    expectModalControlButtonsToBeEnabled(shouldBeEnabled?: boolean): Promise<this>;
+    changeEmailDataWithAssertion(priority: string, subject: string, body: string): Promise<this>;
+    changeEmailDataSaveChangesAndAssert(priority: string, subject: string, body: string): Promise<this>;
+    changeEmailDataCancelChangesAndAssert(priority: string, subject: string, body: string): Promise<this>;
+    expectLeaveConfirmationModalToBeVisible(shouldBeVisible?: boolean): Promise<this>;
+    openModalAndExpectData(priority: string, subject: string, body: string): Promise<this>;
+}
+declare class NotificationSettingsPage extends NotificationPage {
+    constructor(page: Page);
+    getResetButtonElement(): Promise<Locator>;
+    getSaveButtonElement(): Promise<Locator>;
+    getSuggestionTag(): Promise<Locator>;
+    getSuggestedRoleElement(roleName: string): Promise<Locator>;
+    selectSuggestedRole(roleName: string): Promise<this>;
+    getEventElement(eventName: string): Promise<Locator>;
+    getEventRowElement(eventName: string): Promise<Locator>;
+    getRoleElementFromEvent(eventName: string, roleName: string): Promise<Locator>;
+    expectResetButtonToBeEnabled(shouldBeEnabled?: boolean): Promise<this>;
+    expectSaveButtonToBeEnabled(shouldBeEnabled?: boolean): Promise<this>;
+    expectTableWithRecipients(tableTitle: string, recipientEnabled: boolean): Promise<this>;
+    typeRoleText(eventId: string, roleText: string): Promise<this>;
+    addRoleToEvent(eventId: string, roleName: string): Promise<this>;
+    removeRoleFromEvent(eventId: string, roleName: string): Promise<this>;
+    expectSuggestionTagToHaveText(expectedText: string): Promise<this>;
+    expectCancelAndSaveButtonsToBeEnabled(shouldBeEnabled?: boolean): Promise<this>;
+    addRoleToEventWithAssertions(eventName: string, roleName: string): Promise<this>;
+    removeRoleAndAssert(eventName: string, roleName: string): Promise<this>;
+    openEditMessageFromEvent(eventName: string): Promise<NotificationModalPage>;
+}
+declare class SystemSettingsPage extends WithPage {
+    util: Util;
+    risksPage: RisksPage;
+    constructor(page: Page);
+    openGeneralSettings(): Promise<GeneralSettings>;
+    openReleasesAndTriggers(): Promise<ReleaseAndTriggersPage>;
+    openTasks(): Promise<TaskSettingsPage>;
+    openReports(): Promise<ReportsSettingsPage>;
+    openAdvanced(): Promise<advancedSettingsPage>;
+    openExperimental(): Promise<experimentalSettingsPage>;
+    openNotifications(): Promise<NotificationSettingsPage>;
+    openRiskProfiles(): Promise<RisksPage>;
+    openWorkflowCategories(): Promise<void>;
+    openSMTPServer(): Promise<void>;
+    _saveDoNotAssert(): Promise<void>;
+    expectCards(cardTitles: string[] | string): Promise<this>;
+    save(): Promise<this>;
+    reset(): Promise<this>;
+}
+declare class GeneralSettings extends SystemSettingsPage {
+    constructor(page: Page);
+    setInstanceName(value: string): Promise<this>;
+    setLoginMessage(message: string): Promise<this>;
+    clearLoginMessage(): Promise<this>;
+    setHeaderColor(colorName: string): Promise<this>;
+    clickNotificationsMenu(): Promise<void>;
+    expectInstanceName(value: string): Promise<this>;
+    restoreDefaultThemeSettings(): Promise<void>;
+    _clearHeaderInstanceName(): Promise<void>;
+    expectHeaderColor(value: string): Promise<this>;
+    expectConfirmationPopUp(): Promise<this>;
+}
+declare class ConnectionsPage extends WithPage {
+    constructor(page: Page);
+    addNewInstance(typeName: string): Promise<ConfigurationInstancePage>;
+    expectInstanceDisplayed(instanceName: string): Promise<this>;
+    expectInstanceNotDisplayed(instanceName: string): Promise<this>;
+    openInstance(instanceName: string): Promise<ConfigurationInstancePage>;
+    deleteInstance(instanceName: string): Promise<this>;
+    expectSuccessMsgToBeDisplayed(text: string): Promise<this>;
+    clearFilter(): Promise<this>;
+    searchInstances(instanceName: string): Promise<this>;
+    expectErrorDisplayed(): Promise<void>;
+}
+declare class ConfigurationInstancePage extends WithPage {
+    constructor(page: Page);
+    setTextField(fieldName: string, fieldValue: string): Promise<this>;
+    setNumberField(fieldName: string, fieldValue: number): Promise<this>;
+    selectFromDropdown(fieldName: string, element: string): Promise<this>;
+    save(): Promise<this>;
+    test(): Promise<this>;
+    cancel(): Promise<this>;
+    expectResultBanner(message: string): Promise<this>;
+    expectDropdownToBe(fieldName: string, fieldValue: string): Promise<this>;
+    clearDropdown(fieldName: string): Promise<this>;
+    clickField(fieldName: string): Promise<this>;
+    expectTextFieldNotToExist(fieldName: string): Promise<this>;
+    clickHeader(): Promise<void>;
+    expectTextFieldToBe(fieldName: string, fieldValue: string): Promise<this>;
+    setStringList(value: Array<string> | string): Promise<this>;
+    expectStringListCountToBe(count: number): Promise<this>;
+    removeString(value: string): Promise<this>;
+    setStringSet(value: Array<string> | string): Promise<this>;
+    expectStringSetCountToBe(count: number): Promise<this>;
+    setStringMap(pairs: {
+        key: string;
+        value: string;
+    }): Promise<void>;
+    expectStringMapCountToBe(count: number): Promise<this>;
+    expectTestButtonToBeDisabled(): Promise<this>;
+    togglePasswordFieldVariable(fieldName: string): Promise<this>;
+    setPasswordFieldVariable(fieldName: string, fieldValue: string): Promise<this>;
+    expectFieldsToNotBeVisible(fieldNames: Array<string> | string): Promise<this>;
+    expectFieldsToBeVisible(fieldNames: Array<string> | string): Promise<this>;
+}
+declare class TaskAccessPage extends WithPage {
+    constructor(page: Page);
+    setTaskAvailableToAllUsers(taskName: string, enable?: boolean): Promise<void>;
+}
+declare class Navigation {
+    connections: ConnectionsPage;
+    dataRandomGenerator: DataRandomGenerator;
+    dateUtil: DateUtil;
+    folderPage: FolderPage;
+    globalvariable: GlobalVariable;
+    homePage: HomePage;
+    header: HeaderPage;
+    managePluginsPage: ManagePluginsPage;
+    releasePage: ReleasePage;
+    settingsMenu: SettingsMenu;
+    systemSettingsPage: SystemSettingsPage;
+    usersPage: UsersPage;
+    applicationPage: ApplicationsPage;
+    taskDetailsPage: TaskDetails;
+    taskListPage: TaskListPage;
+    templatePage: TemplatePage;
+    templateListPage: TemplateListPage;
+    personalSettingsPage: PersonalSettingsPage;
+    releaseCalendarPage: ReleaseCalendarPage;
+    releaseGroupPage: ReleaseGroupPage;
+    releaseGroupTimelinePage: ReleaseGroupTimelinePage;
+    releaseGanttPage: ReleaseGanttPage;
+    releaseListPage: ReleasesListPage;
+    rolesPage: RolesPage;
+    util: Util;
+    workflowCatalogPage: WorkflowCatalogPage;
+    taskAccessPage: TaskAccessPage;
+    constructor(page: Page);
+    openTemplate(id: string): Promise<ReleasePage>;
+    openFolder(id: string): Promise<FolderPage>;
+    openProfilePage(): Promise<PersonalSettingsPage>;
+    openVariablesOnReleasePage(releaseId: string): Promise<ReleaseVariablesPage>;
+    openRelease(id: string): Promise<ReleasePage>;
+    openPlannerView(releaseId: string): Promise<ReleaseGanttPage>;
+    openApplicationsPage(): Promise<ApplicationsPage>;
+    openPersonalAccessTokenPage(): Promise<PersonalAccessTokenPage>;
+    gotoHomePage(): Promise<void>;
+    gotoFolderPage(): Promise<void>;
+    gotoTaskPage(): Promise<void>;
+    gotoReleasePage(): Promise<void>;
+    gotoWorkflowCatalogPage(): Promise<void>;
+    gotoWorkflowsPage(): Promise<void>;
+    gotoGroupsPage(): Promise<void>;
+    gotoReleaseCalenderPage(): Promise<void>;
+    gotoDeliveriesPage(): Promise<void>;
+    gotoTriggersPage(): Promise<void>;
+    gotoDigitalAnalyticsPage(): Promise<void>;
+    gotoReportsPage(): Promise<void>;
+    gotoTemplatesPage(): Promise<void>;
+    gotoEnvironmentsPage(): Promise<void>;
+    gotoEnvironmentsCalenderPage(): Promise<void>;
+    gotoGobalVariablesPage(): Promise<void>;
+    gotoConnectionsPage(): Promise<void>;
+    collapseSideView(): Promise<void>;
+    expandSideView(): Promise<void>;
+    openRisksProfile(): Promise<void>;
+    openConnection(): Promise<void>;
+    clickOnPrimaryLogo(): Promise<void>;
+    gotoTaskAccessPage(): Promise<TaskAccessPage>;
+}
+declare class LoginPage extends WithPage {
+    /**
+     * Login with username and password
+     * @param userName
+     * @param password
+     */
+    login(userName: string, password: string): Promise<void>;
+    loginWithoutReload(userName: string, password: string): Promise<void>;
+    /**
+     * Logout as authenticated user
+     */
+    logout(): Promise<void>;
+    /**
+     * Expect login to be restricted for a user
+     */
+    expectLoginDisallowed(): Promise<void>;
+    /**
+     * Expect the respective user is logged In
+     * @param username
+     */
+    expectToBeLogged(username: string): Promise<void>;
+    closePendoModalWindow(): Promise<void>;
+    expectUserNotVisible(): Promise<void>;
+    expectUserVisible(): Promise<void>;
+    expectLoginPage(): Promise<void>;
+}
+interface BaseConfigurationItem {
+    id: string;
+    type: string;
+}
+interface PlanItem extends BaseConfigurationItem {
+    title?: string;
+}
+interface Release extends PlanItem {
+    allowConcurrentReleasesFromTrigger: boolean;
+    attachments: Array<Attachment>;
+    autoStart: boolean;
+    description: string;
+    dueDate?: Date;
+    endDate?: Date;
+    extensions: Array<ReleaseExtension>;
+    flagStatus?: string;
+    owner?: string;
+    passwordVariableValues?: VariableValues;
+    phases: Array<_Phase2>;
+    plannedDuration: number;
+    queryableEndDate?: Date;
+    queryableStartDate?: Date;
+    realFlagStatus?: string;
+    scheduledStartDate?: Date;
+    scriptUserPassword?: string;
+    scriptUsername?: string;
+    startDate?: Date;
+    status: ReleaseStatus;
+    summary?: Dashboard;
+    tags?: Array<string>;
+    teams: Array<Team>;
+    variableValues?: VariableValues;
+    variables: Array<Variable>;
+}
+type VariableValues = Record<string, any>;
+interface Variable extends BaseConfigurationItem {
+    description?: string;
+    folderId?: any;
+    key: string;
+    label?: string;
+    multiline?: boolean;
+    referencedType?: string;
+    requiresValue?: boolean;
+    showOnReleaseStart?: boolean;
+    value?: unknown;
+    valueProvider?: VariableValueProvider;
+}
+interface VariableValueProvider {
+    id: string;
+    type?: string;
+    values?: unknown;
+    variable: string;
+}
+interface Container extends PlanItem {
+    tasks: Array<Task>;
+}
+interface _Phase2 extends Container {
+    color: string;
+    description: string;
+    dueDate?: Date;
+    endDate?: Date;
+    plannedDuration: number;
+    scheduledStartDate?: Date;
+    startDate: Date;
+    status: PhaseStatus;
+}
+interface _Dependency1 extends PlanItem {
+    archivedAsResolved: boolean;
+    archivedTargetId: string;
+    archivedTargetTitle: string;
+    target: {
+        id: string;
+        type: string;
+    };
+    targetId: string;
+}
+interface Folder extends PlanItem {
+    children?: Array<Folder>;
+    teams?: Array<FixtureTeam>;
+    variables?: Array<Variable>;
+}
+interface Task extends PlanItem {
+    addresses: Array<string>;
+    attachments: Array<Attachment>;
+    body?: string;
+    comments: Array<Comment>;
+    conditions: Array<Condition>;
+    delayDuringBlackout: boolean;
+    dependencies: Array<_Dependency1>;
+    description?: string;
+    dueDate?: Date;
+    endDate?: Date;
+    failuresCount: number;
+    flagStatus?: string;
+    folderId?: string;
+    links: Array<Link>;
+    locked: boolean;
+    newReleaseTitle?: string;
+    originalScheduledStartDate: string;
+    owner?: string;
+    plannedDuration: number;
+    precondition: string;
+    pythonScript?: PythonScript;
+    scheduledStartDate?: Date;
+    script: string;
+    startDate?: Date;
+    status: TaskStatus;
+    subject?: string;
+    tags?: Array<string>;
+    tasks: Array<Task>;
+    team: string;
+    templateId?: string;
+    templateVariables?: Array<Variable>;
+    variableMapping: VariableValues;
+    variables?: Array<Variable>;
+    waitForScheduledStartDate?: boolean;
+}
+interface Condition extends PlanItem {
+    checked?: boolean;
+}
+type Link = PlanItem;
+type Attachment = PlanItem;
+interface Comment extends PlanItem {
+    author?: string;
+    date?: Date;
+    text?: string;
+}
+interface Dashboard extends BaseConfigurationItem {
+    owner?: string;
+    parentId?: string;
+    tiles: Array<Tile>;
+    title?: string;
+}
+type ReleaseExtension = BaseConfigurationItem;
+interface Tile extends BaseConfigurationItem {
+    col: number;
+    password?: string;
+    row: number;
+    title: string;
+    username?: string;
+    variableMapping: Record<string, any>;
+    width: number;
+}
+interface PythonScript extends BaseConfigurationItem {
+    customScriptTask: string;
+    password?: string;
+    result: string;
+    stringList: Array<string>;
+    stringMap: Map<string, string>;
+    stringSet: Set<string>;
+}
+type ReleaseStatus = 'TEMPLATE' | 'PLANNED' | 'IN_PROGRESS' | 'PAUSED' | 'FAILING' | 'FAILED' | 'COMPLETED' | 'ABORTED';
+type PhaseStatus = 'PLANNED' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILING' | 'FAILED' | 'SKIPPED' | 'ABORTED';
+type TaskStatus = 'IN_PROGRESS' | 'PLANNED' | 'SKIPPED_IN_ADVANCE' | 'COMPLETED_IN_ADVANCE' | 'COMPLETED' | 'SKIPPED' | 'ABORTED' | 'PENDING' | 'FACET_CHECK_IN_PROGRESS' | 'FAILED' | 'FAILING' | 'FAILURE_HANDLER_IN_PROGRESS' | 'ABORT_SCRIPT_IN_PROGRESS' | 'PRECONDITION_IN_PROGRESS' | 'QUEUED' | 'ABORT_SCRIPT_QUEUED' | 'WAITING_FOR_INPUT' | 'FAILURE_HANDLER_QUEUED';
+interface Team extends BaseConfigurationItem {
+    members: Array<string> | Array<principals>;
+    permissions: Array<string>;
+    roles?: Array<FixtureRoles>;
+    teamName: string;
+}
+type FixtureTeam = Omit<Team, 'id'>;
+interface principals {
+    name: string;
+    type: string;
+}
+type FeatureType = 'xlrelease.TaskDrawer';
+interface FixtureFeature {
+    enabled: boolean;
+    id: string;
+    type: FeatureType;
+}
+type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+type FixtureRelease = DeepPartial<Release> & Pick<Release, 'id'>;
+interface FixtureConfiguration extends PlanItem {
+    accessTokenUrl?: string;
+    address?: string;
+    apiToken?: string;
+    authenticationMethod?: string;
+    clientId?: string;
+    folderId?: string;
+    password?: string;
+    port?: number;
+    proxyHost?: string;
+    proxyPassword?: string;
+    proxyPort?: string;
+    proxyUsername?: string;
+    scriptLocation?: string;
+    url?: string;
+    username?: string;
+}
+interface FixtureCi extends PlanItem {
+    apiToken?: string;
+    defaultProfile?: boolean;
+    documentationPage?: string;
+    enabled?: boolean;
+    externalIdLabel?: string;
+    url?: string;
+    username?: string;
+}
+interface FixtureTrigger extends PlanItem {
+    count?: number;
+    description?: string;
+    enabled?: boolean;
+    folderId?: string;
+    gitRepository?: string;
+    jql?: string;
+    password?: string;
+    periodicity?: number | string;
+    pollType?: string;
+    releaseTitle: string;
+    server?: string;
+    template: string;
+    username?: string;
+}
+interface FixtureActivityLog extends PlanItem {
+    activityType: string;
+    eventTime: Date;
+    message: string;
+    targetId: string;
+    username: string;
+}
+interface FixtureRoles {
+    principals?: Array<string>;
+    role?: Array<FixtureRole>;
+}
+interface FixtureRole {
+    id: number;
+    name: string;
+}
+interface FixturePermissions {
+    permissions?: Array<string>;
+    role?: Array<FixtureRole>;
+}
+interface FixtureGlobalRole {
+    id: string | null;
+    name: string;
+    permissions: Array<string>;
+    principals: Array<FixturePrincipal>;
+}
+interface FixturePrincipal {
+    fullname: string;
+    username: string;
+}
+interface ReleaseGroup extends PlanItem {
+    endDate: Date;
+    folderId: string;
+    releaseIds?: Array<string>;
+    startDate: Date;
+}
+interface RiskProfile extends PlanItem {
+    riskProfileAssessors?: Array<RiskProfile>;
+}
+interface Delivery extends PlanItem {
+    deliveryPattern?: string;
+    endDate?: Date;
+    folderId: string;
+    patternId?: string;
+    patternTitle?: string;
+    plannedDuration: number;
+    shouldResetPattern?: boolean;
+    stages: Array<Stage>;
+    startDate?: Date;
+    status: string;
+    trackedItems?: Array<TrackedItem>;
+    transitions?: Array<Transition>;
+}
+interface Stage {
+    description?: string;
+    endDate?: Date;
+    id?: null | string;
+    plannedDuration?: number;
+    startDate?: Date;
+    status?: string;
+    title?: string;
+    transition?: Transition;
+    type: string;
+}
+interface Transition {
+    id?: null | string;
+    title?: string;
+    type: string;
+}
+interface TrackedItem extends PlanItem {
+    createdDate: Date;
+    description?: string;
+    endDate?: Date;
+    folderId?: string;
+    owner?: string;
+    startDate?: Date;
+    status?: string;
+}
+interface Reservation {
+    applications?: Array<ApplicationFixture> | string;
+    endDate: string;
+    environment: Array<EnvironmentFixture> | string;
+    id?: null | string;
+    note?: string;
+    startDate: string;
+    type?: string;
+}
+interface ApplicationFixture {
+    environments?: Array<EnvironmentFixture>;
+    folderId?: string | null;
+    id?: string | null;
+    title?: string;
+    type?: string;
+}
+interface EnvironmentFixture {
+    description?: string;
+    folderId?: string | null;
+    id: null | string;
+    labels?: Array<Label>;
+    stage?: Stage;
+    title?: string;
+    type?: string;
+}
+interface Label extends PlanItem {
+    color: string;
+    title: string;
+}
+interface Facet extends BaseConfigurationItem {
+    analysisDate?: string;
+    applicationId?: Array<ApplicationFixture> | string;
+    build?: string;
+    build_url?: string;
+    complianceData?: string;
+    createdBy?: string;
+    creationDate?: string;
+    duration?: string;
+    endDate?: string;
+    environmentId?: Array<EnvironmentFixture> | string;
+    outcome?: string;
+    priority?: string;
+    project?: string;
+    project_url?: string;
+    record?: string;
+    record_url?: string;
+    serverUrl?: string;
+    serverUser?: string;
+    startDate?: string;
+    status?: string;
+    targetId?: string;
+    ticket?: string;
+    ticketType?: string;
+    ticket_url?: string;
+    title?: string;
+    updatedDate?: string;
+    version?: string;
+}
+type ReleaseFixtures = {
+    fixtures: Fixtures;
+    loginPage: LoginPage;
+    navigation: Navigation;
+};
+export const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & ReleaseFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+declare class Fixtures {
+    constructor(request: APIRequestContext, page: Page);
+    release(release: FixtureRelease): Promise<APIResponse>;
+    archivedRelease(release: FixtureRelease): Promise<APIResponse>;
+    configuration(ci: FixtureConfiguration): Promise<APIResponse>;
+    ci(ci: FixtureCi): Promise<APIResponse>;
+    deleteCI(id: string): Promise<APIResponse>;
+    getParentId(id: string): string;
+    addSystemTeams(teams: Array<FixtureTeam>): Array<FixtureTeam>;
+    folder(folder: Folder): Promise<APIResponse>;
+    createFolder(folderJson: Folder): Promise<APIResponse>;
+    folderVariable(variable: any[]): Promise<APIResponse>;
+    trigger(trigger: FixtureTrigger): Promise<APIResponse>;
+    roles(rolePrincipals: FixtureRoles): Promise<APIResponse>;
+    permissions(rolePermissions: FixturePermissions): Promise<APIResponse>;
+    globalRoles(rolePrincipals: FixtureGlobalRole): Promise<APIResponse>;
+    dashboard(dashboard: Dashboard): Promise<APIResponse>;
+    deleteGlobalRole(roleName: string): Promise<APIResponse>;
+    updateUserProfile(username: string, profile: any): Promise<APIResponse>;
+    deleteRole(roleName: string): Promise<APIResponse>;
+    deleteArchivedRelease(id: string): Promise<APIResponse>;
+    deleteRelease(id: string): Promise<APIResponse>;
+    deleteWelcomeRelease(username: string): Promise<void>;
+    deleteReleaseWithTitle(title: string): Promise<void>;
+    deleteUser(username: string): Promise<APIResponse>;
+    deleteUserProfile(userProfile: string): Promise<APIResponse>;
+    deleteReleaseGroup(releaseGroup: string): Promise<APIResponse>;
+    deleteTrigger(id: string): Promise<APIResponse>;
+    deleteConfiguration(id: string): Promise<APIResponse>;
+    deleteFolder(folderId: string): Promise<APIResponse>;
+    deleteGlobalVariables(): Promise<APIResponse>;
+    deleteGlobalVariable(id: string): Promise<APIResponse>;
+    activityLogs(id: string, logs: Array<FixtureActivityLog>): Promise<APIResponse>;
+    globalVariable(variable: Variable): Promise<APIResponse>;
+    addDefaultSmtpServer(): Promise<APIResponse>;
+    riskProfile(riskProfile: RiskProfile): Promise<APIResponse>;
+    deleteRiskProfile(riskProfileId: string): Promise<APIResponse>;
+    createDeliveryPattern(delivery: Delivery, shouldResetPattern?: boolean): Promise<APIResponse>;
+    createDelivery(delivery: Delivery): Promise<APIResponse>;
+    facet(facet: Facet): Promise<APIResponse>;
+    application(application: ApplicationFixture): Promise<APIResponse>;
+    environment(environment: EnvironmentFixture): Promise<APIResponse>;
+    reservation(reservation: Reservation): Promise<APIResponse>;
+    deleteDelivery(delivery: Delivery): Promise<APIResponse>;
+    deleteApplication(applicationId: string): Promise<APIResponse>;
+    deleteEnvironment(environmentId: string): Promise<APIResponse>;
+    deleteEnvironmentStage(environmentStageId: string): Promise<APIResponse>;
+    clearCalendar(): Promise<APIResponse>;
+    deleteReservation(id: string): Promise<APIResponse>;
+    cleanAll(): Promise<void>;
+    addJiraTask(): Promise<string>;
+    addBlackout(name: string, from: Date, to: Date): Promise<APIResponse>;
+    addUser(username: string, password: string): Promise<void>;
+    addUserProfile(username: string, profile?: any): Promise<void>;
+    resetAdminProfile(): Promise<APIResponse>;
+    resetUserProfile(username: string, fullName?: string): Promise<APIResponse>;
+    updateProfile(profile: {
+        dateFormat: string;
+        email: string;
+        external: boolean;
+        firstDayOfWeek: number;
+        fullName: string;
+        loginAllowed: boolean;
+        profileId: string;
+        timeFormat: string;
+        username: string;
+    }): Promise<APIResponse>;
+    expectJiraTaskStatus(taskId: string, expectedStatus: string): Promise<void>;
+    expectJiraTaskSummary(taskId: string, expectedSummary: string): Promise<void>;
+    expectContainingAttachments(releaseId: string, tempFile: string): Promise<void>;
+    waitForReleaseStarted(releaseTitle: string): Promise<void>;
+    waitForFirstPoll(triggerId: string): Promise<void>;
+    exec(path: string): Promise<void>;
+    getFakeApiUrl(): string;
+    getEnvVariable(name: string): string | undefined;
+    archiveRelease(releaseId: string): Promise<APIResponse>;
+    preArchiveRelease(releaseId: string): Promise<APIResponse>;
+    setFeatures(features: Array<FixtureFeature>): Promise<APIResponse>;
+    enableTaskDrawer(enabled: boolean): Promise<APIResponse>;
+    createReleaseGroup(releaseGroup: ReleaseGroup): Promise<APIResponse>;
+}
+
+//# sourceMappingURL=types.d.ts.map