@coolon/angular-ui-powerups 12.4.0-alpha.4 → 12.4.0-alpha.40

package/cypress/component-builder.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="cypress" />
+import { Constructable } from '@coolon/pectin';
+import { AupCommand } from './components/aup-command';
+import { AupEmptyState } from './components/aup-empty-state';
+import { AupInput } from './components/aup-input';
+import { AupMoreMenu } from './components/popup/aup-more-menu';
+import { AupNavigation } from './components/aup-navigation';
+import { AupTable } from './components/aup-table';
+import { AupTreeTable } from './components/aup-tree-table';
+import { Button } from './components/button';
+import { MatCheckbox } from './components/mat-checkbox';
+import { Types } from './components/types';
+import { ElementLocator } from './element-locator';
+import { PageElement } from './page-element';
+export declare class ComponentBuilder {
+    readonly parentPageElement: PageElement;
+    constructor(parentPageElement: PageElement);
+    find(selector: string): PageElement;
+    section<T extends object>(selector: string, builder: ComponentBuilder.ContainerCallback<T>): T & PageElement;
+    contains(text: string): PageElement;
+    button(text: string): Button;
+    matCheckbox(text: string): MatCheckbox;
+    aupStringInput(selector?: string): AupInput<string>;
+    aupTextInput(selector?: string): AupInput<string>;
+    aupPasswordInput(selector?: string): AupInput<string>;
+    aupNumberInput(selector?: string): AupInput<number>;
+    aupCommand(selector: string): AupCommand;
+    aupCommand(face: Types.CommandFace): AupCommand;
+    aupTabbedNavigation<T extends object>(): AupNavigation;
+    aupSideNavigation<T extends object>(): AupNavigation;
+    aupMoreMenu<T extends object>(selector?: string): AupMoreMenu;
+    aupTable(selector?: string): AupTable;
+    aupTable<T extends object>(builder: ComponentBuilder.ContainerCallback<T, AupTable>): AupTable & T;
+    aupTable<T extends object>(selector: string, builder: ComponentBuilder.ContainerCallback<T, AupTable>): AupTable & T;
+    aupTreeTable(selector?: string): AupTreeTable;
+    aupTreeTable<T extends object>(builder: ComponentBuilder.ContainerCallback<T, AupTreeTable>): AupTreeTable & T;
+    aupTreeTable<T extends object>(selector: string, builder: ComponentBuilder.ContainerCallback<T, AupTreeTable>): AupTreeTable & T;
+    aupEmptyState(selector?: string): AupEmptyState;
+    aupEmptyState<T extends object>(builder: ComponentBuilder.ContainerCallback<T, AupEmptyState>): AupEmptyState & T;
+    aupEmptyState<T extends object>(selector: string, builder: ComponentBuilder.ContainerCallback<T, AupEmptyState>): AupEmptyState & T;
+    component<E extends PageElement>(klass: Constructable<E>, selector: string): E;
+    component<T extends object, E extends PageElement>(klass: Constructable<E>, builder: ComponentBuilder.ContainerCallback<T, E>): E & T;
+    component<T extends object, E extends PageElement>(klass: Constructable<E>, selector: string, builder: ComponentBuilder.ContainerCallback<T, E>): E & T;
+    component<T extends object, E extends PageElement>(klass: Constructable<E>, selectorOrBuilder?: string | ComponentBuilder.ContainerCallback<T, E>, optionalBuilder?: ComponentBuilder.ContainerCallback<T, E>): E & T;
+}
+export declare namespace ComponentBuilder {
+    type ElementCallback<T, E extends PageElement = PageElement> = (section: E) => T;
+    type ContainerCallback<T, E extends PageElement = PageElement, B extends ComponentBuilder = ComponentBuilder> = (section: B & E) => T;
+    interface HasBuilder {
+        readonly builder: ComponentBuilder;
+    }
+    function Mixin<T, BC extends Constructable<PageElement>>(Base: BC): {
+        new (...args: any[]): {
+            readonly builder: ComponentBuilder;
+            readonly domElementLocator: ElementLocator;
+            readonly parent: PageElement<any>;
+            getDefaultElementLocator(): ElementLocator;
+            getDefaultElementSelector(): string;
+            dom(): Cypress.Chainable<JQuery<HTMLElement>>;
+            find(selector: string): PageElement<PageElement<any>>;
+            click(text?: string): void;
+            readonly should: any;
+            getShoulder(element: Cypress.Chainable<JQuery<HTMLElement>>): any;
+            getShouldElement(): Cypress.Chainable<JQuery<HTMLElement>>;
+            shouldBeVisible(): void;
+            shouldNotBeVisible(): void;
+            shouldExist(): void;
+            shouldNotExist(): void;
+        };
+    } & BC;
+}

package/cypress/components/aup-abstract-activity.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="cypress" />
+import { ComponentBuilder } from '../component-builder';
+import { ElementLocator } from '../element-locator';
+import { PageElement } from '../page-element';
+import { AupCommand } from './aup-command';
+declare const AupAbstractActivity_base: {
+    new (...args: any[]): {
+        readonly builder: ComponentBuilder;
+        readonly domElementLocator: ElementLocator;
+        readonly parent: PageElement<any>;
+        getDefaultElementLocator(): ElementLocator;
+        getDefaultElementSelector(): string;
+        dom(): Cypress.Chainable<JQuery<HTMLElement>>;
+        find(selector: string): PageElement<PageElement<any>>;
+        click(text?: string): void;
+        readonly should: any;
+        getShoulder(element: Cypress.Chainable<JQuery<HTMLElement>>): any;
+        getShouldElement(): Cypress.Chainable<JQuery<HTMLElement>>;
+        shouldBeVisible(): void;
+        shouldNotBeVisible(): void;
+        shouldExist(): void;
+        shouldNotExist(): void;
+    };
+} & typeof PageElement;
+export declare class AupAbstractActivity extends AupAbstractActivity_base {
+    protected _confirmCommand: AupCommand;
+    protected _cancelCommand: AupCommand;
+    readonly title: PageElement;
+    constructor(parent: PageElement, selector: string | ElementLocator);
+}
+export {};

package/cypress/components/aup-abstract-table.d.ts

@@ -0,0 +1,18 @@
+import { ElementLocator } from '../element-locator';
+import { PageElement } from '../page-element';
+import { AupTableColumn } from './table/aup-table-column';
+import { AupTableRow } from './table/aup-table-row';
+import { AupTableSelectionColumn } from './table/aup-table-selection-column';
+export declare abstract class AupAbstractTable<TR extends AupTableRow> extends PageElement {
+    row(rowId: any): TR;
+    rowNumber(rowNumber: number): TR;
+    column(columnId: string): AupTableColumn<TR>;
+    get selectionColumn(): AupTableSelectionColumn<TR>;
+    abstract createRow(locator: ElementLocator): TR;
+}
+export declare namespace AupAbstractTable {
+    function cssSelectorForTableRowById(rowId: string): string;
+    function cssSelectorForNthTableRow(rowNumber: number): string;
+    function cssSelectorForColumnCellRendererById(columnOrId: AupTableColumn<any> | string): string;
+    function cssSelectorForCell(rowId: string, columnOrId: string | AupTableColumn<any>): string;
+}

package/cypress/components/aup-activity.d.ts

@@ -0,0 +1,9 @@
+import { ElementLocator } from '../element-locator';
+import { PageElement } from '../page-element';
+import { AupAbstractActivity } from './aup-abstract-activity';
+import { AupCommand } from './aup-command';
+export declare class AupActivity extends AupAbstractActivity {
+    constructor(parent: PageElement, selector: string | ElementLocator);
+    get confirmCommand(): AupCommand;
+    get cancelCommand(): AupCommand;
+}

package/cypress/components/aup-alert-dialog.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="cypress" />
+import { ElementLocator } from '../element-locator';
+import { PageElement } from '../page-element';
+import { AupAlert } from './aup-alert';
+declare const AupAlertDialog_base: {
+    new (...args: any[]): {
+        getDefaultElementLocator(): ElementLocator;
+        clickBackdrop(): void;
+        readonly domElementLocator: ElementLocator;
+        readonly parent: PageElement<any>;
+        getDefaultElementSelector(): string;
+        dom(): Cypress.Chainable<JQuery<HTMLElement>>;
+        find(selector: string): PageElement<PageElement<any>>;
+        click(text?: string): void;
+        readonly should: any;
+        getShoulder(element: Cypress.Chainable<JQuery<HTMLElement>>): any;
+        getShouldElement(): Cypress.Chainable<JQuery<HTMLElement>>;
+        shouldBeVisible(): void;
+        shouldNotBeVisible(): void;
+        shouldExist(): void;
+        shouldNotExist(): void;
+    };
+} & typeof AupAlert;
+export declare class AupAlertDialog extends AupAlertDialog_base {
+    constructor(parent: PageElement, selector: string | ElementLocator);
+}
+export {};

package/cypress/components/aup-alert.d.ts

@@ -0,0 +1,9 @@
+import { ElementLocator } from '../element-locator';
+import { PageElement } from '../page-element';
+import { AupAbstractActivity } from './aup-abstract-activity';
+import { AupCommand } from './aup-command';
+export declare class AupAlert extends AupAbstractActivity {
+    constructor(parent: PageElement, selector: string | ElementLocator);
+    get closeCommand(): AupCommand;
+    clickClose(): void;
+}

package/cypress/components/aup-command-face.d.ts

@@ -1,13 +1,7 @@
-/// <reference types="cypress" />
+import { ElementLocator } from '../element-locator';
 import { PageElement } from '../page-element';
 import { Types } from './types';
-export declare class FaceAccessor implements PageElement.Accessor {
-    readonly face: Types.CommandFace;
-    constructor(face: Types.CommandFace);
-    findIn(parent: Cypress.Chainable<JQuery>): Cypress.Chainable<JQuery>;
-    shouldNotExist(parent: Cypress.Chainable<JQuery>): Cypress.Chainable<JQuery<HTMLElement>>;
-}
 export declare class AupCommandFace extends PageElement {
     constructor(parentElement: PageElement, face: Types.CommandFace);
-    static createAccessor(face: Types.CommandFace): PageElement.Accessor;
+    static createElementLocator(face: Types.CommandFace): ElementLocator;
 }

package/cypress/components/aup-command.d.ts

@@ -2,9 +2,10 @@
 import { PageElement } from '../page-element';
 import { Types } from './types';
 export declare class AupCommand extends PageElement {
-    constructor(parent: PageElement | (() => Cypress.Chainable<JQuery>), face: Types.CommandFace);
+    constructor(parent: PageElement, faceOrSelector: string | Types.CommandFace);
     click(): void;
     getShouldElement(): Cypress.Chainable<JQuery>;
     shouldBeDisabled(): void;
+    shouldBeEnabled(): void;
     private getButton;
 }

package/cypress/components/aup-confirm-dialog.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="cypress" />
+import { ElementLocator } from '../element-locator';
+import { PageElement } from '../page-element';
+import { AupConfirm } from './aup-confirm';
+declare const AupConfirmDialog_base: {
+    new (...args: any[]): {
+        getDefaultElementLocator(): ElementLocator;
+        clickBackdrop(): void;
+        readonly domElementLocator: ElementLocator;
+        readonly parent: PageElement<any>;
+        getDefaultElementSelector(): string;
+        dom(): Cypress.Chainable<JQuery<HTMLElement>>;
+        find(selector: string): PageElement<PageElement<any>>;
+        click(text?: string): void;
+        readonly should: any;
+        getShoulder(element: Cypress.Chainable<JQuery<HTMLElement>>): any;
+        getShouldElement(): Cypress.Chainable<JQuery<HTMLElement>>;
+        shouldBeVisible(): void;
+        shouldNotBeVisible(): void;
+        shouldExist(): void;
+        shouldNotExist(): void;
+    };
+} & typeof AupConfirm;
+export declare class AupConfirmDialog extends AupConfirmDialog_base {
+    constructor(parent: PageElement, selector: string | ElementLocator);
+}
+export {};

package/cypress/components/aup-confirm.d.ts

@@ -0,0 +1,11 @@
+import { ElementLocator } from '../element-locator';
+import { PageElement } from '../page-element';
+import { AupAbstractActivity } from './aup-abstract-activity';
+import { AupCommand } from './aup-command';
+export declare class AupConfirm extends AupAbstractActivity {
+    constructor(parent: PageElement, selector: string | ElementLocator);
+    get confirmCommand(): AupCommand;
+    clickConfirm(): void;
+    get cancelCommand(): AupCommand;
+    clickCancel(): void;
+}

package/cypress/components/aup-empty-state.d.ts

@@ -0,0 +1,4 @@
+import { PageElement } from '../page-element';
+export declare class AupEmptyState extends PageElement {
+    shouldContainText(text: string): void;
+}

package/cypress/components/aup-input.d.ts

@@ -1,28 +1,34 @@
 /// <reference types="cypress" />
 import { PageElement } from '../page-element';
+import Chainable = Cypress.Chainable;
 export declare abstract class AupInput<T> extends PageElement {
-    label(): Cypress.Chainable<JQuery<HTMLLabelElement>>;
-    hint(): Cypress.Chainable<JQuery<HTMLElement>>;
-    error(): Cypress.Chainable<JQuery<HTMLElement>>;
+    label(): Chainable<JQuery<HTMLLabelElement>>;
+    hint(): Chainable<JQuery<HTMLElement>>;
+    error(): Chainable<JQuery<HTMLElement>>;
     get labelShould(): any;
     get hintShould(): any;
     get errorShould(): any;
     labelShouldBe(text: string): any;
     hintShouldBe(text: string): any;
     errorShouldBe(text: string): any;
+    shouldBeFocused(): void;
+    shouldNotBeFocused(): void;
+    type(characters: string): void;
+    hitEnter(): void;
+    abstract input(): Chainable<JQuery>;
     abstract clear(): any;
     abstract setValue(value: T): any;
 }
 export declare namespace AupInput {
     class HtmlInput<T> extends AupInput<T> {
-        input(): Cypress.Chainable<JQuery<HTMLInputElement>>;
+        input(): Chainable<JQuery<HTMLInputElement>>;
         clear(): void;
         setValue(value: T): void;
         getShouldElement(): Cypress.Chainable<JQuery>;
     }
     class TextAreaInput<T> extends AupInput<T> {
         getShouldElement(): Cypress.Chainable<JQuery>;
-        input(): Cypress.Chainable<JQuery<HTMLTextAreaElement>>;
+        input(): Chainable<JQuery<HTMLTextAreaElement>>;
         clear(): void;
         setValue(value: T): void;
     }

package/cypress/components/aup-modal-activity.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="cypress" />
+import { AupActivity } from './aup-activity';
+declare const AupModalActivity_base: {
+    new (...args: any[]): {
+        getDefaultElementLocator(): import("../element-locator").ElementLocator;
+        clickBackdrop(): void;
+        readonly domElementLocator: import("../element-locator").ElementLocator;
+        readonly parent: import("../page-element").PageElement<any>;
+        getDefaultElementSelector(): string;
+        dom(): Cypress.Chainable<JQuery<HTMLElement>>;
+        find(selector: string): import("../page-element").PageElement<import("../page-element").PageElement<any>>;
+        click(text?: string): void;
+        readonly should: any;
+        getShoulder(element: Cypress.Chainable<JQuery<HTMLElement>>): any;
+        getShouldElement(): Cypress.Chainable<JQuery<HTMLElement>>;
+        shouldBeVisible(): void;
+        shouldNotBeVisible(): void;
+        shouldExist(): void;
+        shouldNotExist(): void;
+    };
+} & typeof AupActivity;
+export declare class AupModalActivity extends AupModalActivity_base {
+}
+export {};

package/cypress/components/aup-modal-mixin.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="cypress" />
+import { Constructable } from '@coolon/pectin';
+import { ElementLocator } from '../element-locator';
+import { PageElement } from '../page-element';
+export declare function AupModalMixin<T, BC extends Constructable<PageElement>>(Base: BC): {
+    new (...args: any[]): {
+        getDefaultElementLocator(): ElementLocator;
+        clickBackdrop(): void;
+        readonly domElementLocator: ElementLocator;
+        readonly parent: PageElement<any>;
+        getDefaultElementSelector(): string;
+        dom(): Cypress.Chainable<JQuery<HTMLElement>>;
+        find(selector: string): PageElement<PageElement<any>>;
+        click(text?: string): void;
+        readonly should: any;
+        getShoulder(element: Cypress.Chainable<JQuery<HTMLElement>>): any;
+        getShouldElement(): Cypress.Chainable<JQuery<HTMLElement>>;
+        shouldBeVisible(): void;
+        shouldNotBeVisible(): void;
+        shouldExist(): void;
+        shouldNotExist(): void;
+    };
+} & BC;

package/cypress/components/aup-table.d.ts

@@ -1,19 +1,6 @@
-/// <reference types="cypress" />
-import { PageElement } from '../page-element';
-export declare class AupTable extends PageElement {
-    constructor(parentElementAccessor: () => Cypress.Chainable<JQuery>, selector: string | PageElement.Accessor);
-    row(rowId: any): AupTable.Row;
-    column(columnId: string): AupTable.Column;
-}
-export declare namespace AupTable {
-    class Row extends PageElement {
-    }
-    class Column {
-        readonly table: AupTable;
-        readonly columnId: string;
-        constructor(table: AupTable, columnId: string);
-        cell(content: string): Cell;
-    }
-    class Cell extends PageElement {
-    }
+import { ElementLocator } from '../element-locator';
+import { AupAbstractTable } from './aup-abstract-table';
+import { AupTableRow } from './table/aup-table-row';
+export declare class AupTable extends AupAbstractTable<AupTableRow> {
+    createRow(locator: ElementLocator): AupTableRow;
 }

package/cypress/components/aup-tree-table.d.ts

@@ -0,0 +1,16 @@
+import { ElementLocator } from '../element-locator';
+import { AupAbstractTable } from './aup-abstract-table';
+import { AupTableColumn } from './table/aup-table-column';
+import { AupTableRow } from './table/aup-table-row';
+export declare class AupTreeTable extends AupAbstractTable<AupTreeTable.Row> {
+    get treeControlColumn(): AupTreeTable.TreeControlColumn;
+    createRow(locator: ElementLocator): AupTreeTable.Row;
+}
+export declare namespace AupTreeTable {
+    class Row extends AupTableRow {
+        shouldBeExpanded(): void;
+        shouldBeCollapsed(): void;
+    }
+    class TreeControlColumn extends AupTableColumn<Row> {
+    }
+}

package/cypress/components/button.d.ts

@@ -1,22 +1,26 @@
 /// <reference types="cypress" />
+import { ElementLocator } from '../element-locator';
 import { PageElement } from '../page-element';
 declare const Button_base: {
     new (...args: any[]): {
-        click(): Cypress.Chainable<JQuery<HTMLElement>>;
         shouldBeDisabled(): void;
-        readonly elementAccessStrategy: PageElement.Accessor;
-        readonly parentElementAccessor: () => Cypress.Chainable<JQuery<HTMLElement>>;
-        element(): Cypress.Chainable<JQuery<HTMLElement>>;
-        getParentElement(): Cypress.Chainable<JQuery<HTMLElement>>;
-        find(selector: string): PageElement;
+        readonly domElementLocator: ElementLocator;
+        readonly parent: PageElement<any>;
+        getDefaultElementLocator(): ElementLocator;
+        getDefaultElementSelector(): string;
+        dom(): Cypress.Chainable<JQuery<HTMLElement>>;
+        find(selector: string): PageElement<PageElement<any>>;
+        click(text?: string): void;
         readonly should: any;
         getShoulder(element: Cypress.Chainable<JQuery<HTMLElement>>): any;
         getShouldElement(): Cypress.Chainable<JQuery<HTMLElement>>;
         shouldBeVisible(): void;
         shouldNotBeVisible(): void;
+        shouldExist(): void;
+        shouldNotExist(): void;
     };
 } & typeof PageElement;
 export declare class Button extends Button_base {
-    constructor(parentElementAccessor: () => Cypress.Chainable<JQuery>, buttonText: string);
+    constructor(parentElementAccessor: PageElement, buttonText: string);
 }
 export {};

package/cypress/components/form-element-mixin.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="cypress" />
+import { Constructable } from '@coolon/typescript-utilities';
+import { PageElement } from '../page-element';
+export declare function FormElementMixin<T, BC extends Constructable<PageElement>>(Base: BC): {
+    new (...args: any[]): {
+        shouldBeDisabled(): void;
+        readonly domElementLocator: import("../element-locator").ElementLocator;
+        readonly parent: PageElement<any>;
+        getDefaultElementLocator(): import("../element-locator").ElementLocator;
+        getDefaultElementSelector(): string;
+        dom(): Cypress.Chainable<JQuery<HTMLElement>>;
+        find(selector: string): PageElement<PageElement<any>>;
+        click(text?: string): void;
+        readonly should: any;
+        getShoulder(element: Cypress.Chainable<JQuery<HTMLElement>>): any;
+        getShouldElement(): Cypress.Chainable<JQuery<HTMLElement>>;
+        shouldBeVisible(): void;
+        shouldNotBeVisible(): void;
+        shouldExist(): void;
+        shouldNotExist(): void;
+    };
+} & BC;

package/cypress/components/mat-checkbox.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="cypress" />
+import { ElementLocator } from '../element-locator';
+import { PageElement } from '../page-element';
+declare const MatCheckbox_base: {
+    new (...args: any[]): {
+        shouldBeDisabled(): void;
+        readonly domElementLocator: ElementLocator;
+        readonly parent: PageElement<any>;
+        getDefaultElementLocator(): ElementLocator;
+        getDefaultElementSelector(): string;
+        dom(): Cypress.Chainable<JQuery<HTMLElement>>;
+        find(selector: string): PageElement<PageElement<any>>;
+        click(text?: string): void;
+        readonly should: any;
+        getShoulder(element: Cypress.Chainable<JQuery<HTMLElement>>): any;
+        getShouldElement(): Cypress.Chainable<JQuery<HTMLElement>>;
+        shouldBeVisible(): void;
+        shouldNotBeVisible(): void;
+        shouldExist(): void;
+        shouldNotExist(): void;
+    };
+} & typeof PageElement;
+export declare class MatCheckbox extends MatCheckbox_base {
+    constructor(parentElementAccessor: PageElement, text: string);
+    shouldBeChecked(): void;
+    shouldNotBeChecked(): void;
+    hiddenCheckBoxElement(): Cypress.Chainable<JQuery<HTMLElement>>;
+    check(): void;
+    uncheck(): void;
+}
+export {};

package/cypress/components/popup/aup-abstract-popup-menu.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="cypress" />
+import { ElementLocator } from '../../element-locator';
+import { PageElement } from '../../page-element';
+import { AupPopupMenuPanel } from './aup-popup-menu-panel';
+export declare class AupAbstractPopupMenu extends PageElement {
+    private popup;
+    constructor(parent: PageElement, locator: ElementLocator);
+    protected findPopupIn(p: PageElement): Cypress.Chainable<JQuery<HTMLElement>>;
+    protected getOverlay(): Cypress.Chainable<JQuery<HTMLElement>>;
+    protected getBackdrop(): Cypress.Chainable<JQuery<HTMLElement>>;
+    openPopup(): AupPopupMenuPanel;
+    closePopup(): void;
+    shouldBeOpen(): void;
+    shouldNotBeOpen(): void;
+}

package/cypress/components/popup/aup-more-menu.d.ts

@@ -0,0 +1,5 @@
+import { PageElement } from '../../page-element';
+import { AupAbstractPopupMenu } from './aup-abstract-popup-menu';
+export declare class AupMoreMenu extends AupAbstractPopupMenu {
+    static create(parent: PageElement, selector?: string): AupMoreMenu;
+}

package/cypress/components/popup/aup-popup-menu-panel.d.ts

@@ -0,0 +1,3 @@
+import { PageElement } from '../../page-element';
+export declare class AupPopupMenuPanel extends PageElement {
+}

package/cypress/components/popup/aup-popup-menu.d.ts

@@ -0,0 +1,7 @@
+import { PageElement } from '../../page-element';
+import { Types } from '../types';
+import { AupAbstractPopupMenu } from './aup-abstract-popup-menu';
+export declare class AupPopupMenu extends AupAbstractPopupMenu {
+    constructor(parentElementAccessor: PageElement, face: Types.CommandFace);
+    static create(parent: PageElement, face: Types.CommandFace): AupPopupMenu;
+}

package/cypress/components/table/aup-table-cell.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="cypress" />
+import { PageElement } from '../../page-element';
+import { AupAbstractTable } from '../aup-abstract-table';
+import { AupTableRow } from './aup-table-row';
+import Chainable = Cypress.Chainable;
+export declare class AupTableCell<TR extends AupTableRow> extends PageElement<AupAbstractTable<TR>> {
+    rowId(): Chainable<string>;
+    row(): TR;
+}

package/cypress/components/table/aup-table-column.d.ts

@@ -0,0 +1,10 @@
+import { PageElement } from '../../page-element';
+import { AupAbstractTable } from '../aup-abstract-table';
+import { AupTableCell } from './aup-table-cell';
+import { AupTableRow } from './aup-table-row';
+export declare class AupTableColumn<TR extends AupTableRow> extends PageElement<AupAbstractTable<TR>> {
+    readonly columnId: string;
+    constructor(table: AupAbstractTable<any>, columnId: string);
+    cellContaining(content: string): AupTableCell<TR>;
+    rowContaining(content: string): TR;
+}

package/cypress/components/table/aup-table-row.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="cypress" />
+import { PageElement } from '../../page-element';
+import { AupAbstractTable } from '../aup-abstract-table';
+import { AupTableCell } from './aup-table-cell';
+import { AupTableColumn } from './aup-table-column';
+import { AupTableSelectionCell } from './aup-table-selection-cell';
+import { AupTableSelectionColumn } from './aup-table-selection-column';
+import Chainable = Cypress.Chainable;
+export declare class AupTableRow extends PageElement<AupAbstractTable<any>> {
+    rowId(): Chainable<string>;
+    shouldHaveRowId(rowId: string): void;
+    cell(columnId: string): AupTableCell<this>;
+    cell(column: AupTableColumn<this>): AupTableCell<this>;
+    cell(column: AupTableSelectionColumn<this>): AupTableSelectionCell<this>;
+    shouldBeSelected(): void;
+    shouldNotBeSelected(): void;
+}

package/cypress/components/table/aup-table-selection-cell.d.ts

@@ -0,0 +1,5 @@
+import { AupTableCell } from './aup-table-cell';
+import { AupTableRow } from './aup-table-row';
+export declare class AupTableSelectionCell<TR extends AupTableRow> extends AupTableCell<TR> {
+    selectAll(): void;
+}

package/cypress/components/table/aup-table-selection-column.d.ts

@@ -0,0 +1,5 @@
+import { AupTableColumn } from './aup-table-column';
+import { AupTableRow } from './aup-table-row';
+export declare class AupTableSelectionColumn<TR extends AupTableRow> extends AupTableColumn<TR> {
+    selectAll(): void;
+}