@mediusinc/mng-commons 4.2.0 → 5.0.0-rc.0

package/esm2022/table/api/descriptors/table.descriptor.mjs

@@ -0,0 +1,750 @@
+import { CommonsInternalError, DateUtil, ObjectUtil, TypeRegistry } from '@mediusinc/mng-commons/core';
+import { FilterDescriptor, FilterLookupDescriptor, FilterLookupEnumDescriptor, FilterTypeEnum } from '@mediusinc/mng-commons/filter';
+import { ModelDescriptor, ModelUtil, enumModelGeneric } from '@mediusinc/mng-commons/model';
+import { columnToDateNumberOrBoolean, getTableClassAttributeDef } from '../helpers/class-attribute-converter';
+import { ColumnTypeEnum } from '../models/column.model';
+import { TableDynamicColumnsModeEnum, TableSizeEnum } from '../models/table.model';
+import { ColumnDescriptor, ColumnDynamicDescriptor } from './column.descriptor';
+import { SortDescriptor } from './sort.descriptor';
+export class TableDescriptorInst {
+    constructor(model, autoGenerated = false) {
+        this._columns = [];
+        this._hideHeader = false;
+        this._loadingIcon = 'pi pi-spinner';
+        // extra
+        this._hasHover = true;
+        this._hasGridlines = false;
+        this._hasResizableColumns = false;
+        // styling
+        this._size = TableSizeEnum.Large;
+        this._className = '';
+        // filters&sorts
+        this._filters = [];
+        this._sorts = [];
+        // localization
+        this._isLocalized = false;
+        this._model = model;
+        this._trackProperty = this._model.idProperty;
+        this._autoGenerated = autoGenerated;
+    }
+    get identifier() {
+        return this._identifier;
+    }
+    get trackProperty() {
+        return this._trackProperty;
+    }
+    get paginationMode() {
+        return this._paginationMode;
+    }
+    get rowsPerPageOptions() {
+        return this._rowsPerPageOptions;
+    }
+    get defaultNumRows() {
+        return this._defaultNumRows;
+    }
+    get columns() {
+        return this._columns;
+    }
+    get title() {
+        return this._title;
+    }
+    get hideHeader() {
+        return this._hideHeader;
+    }
+    get loadingText() {
+        return this._loadingText;
+    }
+    get loadingIcon() {
+        return this._loadingIcon;
+    }
+    get filters() {
+        return this._filters;
+    }
+    get sorts() {
+        return this._sorts;
+    }
+    get model() {
+        return this._model;
+    }
+    get className() {
+        return this._className;
+    }
+    get size() {
+        return this._size;
+    }
+    get tableFullHeightOffset() {
+        return this._tableFullHeightOffset;
+    }
+    get rowHeight() {
+        return this._rowHeight;
+    }
+    get hasHover() {
+        return this._hasHover;
+    }
+    get hasGridlines() {
+        return this._hasGridlines;
+    }
+    get hasResizableColumns() {
+        return this._hasResizableColumns;
+    }
+    get columnResizeMode() {
+        return this._columnResizeMode;
+    }
+    get rowClassName() {
+        return this._rowClassName;
+    }
+    get rowClassNameMapFn() {
+        return this._rowClassNameMapFn;
+    }
+    get selectionColumnFrozen() {
+        return this._selectionColumnFrozen;
+    }
+    get actionColumnFrozen() {
+        return this._actionColumnFrozen;
+    }
+    get headerClassName() {
+        return this._headerClassName;
+    }
+    get isLocalized() {
+        return this._isLocalized;
+    }
+    get localizationLocaleProperty() {
+        return this._localizationLocaleProperty;
+    }
+    /**
+     * Track property is used for the purpose of combined saving user preferences in localstorage if 2 tables have the same track properties they will share the same localstorage entry.
+     * Similarly, this property can also be used to differentiate two tables of the same model on the same url (so that they have separate entries in localstorage).
+     * @param identifier
+     */
+    withIdentifier(identifier) {
+        this._identifier = identifier;
+        return this;
+    }
+    withTrackProperty(property) {
+        return this.withTrackPropertyUnsafe(property);
+    }
+    withTrackPropertyUnsafe(property) {
+        this._trackProperty = property;
+        return this;
+    }
+    getColumn(property) {
+        return this.getColumnUnsafe(property);
+    }
+    getColumnUnsafe(property) {
+        return this._columns.find(col => col.property === property) ?? null;
+    }
+    removeColumn(property) {
+        this.removeColumnUnsafe(property);
+    }
+    removeColumnUnsafe(property) {
+        const columnIdx = this._columns.findIndex(c => c.property === property);
+        this._columns.splice(columnIdx, 1);
+    }
+    withColumn(column) {
+        this._columns.push(column);
+        return this;
+    }
+    addColumn(property) {
+        const column = new ColumnDescriptor(this, property);
+        this._columns.push(column);
+        return column;
+    }
+    addColumnEnum(property, enumDesc) {
+        const column = new ColumnDescriptor(this, property);
+        column.asEnumUnsafe(enumDesc);
+        this._columns.push(column);
+        return column;
+    }
+    addColumnUnsafe(property) {
+        const column = new ColumnDescriptor(this, property);
+        this._columns.push(column);
+        return column;
+    }
+    withColumns(...properties) {
+        properties.forEach(p => this.addColumn(p));
+        return this;
+    }
+    withPaginationMode(paginationMode) {
+        this._paginationMode = paginationMode;
+        return this;
+    }
+    withRowsPerPage(rows, options) {
+        this._defaultNumRows = rows;
+        this._rowsPerPageOptions = options;
+        return this;
+    }
+    withTitle(title) {
+        this._title = title;
+        return this;
+    }
+    withHideHeader(hideHeader = true) {
+        this._hideHeader = hideHeader;
+        return this;
+    }
+    withLoading(text, icon) {
+        this._loadingText = text;
+        this._loadingIcon = icon === undefined ? 'pi pi-spinner' : icon;
+        return this;
+    }
+    /**
+     * Helper method that enables/disables reorderable property on all columns currently in the descriptor.
+     * @param columnsReorderable
+     */
+    withCurrentColumnsReorderable(columnsReorderable = true) {
+        for (const col of this.columns) {
+            col.withReorderable(columnsReorderable);
+        }
+        return this;
+    }
+    /**
+     * Helper method that enables/disables toggleable property on all columns currently in the descriptor.
+     * @param columnsToggleable
+     */
+    withCurrentColumnsToggleable(columnsToggleable = true) {
+        for (const col of this.columns) {
+            col.withToggleable(columnsToggleable);
+        }
+        return this;
+    }
+    getSort(property) {
+        return this.getSortUnsafe(property);
+    }
+    getSortUnsafe(property) {
+        return this._sorts.find(s => s.property === property) ?? null;
+    }
+    removeSort(property) {
+        return this.removeSortUnsafe(property);
+    }
+    removeSortUnsafe(property) {
+        const sortIdx = this._sorts.findIndex(c => c.property === property);
+        this._sorts.splice(sortIdx, 1);
+    }
+    addSort(property, isDefault = false, ascending) {
+        return this.addSortUnsafe(property, isDefault, ascending);
+    }
+    addSortUnsafe(property, isDefault = false, ascending) {
+        const sort = new SortDescriptor(property);
+        if (isDefault) {
+            const defaultOrderMax = this._sorts
+                .filter(s => s.defaultIsEnabled)
+                .reduce((acc, s) => (s.defaultOrder !== undefined && s.defaultOrder > acc ? s.defaultOrder : acc), -1);
+            sort.withDefaultSort(true, ascending, defaultOrderMax + 1);
+        }
+        this._sorts.push(sort);
+        return sort;
+    }
+    withSort(property, isDefault = false, ascending) {
+        return this.withSortUnsafe(property, isDefault, ascending);
+    }
+    withSortUnsafe(property, isDefault = false, ascending) {
+        this.addSortUnsafe(property, isDefault, ascending);
+        return this;
+    }
+    withDefaultSort(property, ascending, order, enabled) {
+        return this.withDefaultSortUnsafe(property, ascending, order, enabled);
+    }
+    withDefaultSortUnsafe(property, ascending, order, enabled) {
+        let sort = this._sorts.find(s => s.property === property);
+        if (!sort) {
+            sort = new SortDescriptor(property);
+            this._sorts.push(sort);
+        }
+        sort.withDefaultSort(enabled ?? true, ascending, order);
+        return this;
+    }
+    withSorts(...properties) {
+        return this.withSortsUnsafe(...properties);
+    }
+    withSortsUnsafe(...properties) {
+        properties.forEach(p => {
+            this._sorts.push(new SortDescriptor(p));
+        });
+        return this;
+    }
+    getFilter(property) {
+        return this.getFilterUnsafe(property);
+    }
+    getFilterUnsafe(property) {
+        return this._filters.find(s => s.property === property) ?? null;
+    }
+    removeFilter(property) {
+        return this.removeFilterUnsafe(property);
+    }
+    removeFilterUnsafe(property) {
+        const filterIdx = this._filters.findIndex(c => c.property === property);
+        this._filters.splice(filterIdx, 1);
+    }
+    addFilter(property) {
+        return this.addFilterUnsafe(property);
+    }
+    addFilterUnsafe(property) {
+        const filter = new FilterDescriptor(property);
+        this._filters.push(filter);
+        return filter;
+    }
+    addFilterLookup(property, provider, optionsValueProperty) {
+        return this.addFilterLookupUnsafe(property, provider, optionsValueProperty);
+    }
+    addFilterLookupUnsafe(property, provider, optionsValueProperty) {
+        const filter = new FilterLookupDescriptor(property, {
+            dataProvider: provider,
+            optionsValueProperty: optionsValueProperty
+        });
+        this._filters.push(filter);
+        return filter;
+    }
+    addFilterLookupEnum(property, enumDesc, options) {
+        return this.addFilterLookupEnumUnsafe(property, enumDesc, options);
+    }
+    addFilterLookupEnumUnsafe(property, enumDesc, options) {
+        const filter = new FilterLookupEnumDescriptor(property, enumDesc, options);
+        this._filters.push(filter);
+        return filter;
+    }
+    addFilterFromColumn(property, forceSimple = false) {
+        return this.addFilterFromColumnUnsafe(property, forceSimple);
+    }
+    withFiltersFromColumns(...properties) {
+        return this.withFiltersFromColumnsUnsafe(...properties);
+    }
+    withFiltersFromColumnsUnsafe(...properties) {
+        properties.forEach(p => {
+            this.addFilterFromColumnUnsafe(p);
+        });
+        return this;
+    }
+    addFilterFromColumnUnsafe(property, forceSimple = false) {
+        const column = this.getColumnUnsafe(property);
+        if (!column) {
+            throw new CommonsInternalError(`No column found for filter property "${property}"`);
+        }
+        return this.addFilterFromColumnDescriptorUnsafe(column, forceSimple);
+    }
+    addFilterFromColumnDescriptorUnsafe(column, forceSimple) {
+        let filterDescriptor = new FilterDescriptor(column.property);
+        let filterType;
+        switch (column.columnType) {
+            case ColumnTypeEnum.Number:
+                filterType = FilterTypeEnum.Number;
+                break;
+            case ColumnTypeEnum.Boolean:
+                filterType = FilterTypeEnum.Boolean;
+                break;
+            case ColumnTypeEnum.Date:
+                filterType = FilterTypeEnum.Date;
+                break;
+            case ColumnTypeEnum.Enum:
+                if (!forceSimple && column.enum) {
+                    filterDescriptor = new FilterLookupEnumDescriptor(column.property, column.enum);
+                    filterType = FilterTypeEnum.LookupEnum;
+                }
+                else {
+                    filterType = FilterTypeEnum.String;
+                }
+                break;
+            case ColumnTypeEnum.String:
+            case ColumnTypeEnum.Custom:
+            default:
+                filterType = FilterTypeEnum.String;
+                break;
+        }
+        filterDescriptor.asFilterType(filterType);
+        if (filterType === FilterTypeEnum.Number) {
+            const displayFormatFractions = column.displayFormat?.split('.')?.[1]?.split('-');
+            if (displayFormatFractions && displayFormatFractions.length > 2) {
+                filterDescriptor.withNumberFractions(parseInt(displayFormatFractions[0]), parseInt(displayFormatFractions[1]));
+            }
+        }
+        else if (filterType === FilterTypeEnum.Date) {
+            const displayFormat = column.displayFormat;
+            if (displayFormat) {
+                const filterDisplayFormat = DateUtil.fromAngularToPrimeDateFormat(displayFormat);
+                const hasTime = DateUtil.fromAngularDateFormatHasTime(displayFormat);
+                const hasSeconds = DateUtil.fromAngularDateFormatHasSeconds(displayFormat);
+                filterDescriptor.withDateFormat(filterDisplayFormat, hasTime, hasSeconds);
+            }
+        }
+        this._filters.push(filterDescriptor);
+        return filterDescriptor;
+    }
+    withFilter(property, filter) {
+        if (filter.property !== property) {
+            throw new CommonsInternalError(`Filter property "${property}" and Filter descriptor property "${filter.property}" do not match.`);
+        }
+        return this.withFilterUnsafe(filter);
+    }
+    withFilterUnsafe(filter) {
+        this._filters.push(filter);
+        return this;
+    }
+    withClassName(className) {
+        this._className = className;
+        return this;
+    }
+    withSize(size = TableSizeEnum.Normal) {
+        this._size = size;
+        return this;
+    }
+    withTableFullHeightOffset(tableFullHeightOffset) {
+        this._tableFullHeightOffset = tableFullHeightOffset;
+        return this;
+    }
+    withRowHeight(rowHeight) {
+        this._rowHeight = rowHeight;
+        return this;
+    }
+    withHover(hover) {
+        this._hasHover = hover;
+        return this;
+    }
+    withGridlines(gridlines) {
+        this._hasGridlines = gridlines;
+        return this;
+    }
+    /**
+     * Method that enables/disabled column resize feature with columnResizeMode on all columns.
+     * @param resizableColumns True if enabled
+     * @param columnResizeMode 'fit' or 'expand' mode
+     */
+    withColumnsResizable(resizableColumns = true, columnResizeMode = 'fit') {
+        this._hasResizableColumns = resizableColumns;
+        this._columnResizeMode = columnResizeMode;
+        return this;
+    }
+    /**
+     * Sets column to (un)frozen.
+     * @param selectionColumnFrozen True to freeze selection column, false to unfreeze it.
+     * @param actionColumnFrozen True to freeze action column, false to unfreeze it.
+     */
+    withColumnFrozen(selectionColumnFrozen, actionColumnFrozen) {
+        this._selectionColumnFrozen = selectionColumnFrozen;
+        this._actionColumnFrozen = actionColumnFrozen;
+        return this;
+    }
+    withRowClassName(rowClassName, classNameMapFn) {
+        this._rowClassName = rowClassName;
+        this._rowClassNameMapFn = classNameMapFn;
+        return this;
+    }
+    withHeaderClassName(headerClassName) {
+        this._headerClassName = headerClassName;
+        return this;
+    }
+    withLocalized() {
+        this._isLocalized = true;
+        return this;
+    }
+    withLocalizationLocaleProperty(localizationLocaleProperty) {
+        this._isLocalized = true;
+        this._localizationLocaleProperty = localizationLocaleProperty;
+        return this;
+    }
+    copyFieldsTo(obj) {
+        obj._title = this._title;
+        obj._hideHeader = this._hideHeader;
+        obj._trackProperty = this._trackProperty;
+        obj._filters = this._filters.map(f => f.copy());
+        obj._sorts = this._sorts.map(s => s.copy());
+        obj._className = this._className;
+        obj._size = this._size;
+        obj._tableFullHeightOffset = this._tableFullHeightOffset;
+        obj._rowHeight = this._rowHeight;
+        obj._hasHover = this._hasHover;
+        obj._hasGridlines = this._hasGridlines;
+        obj._hasResizableColumns = this._hasResizableColumns;
+        obj._columnResizeMode = this._columnResizeMode;
+        obj._actionColumnFrozen = this._actionColumnFrozen;
+        obj._selectionColumnFrozen = this._selectionColumnFrozen;
+        obj._isLocalized = this._isLocalized;
+        obj._localizationLocaleProperty = this._localizationLocaleProperty;
+        obj._paginationMode = this._paginationMode;
+        obj._rowsPerPageOptions = this._rowsPerPageOptions;
+    }
+    copy() {
+        const descriptor = new TableDescriptorInst(this.model.copy());
+        this.copyFieldsTo(descriptor);
+        descriptor._columns = this.columns.map(c => c.copy());
+        return descriptor;
+    }
+    /**
+     * defines modified type of column
+     * DO NOT USE with enum (use withCustomEnumType)
+     * @param property column name
+     * @param columnType modified type
+     * @param args additional attributes
+     * @param columnDisplayType
+     */
+    withColumnModifiedType(property, columnType, columnDisplayType, ...args) {
+        return this.withColumnModifiedTypeUnsafe(property, columnType, columnDisplayType, ...args);
+    }
+    withColumnModifiedTypeUnsafe(property, columnType, columnDisplayType, ...args) {
+        if (!this.model.type) {
+            throw new CommonsInternalError(`withColumnModifiedType cannot be executed for property ${property}: Model type is not defined.`);
+        }
+        const attributeDef = getTableClassAttributeDef(this.model.type).find(attr => attr.name === property);
+        if (attributeDef != null) {
+            attributeDef.columnType = columnType ?? attributeDef.columnType;
+            attributeDef.columnDisplayType = columnDisplayType ?? attributeDef.columnDisplayType;
+            TableDescriptorInst.upsertColumnFromAttributeDef(this, attributeDef, this.columns.find(col => col.property === attributeDef.name), ...args);
+        }
+        return this;
+    }
+    /**
+     * defines custom enum type for column
+     * @param property column name
+     * @param enumDesc Enum descriptor.
+     */
+    withColumnModifiedEnum(property, enumDesc) {
+        return this.withColumnModifiedEnumUnsafe(property, enumDesc);
+    }
+    withColumnModifiedEnumUnsafe(property, enumDesc) {
+        if (!this.model.type) {
+            throw new CommonsInternalError(`withColumnModifiedEnum cannot be executed for property ${property}: Model type is not defined.`);
+        }
+        const attributeDef = getTableClassAttributeDef(this.model.type).find(attr => attr.name === property);
+        if (attributeDef != null) {
+            attributeDef.columnType = ColumnTypeEnum.Enum;
+            TableDescriptorInst.upsertColumnFromAttributeDef(this, attributeDef, this.columns.find(col => col.property === property), enumDesc ?? enumModelGeneric(TypeRegistry.get().findEnum(attributeDef.type)));
+        }
+        return this;
+    }
+    /**
+     * modifies column with class and lookup provider
+     * @param property column name
+     * @param lookupProvider lookupProvider for class
+     * @param optionsLabelProperty
+     * @param filterProperty
+     */
+    withModifiedLookup(property, lookupProvider, optionsLabelProperty, filterProperty) {
+        return this.withColumnModifiedLookupUnsafe(property, lookupProvider, optionsLabelProperty, filterProperty);
+    }
+    withColumnModifiedLookupUnsafe(property, lookupProvider, optionsLabelProperty, filterProperty) {
+        const column = this.columns.find(col => col.property === property);
+        if (column) {
+            const filter = this.addFilterLookupUnsafe(column.property, lookupProvider, filterProperty);
+            if (optionsLabelProperty) {
+                filter.withOptionsLabelPropertyUnsafe(optionsLabelProperty);
+            }
+        }
+        return this;
+    }
+    /**
+     * generates column based on attributes
+     * @param desc Table descriptor
+     * @param attribute attribute map
+     * @param column if provided, replaced by new, otherwise new is created
+     * @param args additional parameters
+     */
+    static upsertColumnFromAttributeDef(desc, attribute, column, ...args) {
+        if (column == null) {
+            column = desc.addColumnUnsafe(attribute.name);
+        }
+        if (attribute.columnType === ColumnTypeEnum.Enum && args.length === 0 && attribute.enumType) {
+            args = [enumModelGeneric(attribute.enumType)];
+        }
+        column = column.asType(attribute.columnType, attribute.columnDisplayType, ...args);
+        if (attribute.classType) {
+            const titleProperty = ModelUtil.findTitleAttribute(attribute.classType) ?? undefined;
+            if (titleProperty) {
+                column.withGetter(value => value?.[titleProperty]);
+            }
+        }
+        else {
+            column.withSortUnsafe().withFilterUnsafe();
+        }
+        return column;
+    }
+}
+export class TableDescriptor extends TableDescriptorInst {
+    constructor() {
+        super(ModelDescriptor.create());
+    }
+    static create(idProperty, titleProperty, i18nBaseKey) {
+        return new TableDescriptorInst(ModelDescriptor.create(idProperty, titleProperty, i18nBaseKey));
+    }
+    static fromClass(type, idProperty, titleProperty, i18nBaseKey, isAutoGenerated = false) {
+        return new TableDescriptorInst(ModelDescriptor.fromClass(type, idProperty, titleProperty, i18nBaseKey), isAutoGenerated);
+    }
+    static fromModel(model) {
+        return new TableDescriptorInst(model);
+    }
+    /**
+     * generates descriptor based on type attribute definition
+     * @param type class type
+     * @param idProperty
+     * @param titleProperty
+     */
+    static fromClassWithAutoAttrsDef(type, idProperty, titleProperty) {
+        return TableDescriptor.fromClassWithCustomAttrsDef(type, getTableClassAttributeDef(type), idProperty, titleProperty);
+    }
+    /**
+     * generates descriptor base on given attribute definition
+     * @param type class type
+     * @param attributes attributes from which descriptor is generated
+     * @param idProperty
+     * @param titleProperty
+     */
+    static fromClassWithCustomAttrsDef(type, attributes, idProperty, titleProperty) {
+        const descriptor = TableDescriptor.fromClass(type, idProperty, titleProperty, undefined, true);
+        attributes.filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array')).forEach(attr => TableDescriptorInst.upsertColumnFromAttributeDef(descriptor, attr));
+        return descriptor;
+    }
+}
+export class TableDynamicDescriptorInst extends TableDescriptorInst {
+    constructor(model) {
+        super(model);
+        this._excludedColumns = [];
+        this._filterColumns = [];
+        this._sortColumns = [];
+        this._sortColumnMode = TableDynamicColumnsModeEnum.EXCLUDE;
+        this._filterColumnMode = TableDynamicColumnsModeEnum.EXCLUDE;
+        this._columns = [];
+        if (model.titleProperty) {
+            this.withTitle(model.titleProperty);
+        }
+    }
+    get columns() {
+        return this._columns;
+    }
+    /**
+     * defines excluded columns when generating descriptor
+     * @param excludedColumn names of excluded columns
+     */
+    withColumnsExcluded(excludedColumn) {
+        this._excludedColumns = excludedColumn;
+        return this;
+    }
+    /**
+     * defines column properties on which sort is defined or not depending on sortColumnMode
+     * @param sortOnColumns column names
+     * @param sortColumnMode INCLUDE_ONLY (default) only given columns will have sort, EXCLUDE given columns will NOT have sort
+     */
+    withColumnsSort(sortOnColumns, sortColumnMode = TableDynamicColumnsModeEnum.INCLUDE_ONLY) {
+        this._sortColumnMode = sortColumnMode;
+        this._sortColumns = sortOnColumns;
+        return this;
+    }
+    /**
+     * defines column properties on which filter is defined or not depending on filterColumnMode
+     * @param filterOnColumn column names
+     * @param filterColumnMode INCLUDE_ONLY (default) only given columns will have filter, EXCLUDE given columns will NOT have filter
+     */
+    withColumnsFilter(filterOnColumn, filterColumnMode = TableDynamicColumnsModeEnum.INCLUDE_ONLY) {
+        this._filterColumnMode = filterColumnMode;
+        this._filterColumns = filterOnColumn;
+        return this;
+    }
+    /**
+     * sets given type to column with given property and returns this table
+     * @param property column's property
+     * @param type custom type for column
+     * @param displayType custom column value display type
+     * @param args addition arguments for column
+     */
+    withColumnModifiedType(property, type, displayType, ...args) {
+        const column = this._columns.find(col => property === col.property) ?? this.addColumn(property).withTitle(property);
+        if (column) {
+            column.asType(type, displayType, ...args);
+        }
+        return this;
+    }
+    /**
+     * sets title to column with given property and returns this table
+     * @param property column's property
+     * @param title column's title
+     */
+    withColumnTitle(property, title) {
+        const column = this._columns.find(col => property === col.property) ?? this.addColumn(property);
+        column.withTitle(title, true);
+        return this;
+    }
+    /**
+     * generates columns defined on table based on data fetched from api
+     * @param data data from api
+     */
+    toTableDescriptorFromData(data) {
+        const tableDescriptor = this.toTableDescriptor();
+        if (data.data == null || data.data.length == 0) {
+            return tableDescriptor;
+        }
+        const objectModel = data.data[0];
+        const entries = ObjectUtil.flattenObjectKeys(objectModel)
+            .filter(([key]) => !this._excludedColumns.includes(key))
+            .filter(([, value]) => !Array.isArray(value)); //exclude arrays and sets
+        for (const [key, value] of entries) {
+            const metaColumn = this._columns.find(col => col.property === key);
+            let column;
+            if (metaColumn) {
+                if (!metaColumn.visibility) {
+                    continue;
+                }
+                column = metaColumn.toColumnDescriptor(tableDescriptor);
+                tableDescriptor.withColumn(column);
+            }
+            else {
+                column = tableDescriptor.addColumn(key).withTitle(key);
+                columnToDateNumberOrBoolean(column, value);
+            }
+            if (this.model.i18nBaseKey && !column.property.includes('rev')) {
+                column.withTitle([this.model.i18nBaseKey, 'properties', column.property].join('.').replace('state.', ''));
+            }
+            const elementOfSortColumns = this._sortColumns.includes(column.property);
+            if ((this._sortColumnMode === TableDynamicColumnsModeEnum.EXCLUDE && !elementOfSortColumns) ||
+                (this._sortColumnMode === TableDynamicColumnsModeEnum.INCLUDE_ONLY && elementOfSortColumns)) {
+                column.withSortUnsafe();
+            }
+            const elementOfFilterColumns = this._filterColumns.includes(column.property);
+            if (this._filterColumns.length > 0 &&
+                ((this._filterColumnMode === TableDynamicColumnsModeEnum.EXCLUDE && !elementOfFilterColumns) ||
+                    (this._filterColumnMode === TableDynamicColumnsModeEnum.INCLUDE_ONLY && elementOfFilterColumns))) {
+                column.withFilterUnsafe();
+            }
+        }
+        return tableDescriptor;
+    }
+    /**
+     * adds ColumnDynamicDescriptor to this table
+     * @param property column's property
+     */
+    addColumn(property) {
+        const column = new ColumnDynamicDescriptor(this, property);
+        this._columns.push(column);
+        return column;
+    }
+    removeColumn(property) {
+        const column = this.columns.find(col => col.property === property) ?? this.addColumn(property);
+        column.withVisibility(false);
+        return this;
+    }
+    /**
+     * creates deep copy of table dynamic descriptor
+     */
+    copy() {
+        const descriptor = new TableDynamicDescriptorInst(this.model.copy());
+        this.copyFieldsTo(descriptor);
+        descriptor._columns = this.columns.map(c => c.copy());
+        descriptor._excludedColumns = [...this._excludedColumns];
+        descriptor._filterColumns = [...this._filterColumns];
+        descriptor._sortColumns = [...this._sortColumns];
+        descriptor._filterColumnMode = this._filterColumnMode;
+        descriptor._sortColumnMode = this._sortColumnMode;
+        return descriptor;
+    }
+    toTableDescriptor() {
+        const descriptor = new TableDescriptorInst(this.model);
+        this.copyFieldsTo(descriptor);
+        return descriptor;
+    }
+}
+export class TableDynamicDescriptor extends TableDynamicDescriptorInst {
+    constructor() {
+        super(ModelDescriptor.create());
+    }
+    static create(idProperty, titleProperty, i18nBaseKey) {
+        return new TableDynamicDescriptorInst(ModelDescriptor.create(idProperty, titleProperty, i18nBaseKey));
+    }
+    static fromModel(model) {
+        return new TableDynamicDescriptorInst(model);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.descriptor.js","sourceRoot":"","sources":["../../../../../table/api/src/descriptors/table.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,oBAAoB,EAAkB,QAAQ,EAAmD,UAAU,EAAE,YAAY,EAAC,MAAM,6BAA6B,CAAC;AACjL,OAAO,EAAC,gBAAgB,EAAE,sBAAsB,EAAE,0BAA0B,EAAE,cAAc,EAAC,MAAM,+BAA+B,CAAC;AACnI,OAAO,EAAiB,eAAe,EAAE,SAAS,EAAE,gBAAgB,EAAC,MAAM,8BAA8B,CAAC;AAE1G,OAAO,EAAC,2BAA2B,EAAE,yBAAyB,EAAC,MAAM,sCAAsC,CAAC;AAE5G,OAAO,EAAwB,cAAc,EAAC,MAAM,wBAAwB,CAAC;AAE7E,OAAO,EAA2B,2BAA2B,EAA2B,aAAa,EAAC,MAAM,uBAAuB,CAAC;AACpI,OAAO,EAAC,gBAAgB,EAAE,uBAAuB,EAAC,MAAM,qBAAqB,CAAC;AAC9E,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAEjD,MAAM,OAAO,mBAAmB;IA4C5B,YAAsB,KAAkC,EAAE,aAAa,GAAG,KAAK;QAjCrE,aAAQ,GAA6C,EAAE,CAAC;QAE1D,gBAAW,GAAG,KAAK,CAAC;QAEpB,iBAAY,GAAkB,eAAe,CAAC;QAEtD,QAAQ;QACA,cAAS,GAAG,IAAI,CAAC;QACjB,kBAAa,GAAG,KAAK,CAAC;QACtB,yBAAoB,GAAG,KAAK,CAAC;QAOrC,UAAU;QACF,UAAK,GAAkB,aAAa,CAAC,KAAK,CAAC;QAC3C,eAAU,GAAG,EAAE,CAAC;QAOxB,gBAAgB;QACR,aAAQ,GAAwC,EAAE,CAAC;QACnD,WAAM,GAAiC,EAAE,CAAC;QAElD,eAAe;QACP,iBAAY,GAAG,KAAK,CAAC;QAIzB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;QAC7C,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC;IACxC,CAAC;IAED,IAAW,UAAU;QACjB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAED,IAAW,aAAa;QACpB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC/B,CAAC;IAED,IAAW,cAAc;QACrB,OAAO,IAAI,CAAC,eAAe,CAAC;IAChC,CAAC;IAED,IAAI,kBAAkB;QAClB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IACpC,CAAC;IAED,IAAI,cAAc;QACd,OAAO,IAAI,CAAC,eAAe,CAAC;IAChC,CAAC;IAED,IAAW,OAAO;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED,IAAW,KAAK;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,IAAW,UAAU;QACjB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAED,IAAW,WAAW;QAClB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAED,IAAW,WAAW;QAClB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAED,IAAW,OAAO;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED,IAAW,KAAK;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,IAAW,KAAK;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,IAAW,IAAI;QACX,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAED,IAAW,qBAAqB;QAC5B,OAAO,IAAI,CAAC,sBAAsB,CAAC;IACvC,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,IAAW,QAAQ;QACf,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED,IAAW,YAAY;QACnB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IAED,IAAW,mBAAmB;QAC1B,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACrC,CAAC;IAED,IAAW,gBAAgB;QACvB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAClC,CAAC;IAED,IAAW,YAAY;QACnB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IAED,IAAW,iBAAiB;QACxB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACnC,CAAC;IAED,IAAW,qBAAqB;QAC5B,OAAO,IAAI,CAAC,sBAAsB,CAAC;IACvC,CAAC;IAED,IAAW,kBAAkB;QACzB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IACpC,CAAC;IAED,IAAW,eAAe;QACtB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IACjC,CAAC;IAED,IAAW,WAAW;QAClB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAED,IAAW,0BAA0B;QACjC,OAAO,IAAI,CAAC,2BAA2B,CAAC;IAC5C,CAAC;IAED;;;;OAIG;IACI,cAAc,CAAC,UAAkB;QACpC,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;QAC9B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,iBAAiB,CAAC,QAA2B;QAChD,OAAO,IAAI,CAAC,uBAAuB,CAAC,QAAkB,CAAC,CAAC;IAC5D,CAAC;IAEM,uBAAuB,CAAC,QAAiB;QAC5C,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC;QAC/B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,SAAS,CAAC,QAA0B;QACvC,OAAO,IAAI,CAAC,eAAe,CAAC,QAAkB,CAAC,CAAC;IACpD,CAAC;IAEM,eAAe,CAAC,QAAgB;QACnC,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC,IAAI,IAAI,CAAC;IACxE,CAAC;IAEM,YAAY,CAAC,QAA0B;QAC1C,IAAI,CAAC,kBAAkB,CAAC,QAAkB,CAAC,CAAC;IAChD,CAAC;IAEM,kBAAkB,CAAC,QAAgB;QACtC,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;QACxE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;IACvC,CAAC;IAEM,UAAU,CAAyC,MAA8D;QACpH,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,SAAS,CAAuC,QAAqB;QACxE,MAAM,MAAM,GAAG,IAAI,gBAAgB,CAA4E,IAAI,EAAE,QAAkB,CAAC,CAAC;QACzI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3B,OAAO,MAAM,CAAC;IAClB,CAAC;IAEM,aAAa,CAA0F,QAAqB,EAAE,QAA8B;QAC/J,MAAM,MAAM,GAAG,IAAI,gBAAgB,CAA4C,IAAI,EAAE,QAAkB,CAAC,CAAC;QACzG,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAC9B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3B,OAAO,MAAM,CAAC;IAClB,CAAC;IAEM,eAAe,CAAwB,QAAgB;QAC1D,MAAM,MAAM,GAAG,IAAI,gBAAgB,CAA0B,IAAI,EAAE,QAAQ,CAAC,CAAC;QAC7E,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3B,OAAO,MAAM,CAAC;IAClB,CAAC;IAEM,WAAW,CAAC,GAAG,UAAgC;QAClD,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3C,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,kBAAkB,CAAC,cAAuC;QAC7D,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC;QACtC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,eAAe,CAAC,IAAY,EAAE,OAAuB;QACxD,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,mBAAmB,GAAG,OAAO,CAAC;QACnC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,SAAS,CAAC,KAAa;QAC1B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QAEpB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,cAAc,CAAC,UAAU,GAAG,IAAI;QACnC,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;QAC9B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,WAAW,CAAC,IAAa,EAAE,IAAoB;QAClD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,YAAY,GAAG,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC;QAChE,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;OAGG;IACI,6BAA6B,CAAC,kBAAkB,GAAG,IAAI;QAC1D,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,OAAO,EAAE;YAC5B,GAAG,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC;SAC3C;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;OAGG;IACI,4BAA4B,CAAC,iBAAiB,GAAG,IAAI;QACxD,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,OAAO,EAAE;YAC5B,GAAG,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;SACzC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,OAAO,CAAC,QAAe;QAC1B,OAAO,IAAI,CAAC,aAAa,CAAC,QAAkB,CAAC,CAAC;IAClD,CAAC;IAEM,aAAa,CAAC,QAAgB;QACjC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,IAAI,IAAI,CAAC;IAClE,CAAC;IAEM,UAAU,CAAC,QAAe;QAC7B,OAAO,IAAI,CAAC,gBAAgB,CAAC,QAAkB,CAAC,CAAC;IACrD,CAAC;IAEM,gBAAgB,CAAC,QAAgB;QACpC,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;QACpE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACnC,CAAC;IAEM,OAAO,CAAC,QAAe,EAAE,SAAS,GAAG,KAAK,EAAE,SAAmB;QAClE,OAAO,IAAI,CAAC,aAAa,CAAC,QAAkB,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;IACxE,CAAC;IAEM,aAAa,CAAC,QAAgB,EAAE,SAAS,GAAG,KAAK,EAAE,SAAmB;QACzE,MAAM,IAAI,GAAG,IAAI,cAAc,CAAa,QAAQ,CAAC,CAAC;QACtD,IAAI,SAAS,EAAE;YACX,MAAM,eAAe,GAAG,IAAI,CAAC,MAAM;iBAC9B,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC;iBAC/B,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,KAAK,SAAS,IAAI,CAAC,CAAC,YAAY,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC3G,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,eAAe,GAAG,CAAC,CAAC,CAAC;SAC9D;QACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,QAAQ,CAAC,QAAe,EAAE,SAAS,GAAG,KAAK,EAAE,SAAmB;QACnE,OAAO,IAAI,CAAC,cAAc,CAAC,QAAkB,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;IACzE,CAAC;IAEM,cAAc,CAAC,QAAgB,EAAE,SAAS,GAAG,KAAK,EAAE,SAAmB;QAC1E,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QACnD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,eAAe,CAAC,QAAe,EAAE,SAAmB,EAAE,KAAc,EAAE,OAAiB;QAC1F,OAAO,IAAI,CAAC,qBAAqB,CAAC,QAAkB,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IACrF,CAAC;IAEM,qBAAqB,CAAC,QAAgB,EAAE,SAAmB,EAAE,KAAc,EAAE,OAAiB;QACjG,IAAI,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;QAC1D,IAAI,CAAC,IAAI,EAAE;YACP,IAAI,GAAG,IAAI,cAAc,CAAC,QAAQ,CAAC,CAAC;YACpC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC1B;QACD,IAAI,CAAC,eAAe,CAAC,OAAO,IAAI,IAAI,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QACxD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,SAAS,CAAC,GAAG,UAAmB;QACnC,OAAO,IAAI,CAAC,eAAe,CAAC,GAAI,UAAuB,CAAC,CAAC;IAC7D,CAAC;IAEM,eAAe,CAAC,GAAG,UAAoB;QAC1C,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;YACnB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,SAAS,CAAC,QAAiB;QAC9B,OAAO,IAAI,CAAC,eAAe,CAAC,QAAkB,CAAC,CAAC;IACpD,CAAC;IAEM,eAAe,CAAC,QAAgB;QACnC,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,IAAI,IAAI,CAAC;IACpE,CAAC;IAEM,YAAY,CAAC,QAAiB;QACjC,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAkB,CAAC,CAAC;IACvD,CAAC;IAEM,kBAAkB,CAAC,QAAgB;QACtC,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;QACxE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;IACvC,CAAC;IAEM,SAAS,CAA+E,QAAiB;QAC5G,OAAO,IAAI,CAAC,eAAe,CAAc,QAAkB,CAAC,CAAC;IACjE,CAAC;IAEM,eAAe,CAAc,QAAgB;QAChD,MAAM,MAAM,GAAG,IAAI,gBAAgB,CAA0B,QAAQ,CAAC,CAAC;QACvE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3B,OAAO,MAAM,CAAC;IAClB,CAAC;IAEM,eAAe,CAClB,QAAiB,EACjB,QAAoD,EACpD,oBAAwC;QAExC,OAAO,IAAI,CAAC,qBAAqB,CAAC,QAAkB,EAAE,QAAQ,EAAE,oBAA8B,CAAC,CAAC;IACpG,CAAC;IAEM,qBAAqB,CAAmC,QAAgB,EAAE,QAAoD,EAAE,oBAA6B;QAChK,MAAM,MAAM,GAAG,IAAI,sBAAsB,CAAmC,QAAQ,EAAE;YAClF,YAAY,EAAE,QAAQ;YACtB,oBAAoB,EAAE,oBAAoB;SAC7C,CAAC,CAAC;QACH,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3B,OAAO,MAAM,CAAC;IAClB,CAAC;IAEM,mBAAmB,CAAO,QAAiB,EAAE,QAA8B,EAAE,OAAqB;QACrG,OAAO,IAAI,CAAC,yBAAyB,CAAO,QAAkB,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IACvF,CAAC;IAEM,yBAAyB,CAA0B,QAAgB,EAAE,QAA8B,EAAE,OAAqB;QAC7H,MAAM,MAAM,GAAG,IAAI,0BAA0B,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QAC3E,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3B,OAAO,MAAM,CAAC;IAClB,CAAC;IAEM,mBAAmB,CAAC,QAA4C,EAAE,WAAW,GAAG,KAAK;QACxF,OAAO,IAAI,CAAC,yBAAyB,CAAC,QAAkB,EAAE,WAAW,CAAC,CAAC;IAC3E,CAAC;IAEM,sBAAsB,CAAC,GAAG,UAAgD;QAC7E,OAAO,IAAI,CAAC,4BAA4B,CAAC,GAAI,UAAuB,CAAC,CAAC;IAC1E,CAAC;IAEM,4BAA4B,CAAC,GAAG,UAAoB;QACvD,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;YACnB,IAAI,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,yBAAyB,CAAC,QAAgB,EAAE,WAAW,GAAG,KAAK;QAClE,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAI,CAAC,MAAM,EAAE;YACT,MAAM,IAAI,oBAAoB,CAAC,wCAAwC,QAAQ,GAAG,CAAC,CAAC;SACvF;QACD,OAAO,IAAI,CAAC,mCAAmC,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACzE,CAAC;IAEM,mCAAmC,CACtC,MAA8D,EAC9D,WAAoB;QAEpB,IAAI,gBAAgB,GAAG,IAAI,gBAAgB,CAAkB,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC9E,IAAI,UAA0B,CAAC;QAE/B,QAAQ,MAAM,CAAC,UAAU,EAAE;YACvB,KAAK,cAAc,CAAC,MAAM;gBACtB,UAAU,GAAG,cAAc,CAAC,MAAM,CAAC;gBACnC,MAAM;YACV,KAAK,cAAc,CAAC,OAAO;gBACvB,UAAU,GAAG,cAAc,CAAC,OAAO,CAAC;gBACpC,MAAM;YACV,KAAK,cAAc,CAAC,IAAI;gBACpB,UAAU,GAAG,cAAc,CAAC,IAAI,CAAC;gBACjC,MAAM;YACV,KAAK,cAAc,CAAC,IAAI;gBACpB,IAAI,CAAC,WAAW,IAAI,MAAM,CAAC,IAAI,EAAE;oBAC7B,gBAAgB,GAAG,IAAI,0BAA0B,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;oBAChF,UAAU,GAAG,cAAc,CAAC,UAAU,CAAC;iBAC1C;qBAAM;oBACH,UAAU,GAAG,cAAc,CAAC,MAAM,CAAC;iBACtC;gBACD,MAAM;YACV,KAAK,cAAc,CAAC,MAAM,CAAC;YAC3B,KAAK,cAAc,CAAC,MAAM,CAAC;YAC3B;gBACI,UAAU,GAAG,cAAc,CAAC,MAAM,CAAC;gBACnC,MAAM;SACb;QAED,gBAAgB,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QAC1C,IAAI,UAAU,KAAK,cAAc,CAAC,MAAM,EAAE;YACtC,MAAM,sBAAsB,GAAG,MAAM,CAAC,aAAa,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;YACjF,IAAI,sBAAsB,IAAI,sBAAsB,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC7D,gBAAgB,CAAC,mBAAmB,CAAC,QAAQ,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;aAClH;SACJ;aAAM,IAAI,UAAU,KAAK,cAAc,CAAC,IAAI,EAAE;YAC3C,MAAM,aAAa,GAAG,MAAM,CAAC,aAAa,CAAC;YAC3C,IAAI,aAAa,EAAE;gBACf,MAAM,mBAAmB,GAAG,QAAQ,CAAC,4BAA4B,CAAC,aAAa,CAAC,CAAC;gBACjF,MAAM,OAAO,GAAG,QAAQ,CAAC,4BAA4B,CAAC,aAAa,CAAC,CAAC;gBACrE,MAAM,UAAU,GAAG,QAAQ,CAAC,+BAA+B,CAAC,aAAa,CAAC,CAAC;gBAC3E,gBAAgB,CAAC,cAAc,CAAC,mBAAmB,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;aAC7E;SACJ;QAED,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAErC,OAAO,gBAAgB,CAAC;IAC5B,CAAC;IAEM,UAAU,CAAc,QAAiB,EAAE,MAAiD;QAC/F,IAAI,MAAM,CAAC,QAAQ,KAAK,QAAQ,EAAE;YAC9B,MAAM,IAAI,oBAAoB,CAAC,oBAAoB,QAAQ,qCAAqC,MAAM,CAAC,QAAQ,iBAAiB,CAAC,CAAC;SACrI;QACD,OAAO,IAAI,CAAC,gBAAgB,CAAc,MAAM,CAAC,CAAC;IACtD,CAAC;IAEM,gBAAgB,CAAc,MAAiD;QAClF,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,aAAa,CAAC,SAAiB;QAClC,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,QAAQ,CAAC,OAAsB,aAAa,CAAC,MAAM;QACtD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,yBAAyB,CAAC,qBAA6B;QAC1D,IAAI,CAAC,sBAAsB,GAAG,qBAAqB,CAAC;QACpD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,aAAa,CAAC,SAAiB;QAClC,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,SAAS,CAAC,KAAc;QAC3B,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,aAAa,CAAC,SAAkB;QACnC,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;QAC/B,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACI,oBAAoB,CAAC,gBAAgB,GAAG,IAAI,EAAE,mBAAqC,KAAK;QAC3F,IAAI,CAAC,oBAAoB,GAAG,gBAAgB,CAAC;QAC7C,IAAI,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;QAC1C,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACI,gBAAgB,CAAC,qBAA+B,EAAE,kBAA4B;QACjF,IAAI,CAAC,sBAAsB,GAAG,qBAAqB,CAAC;QACpD,IAAI,CAAC,mBAAmB,GAAG,kBAAkB,CAAC;QAC9C,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,gBAAgB,CAAC,YAAqB,EAAE,cAAkE;QAC7G,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;QAClC,IAAI,CAAC,kBAAkB,GAAG,cAAc,CAAC;QACzC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,mBAAmB,CAAC,eAAuB;QAC9C,IAAI,CAAC,gBAAgB,GAAG,eAAe,CAAC;QACxC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,aAAa;QAChB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,8BAA8B,CAAC,0BAAkC;QACpE,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,2BAA2B,GAAG,0BAA0B,CAAC;QAC9D,OAAO,IAAI,CAAC;IAChB,CAAC;IAES,YAAY,CAAC,GAAuC;QAC1D,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACzB,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACnC,GAAG,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;QACzC,GAAG,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAChD,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAC5C,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACjC,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACvB,GAAG,CAAC,sBAAsB,GAAG,IAAI,CAAC,sBAAsB,CAAC;QACzD,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACjC,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAC/B,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QACvC,GAAG,CAAC,oBAAoB,GAAG,IAAI,CAAC,oBAAoB,CAAC;QACrD,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC;QAC/C,GAAG,CAAC,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC;QACnD,GAAG,CAAC,sBAAsB,GAAG,IAAI,CAAC,sBAAsB,CAAC;QACzD,GAAG,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;QACrC,GAAG,CAAC,2BAA2B,GAAG,IAAI,CAAC,2BAA2B,CAAC;QACnE,GAAG,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;QAC3C,GAAG,CAAC,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC;IACvD,CAAC;IAEM,IAAI;QACP,MAAM,UAAU,GAAG,IAAI,mBAAmB,CAA6B,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;QAC1F,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QAC9B,UAAU,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QACtD,OAAO,UAAU,CAAC;IACtB,CAAC;IAED;;;;;;;OAOG;IACI,sBAAsB,CAAC,QAA0B,EAAE,UAA2B,EAAE,iBAAyC,EAAE,GAAG,IAAW;QAC5I,OAAO,IAAI,CAAC,4BAA4B,CAAC,QAAkB,EAAE,UAAU,EAAE,iBAAiB,EAAE,GAAG,IAAI,CAAC,CAAC;IACzG,CAAC;IAEM,4BAA4B,CAAC,QAAgB,EAAE,UAA2B,EAAE,iBAAyC,EAAE,GAAG,IAAW;QACxI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE;YAClB,MAAM,IAAI,oBAAoB,CAAC,0DAA0D,QAAQ,8BAA8B,CAAC,CAAC;SACpI;QAED,MAAM,YAAY,GAAG,yBAAyB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;QAErG,IAAI,YAAY,IAAI,IAAI,EAAE;YACtB,YAAY,CAAC,UAAU,GAAG,UAAU,IAAI,YAAY,CAAC,UAAU,CAAC;YAChE,YAAY,CAAC,iBAAiB,GAAG,iBAAiB,IAAI,YAAY,CAAC,iBAAiB,CAAC;YACrF,mBAAmB,CAAC,4BAA4B,CAC5C,IAAI,EACJ,YAAY,EACZ,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,CAAC,IAAI,CAAC,EAC5D,GAAG,IAAI,CACV,CAAC;SACL;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACI,sBAAsB,CACzB,QAA0B,EAC1B,QAA+B;QAE/B,OAAO,IAAI,CAAC,4BAA4B,CAAC,QAAkB,EAAE,QAAQ,CAAC,CAAC;IAC3E,CAAC;IAEM,4BAA4B,CAAa,QAAgB,EAAE,QAA+B;QAC7F,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE;YAClB,MAAM,IAAI,oBAAoB,CAAC,0DAA0D,QAAQ,8BAA8B,CAAC,CAAC;SACpI;QAED,MAAM,YAAY,GAAG,yBAAyB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;QAErG,IAAI,YAAY,IAAI,IAAI,EAAE;YACtB,YAAY,CAAC,UAAU,GAAG,cAAc,CAAC,IAAI,CAAC;YAC9C,mBAAmB,CAAC,4BAA4B,CAC5C,IAAI,EACJ,YAAY,EACZ,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC,EACnD,QAAQ,IAAI,gBAAgB,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAa,CAAC,CAC3F,CAAC;SACL;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACI,kBAAkB,CACrB,QAA0B,EAC1B,cAAuD,EACvD,oBAA6B,EAC7B,cAAuB;QAEvB,OAAO,IAAI,CAAC,8BAA8B,CAAC,QAAkB,EAAE,cAAc,EAAE,oBAAoB,EAAE,cAAc,CAAC,CAAC;IACzH,CAAC;IAEM,8BAA8B,CACjC,QAAgB,EAChB,cAAuD,EACvD,oBAA6B,EAC7B,cAAuB;QAEvB,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;QACnE,IAAI,MAAM,EAAE;YACR,MAAM,MAAM,GAAG,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,QAAQ,EAAE,cAAc,EAAE,cAAc,CAAC,CAAC;YAC3F,IAAI,oBAAoB,EAAE;gBACtB,MAAM,CAAC,8BAA8B,CAAC,oBAAoB,CAAC,CAAC;aAC/D;SACJ;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACO,MAAM,CAAC,4BAA4B,CACzC,IAA+C,EAC/C,SAAiC,EACjC,MAAkD,EAClD,GAAG,IAAW;QAEd,IAAI,MAAM,IAAI,IAAI,EAAE;YAChB,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;SACjD;QAED,IAAI,SAAS,CAAC,UAAU,KAAK,cAAc,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,SAAS,CAAC,QAAQ,EAAE;YACzF,IAAI,GAAG,CAAC,gBAAgB,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;SACjD;QAED,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,EAAE,SAAS,CAAC,iBAAiB,EAAE,GAAG,IAAI,CAAC,CAAC;QACnF,IAAI,SAAS,CAAC,SAAS,EAAE;YACrB,MAAM,aAAa,GAAG,SAAS,CAAC,kBAAkB,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC;YACrF,IAAI,aAAa,EAAE;gBACf,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,aAA6B,CAAC,CAAC,CAAC;aACtE;SACJ;aAAM;YACH,MAAM,CAAC,cAAc,EAAE,CAAC,gBAAgB,EAAE,CAAC;SAC9C;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ;AAED,MAAM,OAAO,eAAgB,SAAQ,mBAAwB;IACzD;QACI,KAAK,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC;IACpC,CAAC;IAEM,MAAM,CAAC,MAAM,CAChB,UAA6B,EAC7B,aAAgC,EAChC,WAAyC;QAEzC,OAAO,IAAI,mBAAmB,CAA6B,eAAe,CAAC,MAAM,CAAa,UAAU,EAAE,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC;IAC3I,CAAC;IAEM,MAAM,CAAC,SAAS,CACnB,IAA2B,EAC3B,UAA6B,EAC7B,aAAgC,EAChC,WAAyC,EACzC,eAAe,GAAG,KAAK;QAEvB,OAAO,IAAI,mBAAmB,CAA6B,eAAe,CAAC,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,WAAW,CAAC,EAAE,eAAe,CAAC,CAAC;IACzJ,CAAC;IAEM,MAAM,CAAC,SAAS,CAAmE,KAAkC;QACxH,OAAO,IAAI,mBAAmB,CAA6B,KAAK,CAAC,CAAC;IACtE,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,yBAAyB,CACnC,IAA2B,EAC3B,UAA6B,EAC7B,aAAgC;QAEhC,OAAO,eAAe,CAAC,2BAA2B,CAAC,IAAI,EAAE,yBAAyB,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC;IACzH,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,2BAA2B,CACrC,IAA2B,EAC3B,UAAoC,EACpC,UAA6B,EAC7B,aAAgC;QAEhC,MAAM,UAAU,GAAG,eAAe,CAAC,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;QAC/F,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,4BAA4B,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC;QAC1K,OAAO,UAAU,CAAC;IACtB,CAAC;CACJ;AAED,MAAM,OAAO,0BAA2B,SAAQ,mBAAwB;IASpE,YAAsB,KAA2B;QAC7C,KAAK,CAAC,KAAK,CAAC,CAAC;QATT,qBAAgB,GAAkB,EAAE,CAAC;QACrC,mBAAc,GAAkB,EAAE,CAAC;QACnC,iBAAY,GAAkB,EAAE,CAAC;QACjC,oBAAe,GAAG,2BAA2B,CAAC,OAAO,CAAC;QACtD,sBAAiB,GAAG,2BAA2B,CAAC,OAAO,CAAC;QAE7C,aAAQ,GAA8B,EAAE,CAAC;QAKxD,IAAI,KAAK,CAAC,aAAa,EAAE;YACrB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;SACvC;IACL,CAAC;IAED,IAAoB,OAAO;QACvB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED;;;OAGG;IACI,mBAAmB,CAAC,cAAwB;QAC/C,IAAI,CAAC,gBAAgB,GAAG,cAAc,CAAC;QACvC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACI,eAAe,CAAC,aAAuB,EAAE,cAAc,GAAG,2BAA2B,CAAC,YAAY;QACrG,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC;QACtC,IAAI,CAAC,YAAY,GAAG,aAAa,CAAC;QAClC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACI,iBAAiB,CAAC,cAAwB,EAAE,gBAAgB,GAAG,2BAA2B,CAAC,YAAY;QAC1G,IAAI,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;QAC1C,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QACrC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACa,sBAAsB,CAAC,QAAgB,EAAE,IAAoB,EAAE,WAAmC,EAAE,GAAG,IAAW;QAC9H,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,QAAQ,KAAK,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QACpH,IAAI,MAAM,EAAE;YACR,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC,CAAC;SAC7C;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACI,eAAe,CAAC,QAAgB,EAAE,KAAa;QAClD,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,QAAQ,KAAK,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QAChG,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;OAGG;IACI,yBAAyB,CAAC,IAAoB;QACjD,MAAM,eAAe,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAEjD,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE;YAC5C,OAAO,eAAe,CAAC;SAC1B;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACjC,MAAM,OAAO,GAAG,UAAU,CAAC,iBAAiB,CAAC,WAAW,CAAC;aACpD,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;aACvD,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,yBAAyB;QAE5E,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,OAAO,EAAE;YAChC,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,KAAK,GAAG,CAAC,CAAC;YACnE,IAAI,MAAkC,CAAC;YACvC,IAAI,UAAU,EAAE;gBACZ,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE;oBACxB,SAAS;iBACZ;gBACD,MAAM,GAAG,UAAU,CAAC,kBAAkB,CAAC,eAAe,CAAC,CAAC;gBACxD,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;aACtC;iBAAM;gBACH,MAAM,GAAG,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;gBACvD,2BAA2B,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;aAC9C;YAED,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;gBAC5D,MAAM,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,YAAY,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC;aAC7G;YAED,MAAM,oBAAoB,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACzE,IACI,CAAC,IAAI,CAAC,eAAe,KAAK,2BAA2B,CAAC,OAAO,IAAI,CAAC,oBAAoB,CAAC;gBACvF,CAAC,IAAI,CAAC,eAAe,KAAK,2BAA2B,CAAC,YAAY,IAAI,oBAAoB,CAAC,EAC7F;gBACE,MAAM,CAAC,cAAc,EAAE,CAAC;aAC3B;YAED,MAAM,sBAAsB,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAC7E,IACI,IAAI,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC;gBAC9B,CAAC,CAAC,IAAI,CAAC,iBAAiB,KAAK,2BAA2B,CAAC,OAAO,IAAI,CAAC,sBAAsB,CAAC;oBACxF,CAAC,IAAI,CAAC,iBAAiB,KAAK,2BAA2B,CAAC,YAAY,IAAI,sBAAsB,CAAC,CAAC,EACtG;gBACE,MAAM,CAAC,gBAAgB,EAAE,CAAC;aAC7B;SACJ;QAED,OAAO,eAAe,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACa,SAAS,CAAC,QAAmB;QACzC,MAAM,MAAM,GAAG,IAAI,uBAAuB,CAAC,IAAI,EAAE,QAAkB,CAAC,CAAC;QACrE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3B,OAAO,MAAM,CAAC;IAClB,CAAC;IAEe,YAAY,CAAC,QAAmB;QAC5C,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QAC/F,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAC7B,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;OAEG;IACa,IAAI;QAChB,MAAM,UAAU,GAAG,IAAI,0BAA0B,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;QACrE,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QAC9B,UAAU,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QACtD,UAAU,CAAC,gBAAgB,GAAG,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACzD,UAAU,CAAC,cAAc,GAAG,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC;QACrD,UAAU,CAAC,YAAY,GAAG,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC;QACjD,UAAU,CAAC,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC;QACtD,UAAU,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;QAClD,OAAO,UAAU,CAAC;IACtB,CAAC;IAEM,iBAAiB;QACpB,MAAM,UAAU,GAAG,IAAI,mBAAmB,CAAM,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5D,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QAC9B,OAAO,UAAU,CAAC;IACtB,CAAC;CACJ;AAED,MAAM,OAAO,sBAAuB,SAAQ,0BAA0B;IAClE;QACI,KAAK,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC;IACpC,CAAC;IAEM,MAAM,CAAC,MAAM,CAAC,UAAmB,EAAE,aAAsB,EAAE,WAAqC;QACnG,OAAO,IAAI,0BAA0B,CAAC,eAAe,CAAC,MAAM,CAAM,UAAU,EAAE,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC;IAC/G,CAAC;IAEM,MAAM,CAAC,SAAS,CAAC,KAA2B;QAC/C,OAAO,IAAI,0BAA0B,CAAC,KAAK,CAAC,CAAC;IACjD,CAAC;CACJ","sourcesContent":["import {ClassType, CommonsInternalError, DataListResult, DateUtil, EnumConstantType, EnumType, ILookupDataProvider, ObjectUtil, TypeRegistry} from '@mediusinc/mng-commons/core';\nimport {FilterDescriptor, FilterLookupDescriptor, FilterLookupEnumDescriptor, FilterTypeEnum} from '@mediusinc/mng-commons/filter';\nimport {EnumDescriptor, ModelDescriptor, ModelUtil, enumModelGeneric} from '@mediusinc/mng-commons/model';\n\nimport {columnToDateNumberOrBoolean, getTableClassAttributeDef} from '../helpers/class-attribute-converter';\nimport {TableClassAttributeDef} from '../models/class-table-attribute.model';\nimport {ColumnDisplayTypeEnum, ColumnTypeEnum} from '../models/column.model';\nimport {IColumnsManageInterface} from '../models/table-columns.model';\nimport {ITableDescriptorInternal, TableDynamicColumnsModeEnum, TablePaginationModeEnum, TableSizeEnum} from '../models/table.model';\nimport {ColumnDescriptor, ColumnDynamicDescriptor} from './column.descriptor';\nimport {SortDescriptor} from './sort.descriptor';\n\nexport class TableDescriptorInst<TableModel, Sorts = keyof TableModel, Filters = keyof TableModel>\n    implements ITableDescriptorInternal<TableModel>, IColumnsManageInterface<TableModel, Sorts, Filters>\n{\n    private readonly _model: ModelDescriptor<TableModel>;\n    protected readonly _autoGenerated;\n\n    private _identifier?: string;\n    private _trackProperty?: string;\n    private _paginationMode?: TablePaginationModeEnum;\n    private _rowsPerPageOptions?: number[];\n    private _defaultNumRows?: number;\n    protected _columns: Array<ColumnDescriptor<any, TableModel>> = [];\n    private _title?: string;\n    private _hideHeader = false;\n    private _loadingText?: string;\n    private _loadingIcon: string | null = 'pi pi-spinner';\n\n    // extra\n    private _hasHover = true;\n    private _hasGridlines = false;\n    private _hasResizableColumns = false;\n    private _columnResizeMode?: 'fit' | 'expand';\n\n    // special columns\n    private _selectionColumnFrozen?: boolean;\n    private _actionColumnFrozen?: boolean;\n\n    // styling\n    private _size: TableSizeEnum = TableSizeEnum.Large;\n    private _className = '';\n    private _headerClassName?: string;\n    private _rowClassName?: string;\n    private _rowClassNameMapFn?: (className?: string, item?: TableModel) => string;\n    private _tableFullHeightOffset?: number;\n    private _rowHeight?: number;\n\n    // filters&sorts\n    private _filters: FilterDescriptor<any, TableModel>[] = [];\n    private _sorts: SortDescriptor<TableModel>[] = [];\n\n    // localization\n    private _isLocalized = false;\n    private _localizationLocaleProperty?: string;\n\n    protected constructor(model: ModelDescriptor<TableModel>, autoGenerated = false) {\n        this._model = model;\n        this._trackProperty = this._model.idProperty;\n        this._autoGenerated = autoGenerated;\n    }\n\n    public get identifier() {\n        return this._identifier;\n    }\n\n    public get trackProperty() {\n        return this._trackProperty;\n    }\n\n    public get paginationMode() {\n        return this._paginationMode;\n    }\n\n    get rowsPerPageOptions() {\n        return this._rowsPerPageOptions;\n    }\n\n    get defaultNumRows() {\n        return this._defaultNumRows;\n    }\n\n    public get columns() {\n        return this._columns;\n    }\n\n    public get title() {\n        return this._title;\n    }\n\n    public get hideHeader() {\n        return this._hideHeader;\n    }\n\n    public get loadingText() {\n        return this._loadingText;\n    }\n\n    public get loadingIcon() {\n        return this._loadingIcon;\n    }\n\n    public get filters() {\n        return this._filters;\n    }\n\n    public get sorts() {\n        return this._sorts;\n    }\n\n    public get model() {\n        return this._model;\n    }\n\n    public get className() {\n        return this._className;\n    }\n\n    public get size() {\n        return this._size;\n    }\n\n    public get tableFullHeightOffset() {\n        return this._tableFullHeightOffset;\n    }\n\n    public get rowHeight() {\n        return this._rowHeight;\n    }\n\n    public get hasHover() {\n        return this._hasHover;\n    }\n\n    public get hasGridlines() {\n        return this._hasGridlines;\n    }\n\n    public get hasResizableColumns() {\n        return this._hasResizableColumns;\n    }\n\n    public get columnResizeMode() {\n        return this._columnResizeMode;\n    }\n\n    public get rowClassName() {\n        return this._rowClassName;\n    }\n\n    public get rowClassNameMapFn() {\n        return this._rowClassNameMapFn;\n    }\n\n    public get selectionColumnFrozen() {\n        return this._selectionColumnFrozen;\n    }\n\n    public get actionColumnFrozen() {\n        return this._actionColumnFrozen;\n    }\n\n    public get headerClassName() {\n        return this._headerClassName;\n    }\n\n    public get isLocalized() {\n        return this._isLocalized;\n    }\n\n    public get localizationLocaleProperty() {\n        return this._localizationLocaleProperty;\n    }\n\n    /**\n     * Track property is used for the purpose of combined saving user preferences in localstorage if 2 tables have the same track properties they will share the same localstorage entry.\n     * Similarly, this property can also be used to differentiate two tables of the same model on the same url (so that they have separate entries in localstorage).\n     * @param identifier\n     */\n    public withIdentifier(identifier: string): this {\n        this._identifier = identifier;\n        return this;\n    }\n\n    public withTrackProperty(property?: keyof TableModel): this {\n        return this.withTrackPropertyUnsafe(property as string);\n    }\n\n    public withTrackPropertyUnsafe(property?: string): this {\n        this._trackProperty = property;\n        return this;\n    }\n\n    public getColumn(property: keyof TableModel) {\n        return this.getColumnUnsafe(property as string);\n    }\n\n    public getColumnUnsafe(property: string) {\n        return this._columns.find(col => col.property === property) ?? null;\n    }\n\n    public removeColumn(property: keyof TableModel): void {\n        this.removeColumnUnsafe(property as string);\n    }\n\n    public removeColumnUnsafe(property: string): void {\n        const columnIdx = this._columns.findIndex(c => c.property === property);\n        this._columns.splice(columnIdx, 1);\n    }\n\n    public withColumn<ColumnModel, ColumnValue = ColumnModel>(column: ColumnDescriptor<ColumnModel, TableModel, ColumnValue>): this {\n        this._columns.push(column);\n        return this;\n    }\n\n    public addColumn<PropertyKey extends keyof TableModel>(property: PropertyKey) {\n        const column = new ColumnDescriptor<NonNullable<TableModel[PropertyKey]>, TableModel, TableModel[PropertyKey]>(this, property as string);\n        this._columns.push(column);\n        return column;\n    }\n\n    public addColumnEnum<PropertyKey extends keyof TableModel, Enum extends NonNullable<TableModel[PropertyKey]>>(property: PropertyKey, enumDesc: EnumDescriptor<Enum>) {\n        const column = new ColumnDescriptor<Enum, TableModel, TableModel[PropertyKey]>(this, property as string);\n        column.asEnumUnsafe(enumDesc);\n        this._columns.push(column);\n        return column;\n    }\n\n    public addColumnUnsafe<ColumnModel = unknown>(property: string): ColumnDescriptor<ColumnModel, TableModel> {\n        const column = new ColumnDescriptor<ColumnModel, TableModel>(this, property);\n        this._columns.push(column);\n        return column;\n    }\n\n    public withColumns(...properties: (keyof TableModel)[]): this {\n        properties.forEach(p => this.addColumn(p));\n        return this;\n    }\n\n    public withPaginationMode(paginationMode: TablePaginationModeEnum): this {\n        this._paginationMode = paginationMode;\n        return this;\n    }\n\n    public withRowsPerPage(rows: number, options?: Array<number>) {\n        this._defaultNumRows = rows;\n        this._rowsPerPageOptions = options;\n        return this;\n    }\n\n    public withTitle(title: string): this {\n        this._title = title;\n\n        return this;\n    }\n\n    public withHideHeader(hideHeader = true) {\n        this._hideHeader = hideHeader;\n        return this;\n    }\n\n    public withLoading(text?: string, icon?: string | null): this {\n        this._loadingText = text;\n        this._loadingIcon = icon === undefined ? 'pi pi-spinner' : icon;\n        return this;\n    }\n\n    /**\n     * Helper method that enables/disables reorderable property on all columns currently in the descriptor.\n     * @param columnsReorderable\n     */\n    public withCurrentColumnsReorderable(columnsReorderable = true): this {\n        for (const col of this.columns) {\n            col.withReorderable(columnsReorderable);\n        }\n        return this;\n    }\n\n    /**\n     * Helper method that enables/disables toggleable property on all columns currently in the descriptor.\n     * @param columnsToggleable\n     */\n    public withCurrentColumnsToggleable(columnsToggleable = true): this {\n        for (const col of this.columns) {\n            col.withToggleable(columnsToggleable);\n        }\n        return this;\n    }\n\n    public getSort(property: Sorts) {\n        return this.getSortUnsafe(property as string);\n    }\n\n    public getSortUnsafe(property: string) {\n        return this._sorts.find(s => s.property === property) ?? null;\n    }\n\n    public removeSort(property: Sorts) {\n        return this.removeSortUnsafe(property as string);\n    }\n\n    public removeSortUnsafe(property: string) {\n        const sortIdx = this._sorts.findIndex(c => c.property === property);\n        this._sorts.splice(sortIdx, 1);\n    }\n\n    public addSort(property: Sorts, isDefault = false, ascending?: boolean) {\n        return this.addSortUnsafe(property as string, isDefault, ascending);\n    }\n\n    public addSortUnsafe(property: string, isDefault = false, ascending?: boolean) {\n        const sort = new SortDescriptor<TableModel>(property);\n        if (isDefault) {\n            const defaultOrderMax = this._sorts\n                .filter(s => s.defaultIsEnabled)\n                .reduce((acc, s) => (s.defaultOrder !== undefined && s.defaultOrder > acc ? s.defaultOrder : acc), -1);\n            sort.withDefaultSort(true, ascending, defaultOrderMax + 1);\n        }\n        this._sorts.push(sort);\n        return sort;\n    }\n\n    public withSort(property: Sorts, isDefault = false, ascending?: boolean): this {\n        return this.withSortUnsafe(property as string, isDefault, ascending);\n    }\n\n    public withSortUnsafe(property: string, isDefault = false, ascending?: boolean): this {\n        this.addSortUnsafe(property, isDefault, ascending);\n        return this;\n    }\n\n    public withDefaultSort(property: Sorts, ascending?: boolean, order?: number, enabled?: boolean): this {\n        return this.withDefaultSortUnsafe(property as string, ascending, order, enabled);\n    }\n\n    public withDefaultSortUnsafe(property: string, ascending?: boolean, order?: number, enabled?: boolean): this {\n        let sort = this._sorts.find(s => s.property === property);\n        if (!sort) {\n            sort = new SortDescriptor(property);\n            this._sorts.push(sort);\n        }\n        sort.withDefaultSort(enabled ?? true, ascending, order);\n        return this;\n    }\n\n    public withSorts(...properties: Sorts[]): this {\n        return this.withSortsUnsafe(...(properties as string[]));\n    }\n\n    public withSortsUnsafe(...properties: string[]): this {\n        properties.forEach(p => {\n            this._sorts.push(new SortDescriptor(p));\n        });\n        return this;\n    }\n\n    public getFilter(property: Filters) {\n        return this.getFilterUnsafe(property as string);\n    }\n\n    public getFilterUnsafe(property: string) {\n        return this._filters.find(s => s.property === property) ?? null;\n    }\n\n    public removeFilter(property: Filters) {\n        return this.removeFilterUnsafe(property as string);\n    }\n\n    public removeFilterUnsafe(property: string) {\n        const filterIdx = this._filters.findIndex(c => c.property === property);\n        this._filters.splice(filterIdx, 1);\n    }\n\n    public addFilter<FilterModel = Filters extends keyof TableModel ? TableModel[Filters] : never>(property: Filters) {\n        return this.addFilterUnsafe<FilterModel>(property as string);\n    }\n\n    public addFilterUnsafe<FilterModel>(property: string) {\n        const filter = new FilterDescriptor<FilterModel, TableModel>(property);\n        this._filters.push(filter);\n        return filter;\n    }\n\n    public addFilterLookup<FilterModel = Filters extends keyof TableModel ? NonNullable<TableModel[Filters]> : never, Service = undefined>(\n        property: Filters,\n        provider?: ILookupDataProvider<FilterModel, Service>,\n        optionsValueProperty?: keyof FilterModel\n    ) {\n        return this.addFilterLookupUnsafe(property as string, provider, optionsValueProperty as string);\n    }\n\n    public addFilterLookupUnsafe<FilterModel, Service = undefined>(property: string, provider?: ILookupDataProvider<FilterModel, Service>, optionsValueProperty?: string) {\n        const filter = new FilterLookupDescriptor<FilterModel, TableModel, Service>(property, {\n            dataProvider: provider,\n            optionsValueProperty: optionsValueProperty\n        });\n        this._filters.push(filter);\n        return filter;\n    }\n\n    public addFilterLookupEnum<Enum>(property: Filters, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>) {\n        return this.addFilterLookupEnumUnsafe<Enum>(property as string, enumDesc, options);\n    }\n\n    public addFilterLookupEnumUnsafe<Enum = EnumConstantType>(property: string, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>) {\n        const filter = new FilterLookupEnumDescriptor(property, enumDesc, options);\n        this._filters.push(filter);\n        return filter;\n    }\n\n    public addFilterFromColumn(property: Extract<Filters, keyof TableModel>, forceSimple = false) {\n        return this.addFilterFromColumnUnsafe(property as string, forceSimple);\n    }\n\n    public withFiltersFromColumns(...properties: Extract<Filters, keyof TableModel>[]): this {\n        return this.withFiltersFromColumnsUnsafe(...(properties as string[]));\n    }\n\n    public withFiltersFromColumnsUnsafe(...properties: string[]): this {\n        properties.forEach(p => {\n            this.addFilterFromColumnUnsafe(p);\n        });\n        return this;\n    }\n\n    public addFilterFromColumnUnsafe(property: string, forceSimple = false) {\n        const column = this.getColumnUnsafe(property);\n        if (!column) {\n            throw new CommonsInternalError(`No column found for filter property \"${property}\"`);\n        }\n        return this.addFilterFromColumnDescriptorUnsafe(column, forceSimple);\n    }\n\n    public addFilterFromColumnDescriptorUnsafe<ColumnModel, ColumnValue>(\n        column: ColumnDescriptor<ColumnModel, TableModel, ColumnValue>,\n        forceSimple: boolean\n    ): FilterDescriptor<any, TableModel> {\n        let filterDescriptor = new FilterDescriptor<any, TableModel>(column.property);\n        let filterType: FilterTypeEnum;\n\n        switch (column.columnType) {\n            case ColumnTypeEnum.Number:\n                filterType = FilterTypeEnum.Number;\n                break;\n            case ColumnTypeEnum.Boolean:\n                filterType = FilterTypeEnum.Boolean;\n                break;\n            case ColumnTypeEnum.Date:\n                filterType = FilterTypeEnum.Date;\n                break;\n            case ColumnTypeEnum.Enum:\n                if (!forceSimple && column.enum) {\n                    filterDescriptor = new FilterLookupEnumDescriptor(column.property, column.enum);\n                    filterType = FilterTypeEnum.LookupEnum;\n                } else {\n                    filterType = FilterTypeEnum.String;\n                }\n                break;\n            case ColumnTypeEnum.String:\n            case ColumnTypeEnum.Custom:\n            default:\n                filterType = FilterTypeEnum.String;\n                break;\n        }\n\n        filterDescriptor.asFilterType(filterType);\n        if (filterType === FilterTypeEnum.Number) {\n            const displayFormatFractions = column.displayFormat?.split('.')?.[1]?.split('-');\n            if (displayFormatFractions && displayFormatFractions.length > 2) {\n                filterDescriptor.withNumberFractions(parseInt(displayFormatFractions[0]), parseInt(displayFormatFractions[1]));\n            }\n        } else if (filterType === FilterTypeEnum.Date) {\n            const displayFormat = column.displayFormat;\n            if (displayFormat) {\n                const filterDisplayFormat = DateUtil.fromAngularToPrimeDateFormat(displayFormat);\n                const hasTime = DateUtil.fromAngularDateFormatHasTime(displayFormat);\n                const hasSeconds = DateUtil.fromAngularDateFormatHasSeconds(displayFormat);\n                filterDescriptor.withDateFormat(filterDisplayFormat, hasTime, hasSeconds);\n            }\n        }\n\n        this._filters.push(filterDescriptor);\n\n        return filterDescriptor;\n    }\n\n    public withFilter<FilterModel>(property: Filters, filter: FilterDescriptor<FilterModel, TableModel>): this {\n        if (filter.property !== property) {\n            throw new CommonsInternalError(`Filter property \"${property}\" and Filter descriptor property \"${filter.property}\" do not match.`);\n        }\n        return this.withFilterUnsafe<FilterModel>(filter);\n    }\n\n    public withFilterUnsafe<FilterModel>(filter: FilterDescriptor<FilterModel, TableModel>): this {\n        this._filters.push(filter);\n        return this;\n    }\n\n    public withClassName(className: string): this {\n        this._className = className;\n        return this;\n    }\n\n    public withSize(size: TableSizeEnum = TableSizeEnum.Normal): this {\n        this._size = size;\n        return this;\n    }\n\n    public withTableFullHeightOffset(tableFullHeightOffset: number): this {\n        this._tableFullHeightOffset = tableFullHeightOffset;\n        return this;\n    }\n\n    public withRowHeight(rowHeight: number): this {\n        this._rowHeight = rowHeight;\n        return this;\n    }\n\n    public withHover(hover: boolean): this {\n        this._hasHover = hover;\n        return this;\n    }\n\n    public withGridlines(gridlines: boolean): this {\n        this._hasGridlines = gridlines;\n        return this;\n    }\n\n    /**\n     * Method that enables/disabled column resize feature with columnResizeMode on all columns.\n     * @param resizableColumns True if enabled\n     * @param columnResizeMode 'fit' or 'expand' mode\n     */\n    public withColumnsResizable(resizableColumns = true, columnResizeMode: 'fit' | 'expand' = 'fit'): this {\n        this._hasResizableColumns = resizableColumns;\n        this._columnResizeMode = columnResizeMode;\n        return this;\n    }\n\n    /**\n     * Sets column to (un)frozen.\n     * @param selectionColumnFrozen True to freeze selection column, false to unfreeze it.\n     * @param actionColumnFrozen True to freeze action column, false to unfreeze it.\n     */\n    public withColumnFrozen(selectionColumnFrozen?: boolean, actionColumnFrozen?: boolean): this {\n        this._selectionColumnFrozen = selectionColumnFrozen;\n        this._actionColumnFrozen = actionColumnFrozen;\n        return this;\n    }\n\n    public withRowClassName(rowClassName?: string, classNameMapFn?: (className?: string, item?: TableModel) => string): this {\n        this._rowClassName = rowClassName;\n        this._rowClassNameMapFn = classNameMapFn;\n        return this;\n    }\n\n    public withHeaderClassName(headerClassName: string): this {\n        this._headerClassName = headerClassName;\n        return this;\n    }\n\n    public withLocalized(): this {\n        this._isLocalized = true;\n        return this;\n    }\n\n    public withLocalizationLocaleProperty(localizationLocaleProperty: string): this {\n        this._isLocalized = true;\n        this._localizationLocaleProperty = localizationLocaleProperty;\n        return this;\n    }\n\n    protected copyFieldsTo(obj: TableDescriptorInst<any, any, any>) {\n        obj._title = this._title;\n        obj._hideHeader = this._hideHeader;\n        obj._trackProperty = this._trackProperty;\n        obj._filters = this._filters.map(f => f.copy());\n        obj._sorts = this._sorts.map(s => s.copy());\n        obj._className = this._className;\n        obj._size = this._size;\n        obj._tableFullHeightOffset = this._tableFullHeightOffset;\n        obj._rowHeight = this._rowHeight;\n        obj._hasHover = this._hasHover;\n        obj._hasGridlines = this._hasGridlines;\n        obj._hasResizableColumns = this._hasResizableColumns;\n        obj._columnResizeMode = this._columnResizeMode;\n        obj._actionColumnFrozen = this._actionColumnFrozen;\n        obj._selectionColumnFrozen = this._selectionColumnFrozen;\n        obj._isLocalized = this._isLocalized;\n        obj._localizationLocaleProperty = this._localizationLocaleProperty;\n        obj._paginationMode = this._paginationMode;\n        obj._rowsPerPageOptions = this._rowsPerPageOptions;\n    }\n\n    public copy(): TableDescriptorInst<TableModel, Sorts, Filters> {\n        const descriptor = new TableDescriptorInst<TableModel, Sorts, Filters>(this.model.copy());\n        this.copyFieldsTo(descriptor);\n        descriptor._columns = this.columns.map(c => c.copy());\n        return descriptor;\n    }\n\n    /**\n     * defines modified type of column\n     * DO NOT USE with enum (use withCustomEnumType)\n     * @param property column name\n     * @param columnType modified type\n     * @param args additional attributes\n     * @param columnDisplayType\n     */\n    public withColumnModifiedType(property: keyof TableModel, columnType?: ColumnTypeEnum, columnDisplayType?: ColumnDisplayTypeEnum, ...args: any[]): this {\n        return this.withColumnModifiedTypeUnsafe(property as string, columnType, columnDisplayType, ...args);\n    }\n\n    public withColumnModifiedTypeUnsafe(property: string, columnType?: ColumnTypeEnum, columnDisplayType?: ColumnDisplayTypeEnum, ...args: any[]): this {\n        if (!this.model.type) {\n            throw new CommonsInternalError(`withColumnModifiedType cannot be executed for property ${property}: Model type is not defined.`);\n        }\n\n        const attributeDef = getTableClassAttributeDef(this.model.type).find(attr => attr.name === property);\n\n        if (attributeDef != null) {\n            attributeDef.columnType = columnType ?? attributeDef.columnType;\n            attributeDef.columnDisplayType = columnDisplayType ?? attributeDef.columnDisplayType;\n            TableDescriptorInst.upsertColumnFromAttributeDef(\n                this,\n                attributeDef,\n                this.columns.find(col => col.property === attributeDef.name),\n                ...args\n            );\n        }\n\n        return this;\n    }\n\n    /**\n     * defines custom enum type for column\n     * @param property column name\n     * @param enumDesc Enum descriptor.\n     */\n    public withColumnModifiedEnum<Property extends keyof TableModel, Enum extends NonNullable<TableModel[Property]>>(\n        property: keyof TableModel,\n        enumDesc?: EnumDescriptor<Enum>\n    ): this {\n        return this.withColumnModifiedEnumUnsafe(property as string, enumDesc);\n    }\n\n    public withColumnModifiedEnumUnsafe<Enum = any>(property: string, enumDesc?: EnumDescriptor<Enum>): this {\n        if (!this.model.type) {\n            throw new CommonsInternalError(`withColumnModifiedEnum cannot be executed for property ${property}: Model type is not defined.`);\n        }\n\n        const attributeDef = getTableClassAttributeDef(this.model.type).find(attr => attr.name === property);\n\n        if (attributeDef != null) {\n            attributeDef.columnType = ColumnTypeEnum.Enum;\n            TableDescriptorInst.upsertColumnFromAttributeDef(\n                this,\n                attributeDef,\n                this.columns.find(col => col.property === property),\n                enumDesc ?? enumModelGeneric(TypeRegistry.get().findEnum(attributeDef.type) as EnumType)\n            );\n        }\n\n        return this;\n    }\n\n    /**\n     * modifies column with class and lookup provider\n     * @param property column name\n     * @param lookupProvider lookupProvider for class\n     * @param optionsLabelProperty\n     * @param filterProperty\n     */\n    public withModifiedLookup<ColumnLookupModel>(\n        property: keyof TableModel,\n        lookupProvider?: ILookupDataProvider<ColumnLookupModel>,\n        optionsLabelProperty?: string,\n        filterProperty?: string\n    ): this {\n        return this.withColumnModifiedLookupUnsafe(property as string, lookupProvider, optionsLabelProperty, filterProperty);\n    }\n\n    public withColumnModifiedLookupUnsafe<ColumnLookupModel>(\n        property: string,\n        lookupProvider?: ILookupDataProvider<ColumnLookupModel>,\n        optionsLabelProperty?: string,\n        filterProperty?: string\n    ): this {\n        const column = this.columns.find(col => col.property === property);\n        if (column) {\n            const filter = this.addFilterLookupUnsafe(column.property, lookupProvider, filterProperty);\n            if (optionsLabelProperty) {\n                filter.withOptionsLabelPropertyUnsafe(optionsLabelProperty);\n            }\n        }\n        return this;\n    }\n\n    /**\n     * generates column based on attributes\n     * @param desc Table descriptor\n     * @param attribute attribute map\n     * @param column if provided, replaced by new, otherwise new is created\n     * @param args additional parameters\n     */\n    protected static upsertColumnFromAttributeDef<ColumnModel, TableModel>(\n        desc: TableDescriptorInst<TableModel, any, any>,\n        attribute: TableClassAttributeDef,\n        column?: ColumnDescriptor<ColumnModel, TableModel>,\n        ...args: any[]\n    ): ColumnDescriptor<ColumnModel, TableModel> {\n        if (column == null) {\n            column = desc.addColumnUnsafe(attribute.name);\n        }\n\n        if (attribute.columnType === ColumnTypeEnum.Enum && args.length === 0 && attribute.enumType) {\n            args = [enumModelGeneric(attribute.enumType)];\n        }\n\n        column = column.asType(attribute.columnType, attribute.columnDisplayType, ...args);\n        if (attribute.classType) {\n            const titleProperty = ModelUtil.findTitleAttribute(attribute.classType) ?? undefined;\n            if (titleProperty) {\n                column.withGetter(value => value?.[titleProperty as keyof object]);\n            }\n        } else {\n            column.withSortUnsafe().withFilterUnsafe();\n        }\n\n        return column;\n    }\n}\n\nexport class TableDescriptor extends TableDescriptorInst<any> {\n    protected constructor() {\n        super(ModelDescriptor.create());\n    }\n\n    public static create<TableModel, Sorts = keyof TableModel, Filters = keyof TableModel>(\n        idProperty?: keyof TableModel,\n        titleProperty?: keyof TableModel,\n        i18nBaseKey?: string | ClassType<unknown>\n    ): TableDescriptorInst<TableModel, Sorts, Filters> {\n        return new TableDescriptorInst<TableModel, Sorts, Filters>(ModelDescriptor.create<TableModel>(idProperty, titleProperty, i18nBaseKey));\n    }\n\n    public static fromClass<TableModel, Sorts = keyof TableModel, Filters = keyof TableModel>(\n        type: ClassType<TableModel>,\n        idProperty?: keyof TableModel,\n        titleProperty?: keyof TableModel,\n        i18nBaseKey?: ClassType<unknown> | string,\n        isAutoGenerated = false\n    ): TableDescriptorInst<TableModel, Sorts, Filters> {\n        return new TableDescriptorInst<TableModel, Sorts, Filters>(ModelDescriptor.fromClass(type, idProperty, titleProperty, i18nBaseKey), isAutoGenerated);\n    }\n\n    public static fromModel<TableModel, Sorts = keyof TableModel, Filters = keyof TableModel>(model: ModelDescriptor<TableModel>): TableDescriptorInst<TableModel, Sorts, Filters> {\n        return new TableDescriptorInst<TableModel, Sorts, Filters>(model);\n    }\n\n    /**\n     * generates descriptor based on type attribute definition\n     * @param type class type\n     * @param idProperty\n     * @param titleProperty\n     */\n    public static fromClassWithAutoAttrsDef<TableModel>(\n        type: ClassType<TableModel>,\n        idProperty?: keyof TableModel,\n        titleProperty?: keyof TableModel\n    ): TableDescriptorInst<TableModel> {\n        return TableDescriptor.fromClassWithCustomAttrsDef(type, getTableClassAttributeDef(type), idProperty, titleProperty);\n    }\n\n    /**\n     * generates descriptor base on given attribute definition\n     * @param type class type\n     * @param attributes attributes from which descriptor is generated\n     * @param idProperty\n     * @param titleProperty\n     */\n    public static fromClassWithCustomAttrsDef<TableModel>(\n        type: ClassType<TableModel>,\n        attributes: TableClassAttributeDef[],\n        idProperty?: keyof TableModel,\n        titleProperty?: keyof TableModel\n    ): TableDescriptorInst<TableModel> {\n        const descriptor = TableDescriptor.fromClass(type, idProperty, titleProperty, undefined, true);\n        attributes.filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array')).forEach(attr => TableDescriptorInst.upsertColumnFromAttributeDef(descriptor, attr));\n        return descriptor;\n    }\n}\n\nexport class TableDynamicDescriptorInst extends TableDescriptorInst<any> {\n    private _excludedColumns: Array<string> = [];\n    private _filterColumns: Array<string> = [];\n    private _sortColumns: Array<string> = [];\n    private _sortColumnMode = TableDynamicColumnsModeEnum.EXCLUDE;\n    private _filterColumnMode = TableDynamicColumnsModeEnum.EXCLUDE;\n\n    protected override _columns: ColumnDynamicDescriptor[] = [];\n\n    protected constructor(model: ModelDescriptor<any>) {\n        super(model);\n\n        if (model.titleProperty) {\n            this.withTitle(model.titleProperty);\n        }\n    }\n\n    public override get columns() {\n        return this._columns;\n    }\n\n    /**\n     * defines excluded columns when generating descriptor\n     * @param excludedColumn names of excluded columns\n     */\n    public withColumnsExcluded(excludedColumn: string[]): this {\n        this._excludedColumns = excludedColumn;\n        return this;\n    }\n\n    /**\n     * defines column properties on which sort is defined or not depending on sortColumnMode\n     * @param sortOnColumns column names\n     * @param sortColumnMode INCLUDE_ONLY (default) only given columns will have sort, EXCLUDE given columns will NOT have sort\n     */\n    public withColumnsSort(sortOnColumns: string[], sortColumnMode = TableDynamicColumnsModeEnum.INCLUDE_ONLY): this {\n        this._sortColumnMode = sortColumnMode;\n        this._sortColumns = sortOnColumns;\n        return this;\n    }\n\n    /**\n     * defines column properties on which filter is defined or not depending on filterColumnMode\n     * @param filterOnColumn column names\n     * @param filterColumnMode INCLUDE_ONLY (default) only given columns will have filter, EXCLUDE given columns will NOT have filter\n     */\n    public withColumnsFilter(filterOnColumn: string[], filterColumnMode = TableDynamicColumnsModeEnum.INCLUDE_ONLY): this {\n        this._filterColumnMode = filterColumnMode;\n        this._filterColumns = filterOnColumn;\n        return this;\n    }\n\n    /**\n     * sets given type to column with given property and returns this table\n     * @param property column's property\n     * @param type custom type for column\n     * @param displayType custom column value display type\n     * @param args addition arguments for column\n     */\n    public override withColumnModifiedType(property: string, type: ColumnTypeEnum, displayType?: ColumnDisplayTypeEnum, ...args: any[]): this {\n        const column = this._columns.find(col => property === col.property) ?? this.addColumn(property).withTitle(property);\n        if (column) {\n            column.asType(type, displayType, ...args);\n        }\n        return this;\n    }\n\n    /**\n     * sets title to column with given property and returns this table\n     * @param property column's property\n     * @param title column's title\n     */\n    public withColumnTitle(property: string, title: string): this {\n        const column = this._columns.find(col => property === col.property) ?? this.addColumn(property);\n        column.withTitle(title, true);\n        return this;\n    }\n\n    /**\n     * generates columns defined on table based on data fetched from api\n     * @param data data from api\n     */\n    public toTableDescriptorFromData(data: DataListResult): TableDescriptorInst<any> {\n        const tableDescriptor = this.toTableDescriptor();\n\n        if (data.data == null || data.data.length == 0) {\n            return tableDescriptor;\n        }\n\n        const objectModel = data.data[0];\n        const entries = ObjectUtil.flattenObjectKeys(objectModel)\n            .filter(([key]) => !this._excludedColumns.includes(key))\n            .filter(([, value]) => !Array.isArray(value)); //exclude arrays and sets\n\n        for (const [key, value] of entries) {\n            const metaColumn = this._columns.find(col => col.property === key);\n            let column: ColumnDescriptor<any, any>;\n            if (metaColumn) {\n                if (!metaColumn.visibility) {\n                    continue;\n                }\n                column = metaColumn.toColumnDescriptor(tableDescriptor);\n                tableDescriptor.withColumn(column);\n            } else {\n                column = tableDescriptor.addColumn(key).withTitle(key);\n                columnToDateNumberOrBoolean(column, value);\n            }\n\n            if (this.model.i18nBaseKey && !column.property.includes('rev')) {\n                column.withTitle([this.model.i18nBaseKey, 'properties', column.property].join('.').replace('state.', ''));\n            }\n\n            const elementOfSortColumns = this._sortColumns.includes(column.property);\n            if (\n                (this._sortColumnMode === TableDynamicColumnsModeEnum.EXCLUDE && !elementOfSortColumns) ||\n                (this._sortColumnMode === TableDynamicColumnsModeEnum.INCLUDE_ONLY && elementOfSortColumns)\n            ) {\n                column.withSortUnsafe();\n            }\n\n            const elementOfFilterColumns = this._filterColumns.includes(column.property);\n            if (\n                this._filterColumns.length > 0 &&\n                ((this._filterColumnMode === TableDynamicColumnsModeEnum.EXCLUDE && !elementOfFilterColumns) ||\n                    (this._filterColumnMode === TableDynamicColumnsModeEnum.INCLUDE_ONLY && elementOfFilterColumns))\n            ) {\n                column.withFilterUnsafe();\n            }\n        }\n\n        return tableDescriptor;\n    }\n\n    /**\n     * adds ColumnDynamicDescriptor to this table\n     * @param property column's property\n     */\n    public override addColumn(property: keyof any): ColumnDynamicDescriptor {\n        const column = new ColumnDynamicDescriptor(this, property as string);\n        this._columns.push(column);\n        return column;\n    }\n\n    public override removeColumn(property: keyof any): this {\n        const column = this.columns.find(col => col.property === property) ?? this.addColumn(property);\n        column.withVisibility(false);\n        return this;\n    }\n\n    /**\n     * creates deep copy of table dynamic descriptor\n     */\n    public override copy(): TableDynamicDescriptorInst {\n        const descriptor = new TableDynamicDescriptorInst(this.model.copy());\n        this.copyFieldsTo(descriptor);\n        descriptor._columns = this.columns.map(c => c.copy());\n        descriptor._excludedColumns = [...this._excludedColumns];\n        descriptor._filterColumns = [...this._filterColumns];\n        descriptor._sortColumns = [...this._sortColumns];\n        descriptor._filterColumnMode = this._filterColumnMode;\n        descriptor._sortColumnMode = this._sortColumnMode;\n        return descriptor;\n    }\n\n    public toTableDescriptor(): TableDescriptorInst<any> {\n        const descriptor = new TableDescriptorInst<any>(this.model);\n        this.copyFieldsTo(descriptor);\n        return descriptor;\n    }\n}\n\nexport class TableDynamicDescriptor extends TableDynamicDescriptorInst {\n    protected constructor() {\n        super(ModelDescriptor.create());\n    }\n\n    public static create(idProperty?: string, titleProperty?: string, i18nBaseKey?: string | ClassType<any>): TableDynamicDescriptorInst {\n        return new TableDynamicDescriptorInst(ModelDescriptor.create<any>(idProperty, titleProperty, i18nBaseKey));\n    }\n\n    public static fromModel(model: ModelDescriptor<any>): TableDynamicDescriptorInst {\n        return new TableDynamicDescriptorInst(model);\n    }\n}\n"]}