@guiexpert/table 1.0.2 → 1.0.5

package/lib/table/data/options/table-options.if.d.ts

@@ -0,0 +1,42 @@
+import { DefaultRowHeightsIf } from "./default-row-heights.if";
+import { TreeOptionsIf } from "./tree-options.if";
+import { FilterFunction } from "../common/filter-function";
+import { SortState } from "../common/sort-state.type";
+import { SortedOptionsIf } from "./sorted-options.if";
+import { AutoRestoreOptionsIf } from "./auto-restore-options.if";
+import { GetEditRenderer } from "../../renderer/edit/edit-cell-renderer.type";
+import { SelectionModelIf } from "../../selection/selection-model.if";
+import { GetT } from "../common/get-t";
+import { FocusModelIf } from "../../focus/focus-model.if";
+import { ShortcutActionIdMapping } from "../../action/shortcut-actionid-mapping.type";
+export interface TableOptionsIf {
+    headerSeparatorBorderVisible: boolean;
+    footerSeparatorBorderVisible: boolean;
+    fixedEastSeparatorBorderVisible: boolean;
+    fixedWestSeparatorBorderVisible: boolean;
+    verticalBorderVisible: boolean;
+    horizontalBorderVisible: boolean;
+    overflowX: "auto" | "scroll";
+    overflowY: "auto" | "scroll";
+    tableTopBorderVisible: boolean;
+    tableBottomBorderVisible: boolean;
+    hoverRowVisible: boolean;
+    hoverColumnVisible: boolean;
+    columnsResizable: boolean;
+    columnsDraggable: boolean;
+    columnResizeHandleWidthInPx: number;
+    headerVerticalSeparator: boolean;
+    footerVerticalSeparator: boolean;
+    defaultRowHeights: DefaultRowHeightsIf;
+    headerToggleExpandCollapseIcons: boolean;
+    treeOptions: TreeOptionsIf;
+    showCheckboxWihoutExtraColumn: boolean;
+    externalFilterFunction: FilterFunction<any> | undefined;
+    sortedOptions: SortedOptionsIf;
+    sortOrder: SortState[];
+    autoRestoreOptions?: AutoRestoreOptionsIf<any>;
+    getEditRenderer?: GetEditRenderer;
+    getSelectionModel?: GetT<SelectionModelIf>;
+    getFocusModel?: GetT<FocusModelIf>;
+    shortcutActionIdMapping?: ShortcutActionIdMapping;
+}

package/lib/table/data/options/tree-options.d.ts

@@ -0,0 +1,9 @@
+import { IconIf } from "./icon.if";
+import { TreeOptionsIf } from "./tree-options.if";
+export declare class TreeOptions implements TreeOptionsIf {
+    arrowExpanded: IconIf;
+    arrowCollapsed: IconIf;
+    arrowPlaceholder: IconIf;
+    arrowExpandCollapseAll: IconIf;
+    constructor(arrowExpanded?: IconIf, arrowCollapsed?: IconIf, arrowPlaceholder?: IconIf, arrowExpandCollapseAll?: IconIf);
+}

package/lib/table/data/options/tree-options.if.d.ts

@@ -0,0 +1,7 @@
+import { IconIf } from "./icon.if";
+export interface TreeOptionsIf {
+    arrowExpandCollapseAll: IconIf;
+    arrowExpanded: IconIf;
+    arrowCollapsed: IconIf;
+    arrowPlaceholder: IconIf;
+}

package/lib/table/data/table-model-and-options.d.ts

@@ -0,0 +1,8 @@
+import { TableModelAndOptionsIf } from "./table-model-and-options.if";
+import { TableModelIf } from "./tablemodel/table-model.if";
+import { TableOptions } from "./options/table-options";
+export declare class TableModelAndOptions implements TableModelAndOptionsIf {
+    tableModel: TableModelIf;
+    tableOptions: TableOptions;
+    constructor(tableModel: TableModelIf, tableOptions: TableOptions);
+}

package/{src/lib/table/data/table-model-and-options.if.ts → lib/table/data/table-model-and-options.if.d.ts}

@@ -1,8 +1,6 @@
 import { TableModelIf } from "./tablemodel/table-model.if";
 import { TableOptions } from "./options/table-options";
-
-
 export interface TableModelAndOptionsIf {
-  tableModel: TableModelIf;
-  tableOptions: TableOptions;
+    tableModel: TableModelIf;
+    tableOptions: TableOptions;
 }

package/{src/lib/table/data/tablemodel/area-ident.type.ts → lib/table/data/tablemodel/area-ident.type.d.ts}

@@ -2,17 +2,8 @@
  * The AreaIdent is an identifier for the three areas : header, boder, and footer.
  */
 export type AreaIdent = "header" | "body" | "footer";
-
 /**
  * Converts a string to the identifier of type AreaIdent.
  * @param s should be "header"|"body"|"footer". The fallback return value is 'body'
  */
-export const getAreaIdentByString = (s: string | null): AreaIdent => {
-  if (s === "header") {
-    return "header";
-  }
-  if (s === "footer") {
-    return "footer";
-  }
-  return "body";
-};
+export declare const getAreaIdentByString: (s: string | null) => AreaIdent;

package/lib/table/data/tablemodel/areamodel/abstract-area-model.d.ts

@@ -0,0 +1,47 @@
+import { CellRendererIf } from "../../../renderer/cell-render.if";
+import { AreaModelIf } from "./area-model.if";
+import { CheckedType } from "../../common/checked-type";
+import { ColumnDefIf } from "../column/column-def.if";
+import { AreaIdent } from "../area-ident.type";
+import { CheckboxModelIf } from "../../../checkbox/checkbox-model.if";
+import { FilterFunction } from "../../common/filter-function";
+import { SortItem } from "../../common/sort-item";
+import { HasDefaultRowHeightIf } from "./has-default-row-height-if";
+export declare abstract class AbstractAreaModel<T> implements AreaModelIf, HasDefaultRowHeightIf {
+    areaIdent: AreaIdent;
+    protected columnDefs: ColumnDefIf[];
+    defaultRowHeight: number;
+    rowSelectionModel: CheckboxModelIf<any> | undefined;
+    protected cellRenderers: (CellRendererIf | undefined)[];
+    protected yPositions: number[];
+    constructor(areaIdent: AreaIdent, columnDefs?: ColumnDefIf[], defaultRowHeight?: number);
+    abstract getRowCount(): number;
+    abstract getValueAt(rowIndex: number, columnIndex: number): any;
+    getTooltipAt(_rowIndex: number, _columnIndex: number): any;
+    abstract getRowHeight(rowIndex: number): number;
+    getCellRenderer(_rowIndex: number, columnIndex: number): CellRendererIf | undefined;
+    getColspanAt(_rowIndex: number, _columnIndex: number): number;
+    getCustomClassesAt(_rowIndex: number, _columnIndex: number): string[];
+    getCustomStyleAt(_rowIndex: number, _columnIndex: number): {
+        [key: string]: string;
+    } | undefined;
+    getRowspanAt(_rowIndex: number, _columnIndex: number): number;
+    getRowByIndex(_rowIndex: number): any;
+    isRowCheckable(_rowIndex: number): boolean;
+    isRowChecked(rowIndex: number): CheckedType | undefined;
+    setRowChecked(rowIndex: number, checked: boolean): void;
+    getMaxColspan(): number;
+    getMaxRowspan(): number;
+    getYPosByRowIndex(rowIndex: number): number;
+    init(): void;
+    abstract externalFilterChanged<T>(predictFn: FilterFunction<T>): void;
+    isFilterable(): boolean;
+    doSort(_sortItems: SortItem[]): boolean;
+    isEditable(_rowIndex: number, columnIndex: number): boolean;
+    setValue(rowIndex: number, columnIndex: number, value: any): boolean;
+    isSelectable(_rowIndex: number, _columnIndex: number): boolean;
+    changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void;
+    protected setPropertyValue(o: any, props: string[], value: any): boolean;
+    protected arrayMove(arr: any[], fromIndex: number, toIndex: number): any[];
+    private calcYPositions;
+}

package/lib/table/data/tablemodel/areamodel/area-model-array-of-arrays.d.ts

@@ -0,0 +1,19 @@
+import { AbstractAreaModel } from "./abstract-area-model";
+import { AreaIdent } from "../area-ident.type";
+import { ColumnDefIf } from "../column/column-def.if";
+import { FilterFunction } from "../../common/filter-function";
+export declare class AreaModelArrayOfArrays<T> extends AbstractAreaModel<T[][]> {
+    areaIdent: AreaIdent;
+    readonly arr: T[][];
+    defaultRowHeight: number;
+    protected columnDefs: ColumnDefIf[];
+    filteredArr: T[][];
+    constructor(areaIdent: AreaIdent, arr: T[][], defaultRowHeight: number, columnDefs?: ColumnDefIf[]);
+    externalFilterChanged(predictFn: FilterFunction<any>): void;
+    getRowCount(): number;
+    getValueAt(rowIndex: number, columnIndex: number): any;
+    setValue(rowIndex: number, columnIndex: number, value: any): boolean;
+    getRowByIndex(rowIndex: number): any;
+    getRowHeight(_rowIndex: number): number;
+    changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void;
+}

package/lib/table/data/tablemodel/areamodel/area-model-cell-groups.d.ts

@@ -0,0 +1,51 @@
+import { AreaIdent } from "../area-ident.type";
+import { ColumnDefIf } from "../column/column-def.if";
+import { AreaModelIf } from "./area-model.if";
+import { CellGroupIf } from "../cellgroup/cell-group.if";
+import { CheckboxModelIf } from "../../../checkbox/checkbox-model.if";
+import { SortItem } from "../../common/sort-item";
+import { FilterFunction } from "../../common/filter-function";
+import { CellRendererIf } from "../../../renderer/cell-render.if";
+import { CheckedType } from "../../common/checked-type";
+import { CellGroupExt } from "../cellgroup/cell-group-ext";
+export declare class AreaModelCellGroups implements AreaModelIf {
+    readonly areaIdent: AreaIdent;
+    readonly groups: CellGroupIf[];
+    readonly columnDefs: ColumnDefIf[];
+    readonly defaultRowHeight: number;
+    gammaCells: boolean;
+    rowSelectionModel: CheckboxModelIf<any> | undefined;
+    readonly arr: (CellGroupExt | null | undefined)[][];
+    private groupExts;
+    private cellGroupExtCellRenderer;
+    constructor(areaIdent: AreaIdent, groups: CellGroupIf[], columnDefs: ColumnDefIf[], defaultRowHeight: number);
+    getAllLeafs(): CellGroupExt[];
+    getMaxRowCount(): number;
+    buildArray(): (CellGroupExt | null | undefined)[][];
+    changeColumnOrder(_sourceColumnIndex: number, _targetColumnIndex: number): void;
+    doSort(_sortItems: SortItem[]): boolean;
+    externalFilterChanged<T>(_predictFn: FilterFunction<T>): void;
+    getCellRenderer(_rowIndex: number, _columnIndex: number): CellRendererIf | undefined;
+    getColspanAt(rowIndex: number, columnIndex: number): number;
+    getCustomClassesAt(_rowIndex: number, _columnIndex: number): string[];
+    getCustomStyleAt(_rowIndex: number, _columnIndex: number): {
+        [p: string]: string;
+    } | undefined;
+    getMaxColspan(): number;
+    getMaxRowspan(): number;
+    getRowByIndex(_rowIndex: number): any;
+    getRowCount(): number;
+    getRowspanAt(rowIndex: number, columnIndex: number): number;
+    getTooltipAt(_rowIndex: number, _columnIndex: number): any;
+    getValueAt(rowIndex: number, columnIndex: number): any;
+    getYPosByRowIndex(_rowIndex: number): number;
+    init(): void;
+    getRowHeight(_rowIndex: number): number;
+    isEditable(_rowIndex: number, _columnIndex: number): boolean;
+    isFilterable(): boolean;
+    isRowCheckable(_rowIndex: number): boolean;
+    isRowChecked(_rowIndex: number): CheckedType | undefined;
+    isSelectable(_rowIndex: number, _columnIndex: number): boolean;
+    setRowChecked(_rowIndex: number, _checked: boolean): void;
+    setValue(_rowIndex: number, _columnIndex: number, _value: any): boolean;
+}

package/lib/table/data/tablemodel/areamodel/area-model-hidden.d.ts

@@ -0,0 +1,41 @@
+import { AreaModelIf } from "./area-model.if";
+import { CellRendererIf } from "../../../renderer/cell-render.if";
+import { CheckedType } from "../../common/checked-type";
+import { CheckboxModelIf } from "../../../checkbox/checkbox-model.if";
+import { FilterFunction } from "../../common/filter-function";
+import { SortItem } from "../../common/sort-item";
+import { AreaIdent } from "../area-ident.type";
+/**
+ * An unvisible model, which is used internally for hiding a header.
+ */
+export declare class AreaModelHidden implements AreaModelIf {
+    areaIdent: AreaIdent;
+    rowSelectionModel: CheckboxModelIf<any> | undefined;
+    constructor(areaIdent?: AreaIdent);
+    getRowCount(): number;
+    getValueAt(_rowIndex: number, _columnIndex: number): any;
+    getCellRenderer(_rowIndex: number, _columnIndex: number): CellRendererIf | undefined;
+    getRowHeight(_rowIndex: number): number;
+    getColspanAt(_rowIndex: number, _columnIndex: number): number;
+    getCustomClassesAt(_rowIndex: number, _columnIndex: number): string[];
+    getCustomStyleAt(_rowIndex: number, _columnIndex: number): {
+        [key: string]: string;
+    } | undefined;
+    getRowspanAt(_rowIndex: number, _columnIndex: number): number;
+    getRowByIndex(_idx: number): any;
+    isRowCheckable(_rowIndex: number): boolean;
+    isRowChecked(_rowIndex: number): CheckedType | undefined;
+    setRowChecked(_rowIndex: number, _checked: boolean): void;
+    getTooltipAt(_rowIndex: number, _columnIndex: number): any;
+    getMaxColspan(): number;
+    getMaxRowspan(): number;
+    getYPosByRowIndex(_rowIndex: number): number;
+    init(): void;
+    externalFilterChanged(_predictFn: FilterFunction<any>): void;
+    isFilterable(): boolean;
+    doSort(_sortItems: SortItem[]): boolean;
+    isEditable(_rowIndex: number, _columnIndex: number): boolean;
+    setValue(_rowIndex: number, _columnIndex: number, _value: string): boolean;
+    isSelectable(_rowIndex: number, _columnIndex: number): boolean;
+    changeColumnOrder(_sourceColumnIndex: number, _targetColumnIndex: number): void;
+}

package/lib/table/data/tablemodel/areamodel/area-model-object-array-with-columndefs.d.ts

@@ -0,0 +1,10 @@
+import { AreaModelObjectyArray } from "./area-model-object-array";
+import { ColumnDefIf } from "../column/column-def.if";
+import { AreaIdent } from "../area-ident.type";
+export declare class AreaModelObjectArrayWithColumndefs<T> extends AreaModelObjectyArray<T> {
+    areaIdent: AreaIdent;
+    protected readonly rows: T[];
+    protected readonly columnDefs: ColumnDefIf[];
+    defaultRowHeight: number;
+    constructor(areaIdent: AreaIdent, rows: T[], columnDefs: ColumnDefIf[], defaultRowHeight: number);
+}

package/lib/table/data/tablemodel/areamodel/area-model-object-array.d.ts

@@ -0,0 +1,28 @@
+import { AbstractAreaModel } from "./abstract-area-model";
+import { ColumnDefIf } from "../column/column-def.if";
+import { AreaIdent } from "../area-ident.type";
+import { FilterFunction } from "../../common/filter-function";
+import { SorterService } from "../../../service/sorter.service";
+import { SortItem } from "../../common/sort-item";
+export declare class AreaModelObjectyArray<T> extends AbstractAreaModel<T> {
+    areaIdent: AreaIdent;
+    protected readonly rows: T[];
+    defaultRowHeight: number;
+    protected columnDefs: ColumnDefIf[];
+    protected readonly properties: string[];
+    protected filteredRows: T[];
+    protected sorterService: SorterService;
+    constructor(areaIdent: AreaIdent, rows: T[], defaultRowHeight: number, columnDefs?: ColumnDefIf[]);
+    getRowCount(): number;
+    getValueAt(rowIndex: number, columnIndex: number): any;
+    getFilteredRows(): T[];
+    getAllRows(): T[];
+    getRowHeight(_rowIndex: number): number;
+    getRowByIndex(rowIndex: number): any;
+    externalFilterChanged(predictFn: FilterFunction<any>): void;
+    doSort(sortItems: SortItem[]): boolean;
+    getValueByT(t: T, property: string): any;
+    changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void;
+    protected genericFlatTableSortComparator(property: string, f: number): (a: T, b: T) => number;
+    private getPropertyValue;
+}

package/lib/table/data/tablemodel/areamodel/area-model-tree.d.ts

@@ -0,0 +1,39 @@
+import { TreeRow } from "../../common/tree-row";
+import { AbstractAreaModel } from "./abstract-area-model";
+import { AreaIdent } from "../area-ident.type";
+import { ColumnDefIf } from "../column/column-def.if";
+import { FilterFunction } from "../../common/filter-function";
+import { SorterService } from "../../../service/sorter.service";
+import { SortItem } from "../../common/sort-item";
+export declare class AreaModelTree<S> extends AbstractAreaModel<TreeRow<S>> {
+    areaIdent: AreaIdent;
+    readonly rows: TreeRow<S>[];
+    defaultRowHeight: number;
+    protected columnDefs: ColumnDefIf[];
+    protected readonly properties: string[];
+    protected sorterService: SorterService;
+    private readonly service;
+    private filteredFlattenRows;
+    private flattenRows;
+    private lastPredictFn?;
+    constructor(areaIdent: AreaIdent, rows: TreeRow<S>[], defaultRowHeight: number, columnDefs?: ColumnDefIf[]);
+    changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void;
+    recalcVisibleTreeRows(): void;
+    getFilteredFlattenRows(): TreeRow<S>[];
+    getRowCount(): number;
+    getValueAt(rowIndex: number, columnIndex: number): any;
+    getRowHeight(_rowIndex: number): number;
+    getCustomClassesAt(rowIndex: number, _columnIndex: number): string[];
+    getRowByIndex(idx: number): TreeRow<S> | undefined;
+    getValueByT(t: S, property: string): any;
+    externalFilterChanged<S>(predictFn: FilterFunction<S>): void;
+    doSort(sortItems: SortItem[]): boolean;
+    toggleExpandCollapseAll(expanded: boolean): void;
+    setAllParentsOk(item: TreeRow<any>): boolean;
+    setValue(rowIndex: number, columnIndex: number, value: any): boolean;
+    protected genericTreeTableSortComparator(property: string, f: number): (a: TreeRow<S>, b: TreeRow<S>) => number;
+    private expandAllRecursive;
+    private doFiltering;
+    private getPropertyValue;
+    private treeSort;
+}

package/lib/table/data/tablemodel/areamodel/area-model.d.ts

@@ -0,0 +1,37 @@
+import { AreaModelIf } from "./area-model.if";
+import { AreaIdent } from "../area-ident.type";
+import { CheckboxModelIf } from "../../../checkbox/checkbox-model.if";
+import { SortItem } from "../../common/sort-item";
+import { FilterFunction } from "../../common/filter-function";
+import { CellRendererIf } from "../../../renderer/cell-render.if";
+import { CheckedType } from "../../common/checked-type";
+export declare class AreaModel implements AreaModelIf {
+    areaIdent: AreaIdent;
+    rowSelectionModel: CheckboxModelIf<any> | undefined;
+    changeColumnOrder(_sourceColumnIndex: number, _targetColumnIndex: number): void;
+    doSort(_sortItems: SortItem[]): boolean;
+    externalFilterChanged<T>(_predictFn: FilterFunction<T>): void;
+    getCellRenderer(_rowIndex: number, _columnIndex: number): CellRendererIf | undefined;
+    getColspanAt(_rowIndex: number, _columnIndex: number): number;
+    getCustomClassesAt(_rowIndex: number, _columnIndex: number): string[];
+    getCustomStyleAt(_rowIndex: number, _columnIndex: number): {
+        [p: string]: string;
+    } | undefined;
+    getMaxColspan(): number;
+    getMaxRowspan(): number;
+    getRowByIndex(_rowIndex: number): any;
+    getRowCount(): number;
+    getRowHeight(_rowIndex: number): number;
+    getRowspanAt(_rowIndex: number, _columnIndex: number): number;
+    getTooltipAt(_rowIndex: number, _columnIndex: number): any;
+    getValueAt(_rowIndex: number, _columnIndex: number): any;
+    getYPosByRowIndex(_rowIndex: number): number;
+    init(): void;
+    isEditable(_rowIndex: number, _columnIndex: number): boolean;
+    isFilterable(): boolean;
+    isRowCheckable(_rowIndex: number): boolean;
+    isRowChecked(_rowIndex: number): CheckedType | undefined;
+    isSelectable(_rowIndex: number, _columnIndex: number): boolean;
+    setRowChecked(_rowIndex: number, _checked: boolean): void;
+    setValue(_rowIndex: number, _columnIndex: number, _value: any): boolean;
+}

package/lib/table/data/tablemodel/areamodel/area-model.if.d.ts

@@ -0,0 +1,158 @@
+import { CellRendererIf } from "../../../renderer/cell-render.if";
+import { CheckedType } from "../../common/checked-type";
+import { CheckboxModelIf } from "../../../checkbox/checkbox-model.if";
+import { FilterFunction } from "../../common/filter-function";
+import { SortItem } from "../../common/sort-item";
+import { AreaIdent } from "../area-ident.type";
+/**
+ * This is the model interface for an area model. A table can have three of these models, one for the header,
+ * one for the body , and one for the footer.
+ * An AreaModelIf gives you information about the rows and cell contents.
+ * The column information is given by the TableModelIf.
+ */
+export interface AreaModelIf {
+    /**
+     * The identifier for one of the areas: header, body, footer.
+     */
+    areaIdent: AreaIdent;
+    /**
+     * A model and controller for a row checkbox selection
+     */
+    rowSelectionModel: CheckboxModelIf<any> | undefined;
+    /**
+     * Method for moving a column from position sourceColumnIndex to targetColumnIndex.
+     */
+    changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void;
+    /**
+     * Method for changing a cell value.
+     */
+    setValue(rowIndex: number, columnIndex: number, value: any): boolean;
+    /**
+     * Internally used by TableModel.
+     */
+    init(): void;
+    /**
+     * Returns the number of rows of the area
+     */
+    getRowCount(): number;
+    /**
+     * Returns the value of the cell at position rowIndex/columnIndex.
+     */
+    getValueAt(rowIndex: number, columnIndex: number): any;
+    /**
+     * Returns the value of a colspan of the cell at position rowIndex/columnIndex.
+     * A value below 2 is ignored.
+     */
+    getColspanAt(rowIndex: number, columnIndex: number): number;
+    /**
+     * This return value is internally used to optimize the render performance.
+     * Set this value to the lowest possible value. If the model has no colspan,
+     * a value of 0 would be good. The dafault is 32. If your model has a colspan
+     * cell greater 32, don't forget to increase this value.
+     */
+    getMaxColspan(): number;
+    /**
+     * Returns the value of a rowspan of the cell at position rowIndex/columnIndex.
+     * A value below 2 is ignored.
+     */
+    getRowspanAt(rowIndex: number, columnIndex: number): number;
+    /**
+     * This return value is internally used to optimize the render performance.
+     * Set this value to the lowest possible value. If the model has no rowspan,
+     * a value of 0 would be good. The dafault is 32. If your model has a rowspan
+     * cell greater 32, don't forget to increase this value.
+     */
+    getMaxRowspan(): number;
+    /**
+     * This method can be used to return a list of css classes for the given cell
+     * @param rowIndex row index of the cell
+     * @param columnIndex column index of the cell
+     */
+    getCustomClassesAt(rowIndex: number, columnIndex: number): string[];
+    /**
+     * This method can be used to return an object with css style information for the given cell
+     * @param rowIndex row index of the cell
+     * @param columnIndex column index of the cell
+     */
+    getCustomStyleAt(rowIndex: number, columnIndex: number): {
+        [key: string]: string;
+    } | undefined;
+    /**
+     * Returns the cell value of the given cell. This value will be rendered
+     * directly in the cell or rendered by a cell renderer: see {@link getCellRenderer}.
+     * @param rowIndex
+     * @param columnIndex
+     */
+    getValueAt(rowIndex: number, columnIndex: number): any;
+    /**
+     * Returns the value of a tooltip of the given cell (rowIndex/columnIndex).
+     * @param rowIndex
+     * @param columnIndex
+     */
+    getTooltipAt(rowIndex: number, columnIndex: number): any;
+    /**
+     * Returns a cell renderer class for the given cell (rowIndex/columnIndex).
+     * If the return value is undefined, no renderer is used and the model value will be rendered directly in the cell.
+     * @param rowIndex
+     * @param columnIndex
+     */
+    getCellRenderer(rowIndex: number, columnIndex: number): CellRendererIf | undefined;
+    /**
+     * Returns the row height in pixel of the given row (rowIndex).
+     * @param rowIndex
+     */
+    getRowHeight(rowIndex: number): number;
+    /**
+     * Returns the row of the model, which correspond to the rowIndex.
+     * @param rowIndex
+     */
+    getRowByIndex(rowIndex: number): any;
+    /**
+     * Return the y-position in pixel of the top of the row on the scrollpane.
+     * For big tables it can be a big value (greate than the height of the viewport).
+     * @param rowIndex
+     */
+    getYPosByRowIndex(rowIndex: number): number;
+    /**
+     * If this method returns true, the cell can be edited by the user.
+     * @param rowIndex
+     * @param columnIndex
+     */
+    isEditable(rowIndex: number, columnIndex: number): boolean;
+    /**
+     * If true, the cell is selectable.
+     * @param rowIndex
+     * @param columnIndex
+     */
+    isSelectable(rowIndex: number, columnIndex: number): boolean;
+    /**
+     * If true, the row is checkable and a checkbox is rendered at the beginning of the row.
+     * @param rowIndex
+     */
+    isRowCheckable(rowIndex: number): boolean;
+    /**
+     * Returns the checked state of an row.
+     * @param rowIndex
+     */
+    isRowChecked(rowIndex: number): CheckedType | undefined;
+    /**
+     * Set the checked state of the row (rowIndex) to #checked.
+     * @param rowIndex
+     * @param checked
+     */
+    setRowChecked(rowIndex: number, checked: boolean): void;
+    /**
+     * If true, the table is filterable. Rows can be filtered with help of {@link #externalFilterChanged()}
+     */
+    isFilterable(): boolean;
+    /**
+     * Will be called internally, when a filtering is trigger.
+     * @param predictFn Defines, what row are invisible or visible after filtering.
+     */
+    externalFilterChanged<T>(predictFn: FilterFunction<T>): void;
+    /**
+     * If the 'restore sort' option is set (see), this method will be triggered automatically by the table,
+     * @param sortItems
+     */
+    doSort(sortItems: SortItem[]): boolean;
+}

package/lib/table/data/tablemodel/areamodel/col-and-rowspan-model.d.ts

@@ -0,0 +1,12 @@
+import { CellRange } from "../../common/cell-range";
+import { AreaModelIf } from "./area-model.if";
+import { TableModelIf } from "../table-model.if";
+export declare class ColAndRowspanModel {
+    protected tableModel: TableModelIf;
+    protected areaModel: AreaModelIf;
+    protected colAndRowspanRanges: CellRange[] | undefined;
+    constructor(tableModel: TableModelIf, areaModel: AreaModelIf);
+    init(): void;
+    getRanges(): CellRange[];
+    isInRange(rowIndex: number, columnIndex: number): boolean;
+}

package/{src/lib/table/data/tablemodel/areamodel/has-default-row-height-if.ts → lib/table/data/tablemodel/areamodel/has-default-row-height-if.d.ts}

@@ -1,3 +1,3 @@
 export interface HasDefaultRowHeightIf {
-  defaultRowHeight: number;
+    defaultRowHeight: number;
 }

package/lib/table/data/tablemodel/cellgroup/cell-group-ext.d.ts

@@ -0,0 +1,21 @@
+import { CellGroupIf } from "./cell-group.if";
+import { CellGroup } from "./cell-group";
+export declare class CellGroupExt extends CellGroup {
+    rowIndex: number;
+    childIndex: number;
+    parent?: CellGroupExt | undefined;
+    impl: string;
+    children: CellGroupExt[] | undefined;
+    leftNeighbour: CellGroupExt | undefined;
+    rightNeighbour: CellGroupExt | undefined;
+    constructor(cellGroup: CellGroupIf, rowIndex?: number, childIndex?: number, parent?: CellGroupExt | undefined);
+    ownColumn(): boolean;
+    toString(): string;
+    getColumnIndex(): number;
+    isVisible(): boolean;
+    claimsSpace(): boolean;
+    getColumnCount(cg?: CellGroupExt, ret?: number): number;
+    getRowSpan(cg: CellGroupExt | undefined, maxRowCount: number): number;
+    getParentCount(cg?: CellGroupExt, ret?: number): number;
+    log(maxRowCount: number): void;
+}

package/lib/table/data/tablemodel/cellgroup/cell-group.d.ts

@@ -0,0 +1,11 @@
+import { CellGroupIf } from "./cell-group.if";
+export declare class CellGroup implements CellGroupIf {
+    data: any;
+    property?: string | undefined;
+    toggle?: boolean | undefined;
+    closed: boolean;
+    visibility: "always" | "inverted" | "normal" | undefined;
+    children: CellGroupIf[] | undefined;
+    impl: string;
+    constructor(data: any, property?: string | undefined, toggle?: boolean | undefined, closed?: boolean, visibility?: "always" | "inverted" | "normal" | undefined, children?: CellGroupIf[] | undefined);
+}

package/lib/table/data/tablemodel/cellgroup/cell-group.if.d.ts

@@ -0,0 +1,9 @@
+export interface CellGroupIf {
+    data: any;
+    property?: string;
+    toggle?: boolean;
+    closed?: boolean;
+    visibility?: "always" | "inverted" | "normal" | undefined;
+    children?: CellGroupIf[] | undefined;
+    impl?: string;
+}

package/lib/table/data/tablemodel/cellgroup/cellgroup-factory.d.ts

@@ -0,0 +1,10 @@
+import { CellGroupIf } from "./cell-group.if";
+import { ColumnDefIf } from "../column/column-def.if";
+import { CellGroupExt } from "./cell-group-ext";
+export declare class CellgroupFactory {
+    static buildColumnDefs(cellGroups: CellGroupIf[], ret?: ColumnDefIf[]): ColumnDefIf[];
+    static buildGroupExts(cellGroups: CellGroupIf[], ret?: CellGroupExt[], deep?: number, parent?: CellGroupExt): CellGroupExt[];
+    static flattenGroupExts(cellGroups: CellGroupExt[], ret?: CellGroupExt[]): CellGroupExt[];
+    static buildArrayOfArrays(flatten: CellGroupExt[], arrs: (CellGroupExt | null | undefined)[][]): (CellGroupExt | null | undefined)[][];
+    static iterateThrowColumns(sb: string[] | undefined, cellGroups: CellGroupExt[]): void;
+}