@guiexpert/table 0.0.1

package/lib/table/data/common/args-render-cell-div.d.ts

@@ -0,0 +1,13 @@
+import { AreaModelIf } from "../tablemodel/areamodel/area-model.if";
+import { AreaIdent } from "../tablemodel/area-ident.type";
+export interface ArgsRenderCellDiv {
+    areaModel: AreaModelIf;
+    areaIdent: AreaIdent;
+    rowIndex: number;
+    index: number;
+    left: number;
+    width: number;
+    height: number;
+    top: number;
+    parent: HTMLDivElement;
+}

package/lib/table/data/common/boolean-function.d.ts

@@ -0,0 +1,3 @@
+export declare type BooleanFunction = () => boolean;
+export declare const TrueFn: () => boolean;
+export declare const FalseFn: () => boolean;

package/lib/table/data/common/cell-range.d.ts

@@ -0,0 +1,17 @@
+export declare class CellRange {
+    r1: number;
+    c1: number;
+    r2: number;
+    c2: number;
+    constructor(r1: number, c1: number, r2: number, c2: number);
+    static create(params: {
+        rowIndex1: number;
+        columnIndex1: number;
+        rowIndex2: number;
+        columnIndex2: number;
+    }): CellRange;
+    static singleCell(rowIndex: number, columnIndex: number): CellRange;
+    static singleRow(rowIndex: number): CellRange;
+    static singleColumn(columnIndex: number): CellRange;
+    isInRange(rowIndex: number, columnIndex: number): boolean;
+}

package/lib/table/data/common/checkbox-column.d.ts

@@ -0,0 +1,13 @@
+import { SizeIf } from "./size.if";
+import { ColumnDefIf } from "../tablemodel/column/column-def.if";
+import { CellRendererIf } from "../../renderer/cell-render.if";
+import { AreaObjectMapType } from "./area-map.type";
+export declare class CheckboxColumn implements ColumnDefIf {
+    property: string;
+    headerLabel: string;
+    width: SizeIf;
+    minWidth: SizeIf;
+    maxWidth: SizeIf;
+    rendererMap: AreaObjectMapType<CellRendererIf>;
+    classes: AreaObjectMapType<string[]>;
+}

package/lib/table/data/common/checked-type.d.ts

@@ -0,0 +1 @@
+export declare type CheckedType = 'none' | 'semi' | 'full';

package/lib/table/data/common/event/ge-cell-indices.d.ts

@@ -0,0 +1,5 @@
+export declare class GeCellIndices {
+    rowIndex: number;
+    columnIndex: number;
+    constructor(rowIndex?: number, columnIndex?: number);
+}

package/lib/table/data/common/event/ge-key-event.d.ts

@@ -0,0 +1,5 @@
+export declare class GeKeyEvent {
+    status: 'down' | 'up';
+    originalEvent?: KeyboardEvent | undefined;
+    constructor(status?: 'down' | 'up', originalEvent?: KeyboardEvent | undefined);
+}

package/lib/table/data/common/event/ge-model-change-event.d.ts

@@ -0,0 +1,6 @@
+import { GeCellIndices } from "./ge-cell-indices";
+export declare class GeModelChangeEvent {
+    cells: GeCellIndices[];
+    constructor(cells: GeCellIndices[]);
+    static createSingle(rowIndex: number, columnIndex: number): GeModelChangeEvent;
+}

package/lib/table/data/common/event/ge-mouse-event.d.ts

@@ -0,0 +1,17 @@
+import { AreaIdent } from "../../tablemodel/area-ident.type";
+import { SideIdent } from "../../side-ident.type";
+export declare class GeMouseEvent {
+    rowIndex: number;
+    rowTop: number;
+    columnIndex: number;
+    columnLeft: number;
+    areaIdent?: AreaIdent | undefined;
+    sideIdent?: SideIdent | undefined;
+    originalEvent?: MouseEvent | undefined;
+    clickCount: number;
+    draggingX: number;
+    draggingY: number;
+    action: string | null;
+    constructor(rowIndex?: number, rowTop?: number, columnIndex?: number, columnLeft?: number, areaIdent?: AreaIdent | undefined, sideIdent?: SideIdent | undefined, originalEvent?: MouseEvent | undefined, clickCount?: number, draggingX?: number, draggingY?: number, action?: string | null);
+    clone(): GeMouseEvent;
+}

package/lib/table/data/common/filter-function.d.ts

@@ -0,0 +1 @@
+export declare type FilterFunction<T> = (value: T, index: number, array: T[]) => unknown;

package/lib/table/data/common/get-t.d.ts

@@ -0,0 +1 @@
+export declare type GetT<T> = () => T | undefined;

package/lib/table/data/common/index-and-px.d.ts

@@ -0,0 +1,5 @@
+export declare class IndexAndPx {
+    index: number;
+    px: number;
+    constructor(index: number, px: number);
+}

package/lib/table/data/common/size.d.ts

@@ -0,0 +1,6 @@
+import { SizeIf } from "./size.if";
+export declare class Size implements SizeIf {
+    value: number;
+    unit: 'px' | '%';
+    constructor(value?: number, unit?: 'px' | '%');
+}

package/lib/table/data/common/size.if.d.ts

@@ -0,0 +1,4 @@
+export interface SizeIf {
+    value: number;
+    unit: 'px' | '%';
+}

package/lib/table/data/common/sizes.d.ts

@@ -0,0 +1,32 @@
+import { Size } from "./size";
+export declare const px300: Size;
+export declare const px290: Size;
+export declare const px280: Size;
+export declare const px270: Size;
+export declare const px260: Size;
+export declare const px250: Size;
+export declare const px240: Size;
+export declare const px230: Size;
+export declare const px220: Size;
+export declare const px210: Size;
+export declare const px200: Size;
+export declare const px190: Size;
+export declare const px180: Size;
+export declare const px170: Size;
+export declare const px160: Size;
+export declare const px150: Size;
+export declare const px140: Size;
+export declare const px130: Size;
+export declare const px120: Size;
+export declare const px110: Size;
+export declare const px100: Size;
+export declare const px90: Size;
+export declare const px80: Size;
+export declare const px70: Size;
+export declare const px60: Size;
+export declare const px50: Size;
+export declare const px40: Size;
+export declare const px30: Size;
+export declare const px20: Size;
+export declare const px10: Size;
+export declare const px0: Size;

package/lib/table/data/common/sort-item.d.ts

@@ -0,0 +1,6 @@
+import { SortState } from "./sort-state.type";
+export declare class SortItem {
+    columnIndex: number;
+    sortState: SortState;
+    constructor(columnIndex: number, sortState: SortState);
+}

package/lib/table/data/common/sort-state.type.d.ts

@@ -0,0 +1 @@
+export declare type SortState = "asc" | "desc" | "";

package/lib/table/data/common/tree-arrow.type.d.ts

@@ -0,0 +1 @@
+export declare type TreeArrowType = "none" | "hidden" | "collapsed" | "expanded";

package/lib/table/data/common/tree-row-if.d.ts

@@ -0,0 +1,10 @@
+import { TreeRow } from "./tree-row";
+export interface TreeRowIf<T> {
+    data: T;
+    expanded: boolean;
+    children: TreeRow<T>[] | undefined;
+    parent: TreeRow<T> | undefined;
+    deep: number;
+    checked: boolean;
+    keep: boolean;
+}

package/lib/table/data/common/tree-row.d.ts

@@ -0,0 +1,11 @@
+import { TreeRowIf } from "./tree-row-if";
+export declare class TreeRow<T> implements TreeRowIf<T> {
+    data: T;
+    expanded: boolean;
+    children: TreeRowIf<T>[] | undefined;
+    parent: TreeRowIf<T> | undefined;
+    deep: number;
+    checked: boolean;
+    keep: boolean;
+    constructor(data: T, expanded: boolean, children: TreeRowIf<T>[] | undefined, parent: TreeRowIf<T> | undefined, deep?: number, checked?: boolean, keep?: boolean);
+}

package/lib/table/data/common/value-label.d.ts

@@ -0,0 +1,6 @@
+import { ValueLabelIf } from "./value-label.if";
+export declare class ValueLabel implements ValueLabelIf {
+    value: any;
+    label: string;
+    constructor(value: any, label: string);
+}

package/lib/table/data/common/value-label.if.d.ts

@@ -0,0 +1,4 @@
+export interface ValueLabelIf {
+    value: any;
+    label: string;
+}

package/lib/table/data/div-scope.type.d.ts

@@ -0,0 +1,7 @@
+export declare type DivScope = {
+    parent: HTMLDivElement;
+    child: HTMLDivElement;
+    cache: {
+        [key: number]: HTMLDivElement;
+    };
+};

package/lib/table/data/geo-data.d.ts

@@ -0,0 +1,8 @@
+export declare class GeoData {
+    left: number;
+    width: number;
+    height: number;
+    top: number;
+    index?: number | undefined;
+    constructor(left?: number, width?: number, height?: number, top?: number, index?: number | undefined);
+}

package/lib/table/data/options/auto-restore-options.d.ts

@@ -0,0 +1,11 @@
+import { AutoRestoreOptionsIf } from "./auto-restore-options.if";
+export declare class AutoRestoreOptions<T> implements AutoRestoreOptionsIf<T> {
+    autoRestoreSortingState: boolean;
+    autoRestoreCollapsedExpandedState: boolean;
+    autoRestoreScrollPosition: boolean;
+    autoRestoreCheckedState: boolean;
+    autoRestoreSelectedState: boolean;
+    getStorageKeyFn: undefined;
+    isSame: (r1: T, r2: T, options: AutoRestoreOptionsIf<T>) => boolean;
+    getRowId: (row: T) => string | number;
+}

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

@@ -0,0 +1,13 @@
+export declare type IsSameFn<T> = (r1: T, r2: T, optionsIf: AutoRestoreOptionsIf<T>) => boolean;
+export declare type GetRowIdFn<T> = ((row: T) => string | number);
+export declare type GetStorageKeyFn = (() => string);
+export interface AutoRestoreOptionsIf<T> {
+    autoRestoreSortingState: boolean;
+    autoRestoreCollapsedExpandedState?: boolean;
+    autoRestoreScrollPosition?: boolean;
+    autoRestoreCheckedState?: boolean;
+    autoRestoreSelectedState?: boolean;
+    getRowId?: undefined | GetRowIdFn<T>;
+    getStorageKeyFn?: undefined | GetStorageKeyFn;
+    isSame?: undefined | IsSameFn<T>;
+}

package/lib/table/data/options/default-row-heights.d.ts

@@ -0,0 +1,7 @@
+import { DefaultRowHeightsIf } from "./default-row-heights.if";
+export declare class DefaultRowHeights implements DefaultRowHeightsIf {
+    header: number;
+    body: number;
+    footer: number;
+    constructor(header?: number, body?: number, footer?: number);
+}

package/lib/table/data/options/default-row-heights.if.d.ts

@@ -0,0 +1,5 @@
+export interface DefaultRowHeightsIf {
+    header: number;
+    body: number;
+    footer: number;
+}

package/lib/table/data/options/icon.d.ts

@@ -0,0 +1,7 @@
+import { IconIf } from "./icon.if";
+export declare class Icon implements IconIf {
+    content: string;
+    style: string;
+    classes: string[];
+    constructor(content?: string, style?: string, classes?: string[]);
+}

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

@@ -0,0 +1,5 @@
+export interface IconIf {
+    content: string;
+    style: string;
+    classes: string[];
+}

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

@@ -0,0 +1,8 @@
+import { IconIf } from "./icon.if";
+import { SortedOptionsIf } from "./sorted-options.if";
+export declare class SortedOptions implements SortedOptionsIf {
+    iconAsc: IconIf;
+    iconDesc: IconIf;
+    iconPlaceholder: IconIf;
+    constructor(iconAsc?: IconIf, iconDesc?: IconIf, iconPlaceholder?: IconIf);
+}

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

@@ -0,0 +1,6 @@
+import { IconIf } from "./icon.if";
+export interface SortedOptionsIf {
+    iconAsc: IconIf;
+    iconDesc: IconIf;
+    iconPlaceholder: IconIf;
+}

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

@@ -0,0 +1,36 @@
+import { DefaultRowHeightsIf } from "./default-row-heights.if";
+import { TableOptionsIf } from "./table-options.if";
+import { TreeOptions } from "./tree-options";
+import { FilterFunction } from "../common/filter-function";
+import { SortState } from "../common/sort-state.type";
+import { SortedOptions } from "./sorted-options";
+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 declare class TableOptions implements TableOptionsIf {
+    overflowX: 'auto' | 'scroll';
+    overflowY: 'auto' | 'scroll';
+    hoverRowVisible: boolean;
+    hoverColumnVisible: boolean;
+    columnsResizable: boolean;
+    columnResizeHandleWidthInPx: number;
+    defaultRowHeights: DefaultRowHeightsIf;
+    autoRestoreCheckedStateAfterUpdate: boolean;
+    autoRestoreExpandedStateAfterUpdate: boolean;
+    autoRestoreScrollPositionAfterUpdate: boolean;
+    autoRestoreSelectedStateAfterUpdate: boolean;
+    footerVerticalSeparator: boolean;
+    headerToggleExpandCollapseIcons: boolean;
+    headerVerticalSeparator: boolean;
+    treeOptions: TreeOptions;
+    showCheckboxWihoutExtraColumn: boolean;
+    externalFilterFunction: FilterFunction<any> | undefined;
+    sortedOptions: SortedOptions;
+    sortOrder: SortState[];
+    getEditRenderer?: GetEditRenderer;
+    getSelectionModel?: GetT<SelectionModelIf>;
+    getFocusModel?: GetT<FocusModelIf>;
+    shortcutActionIdMapping?: ShortcutActionIdMapping;
+}

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

@@ -0,0 +1,37 @@
+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 {
+    overflowX: 'auto' | 'scroll';
+    overflowY: 'auto' | 'scroll';
+    hoverRowVisible: boolean;
+    hoverColumnVisible: boolean;
+    columnsResizable: boolean;
+    columnResizeHandleWidthInPx: number;
+    headerVerticalSeparator: boolean;
+    footerVerticalSeparator: boolean;
+    defaultRowHeights: DefaultRowHeightsIf;
+    headerToggleExpandCollapseIcons: boolean;
+    autoRestoreExpandedStateAfterUpdate: boolean;
+    autoRestoreCheckedStateAfterUpdate: boolean;
+    autoRestoreSelectedStateAfterUpdate: boolean;
+    autoRestoreScrollPositionAfterUpdate: 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/side-ident.type.d.ts

@@ -0,0 +1 @@
+export declare type SideIdent = "west" | "center" | "east";

package/lib/table/data/tablemodel/area-ident.type.d.ts

@@ -0,0 +1,2 @@
+export declare type AreaIdent = "header" | "body" | "footer";
+export declare const getAreaIdentByString: (s: string | null) => AreaIdent;

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

@@ -0,0 +1,43 @@
+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 { TableModelIf } from "../table-model.if";
+export declare abstract class AbstractAreaModel<T> implements AreaModelIf {
+    protected areaIdent: AreaIdent;
+    protected columnDefs: ColumnDefIf[];
+    protected overridingRowHeight: number;
+    rowSelectionModel: CheckboxModelIf<any> | undefined;
+    protected cellRenderers: (CellRendererIf | undefined)[];
+    protected yPositions: number[];
+    constructor(areaIdent: AreaIdent, columnDefs?: ColumnDefIf[], overridingRowHeight?: 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[];
+    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: string, _tableModel: TableModelIf): boolean;
+    isSelectable(rowIndex: number, columnIndex: number): boolean;
+    private calcYPositions;
+    changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void;
+    protected arrayMove(arr: any[], fromIndex: number, toIndex: number): any[];
+}

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

@@ -0,0 +1,18 @@
+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 AreaModelArrayArray<T> extends AbstractAreaModel<T[][]> {
+    protected areaIdent: AreaIdent;
+    readonly arr: T[][];
+    defaultRowHeight: number;
+    protected columnDefs: ColumnDefIf[];
+    filteredArr: T[][];
+    constructor(areaIdent: AreaIdent, arr: T[][], defaultRowHeight?: number, columnDefs?: ColumnDefIf[]);
+    externalFilterChanged<T>(predictFn: FilterFunction<any>): void;
+    getRowCount(): number;
+    getValueAt(rowIndex: number, columnIndex: number): any;
+    getRowByIndex(rowIndex: number): any;
+    getRowHeight(rowIndex: number): number;
+    changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void;
+}

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

@@ -0,0 +1,32 @@
+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";
+export declare class AreaModelHidden implements AreaModelIf {
+    rowSelectionModel: CheckboxModelIf<any> | undefined;
+    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[];
+    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> {
+    protected areaIdent: AreaIdent;
+    protected readonly rows: T[];
+    protected readonly columnDefs: ColumnDefIf[];
+    protected 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,27 @@
+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> {
+    protected areaIdent: AreaIdent;
+    protected readonly rows: T[];
+    protected 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[];
+    getRowHeight(rowIndex: number): number;
+    getRowByIndex(rowIndex: number): any;
+    externalFilterChanged<T>(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>> {
+    protected 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: string): 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.if.d.ts

@@ -0,0 +1,33 @@
+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 { TableModelIf } from "../table-model.if";
+export interface AreaModelIf {
+    changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void;
+    rowSelectionModel: CheckboxModelIf<any> | undefined;
+    setValue(rowIndex: number, columnIndex: number, value: string, tableModel: TableModelIf): boolean;
+    init(): void;
+    getRowCount(): number;
+    getValueAt(rowIndex: number, columnIndex: number): any;
+    getColspanAt(rowIndex: number, columnIndex: number): number;
+    getMaxColspan(): number;
+    getRowspanAt(rowIndex: number, columnIndex: number): number;
+    getMaxRowspan(): number;
+    getCustomClassesAt(rowIndex: number, columnIndex: number): string[];
+    getValueAt(rowIndex: number, columnIndex: number): any;
+    getTooltipAt(rowIndex: number, columnIndex: number): any;
+    getCellRenderer(rowIndex: number, columnIndex: number): CellRendererIf | undefined;
+    getRowHeight(rowIndex: number): number;
+    getRowByIndex(rowIndex: number): any;
+    getYPosByRowIndex(rowIndex: number): number;
+    isEditable(rowIndex: number, columnIndex: number): boolean;
+    isSelectable(rowIndex: number, columnIndex: number): boolean;
+    isRowCheckable(rowIndex: number): boolean;
+    isRowChecked(rowIndex: number): CheckedType | undefined;
+    setRowChecked(rowIndex: number, checked: boolean): void;
+    isFilterable(): boolean;
+    externalFilterChanged<T>(predictFn: FilterFunction<T>): void;
+    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;
+}