@mediusinc/mng-commons 0.12.5 → 0.14.0

package/lib/descriptors/editor.descriptor.d.ts

@@ -1,17 +1,39 @@
+import { ILookupDataProvider } from '../data-providers';
+import { TableviewAttributeDef } from '../models/tableview-attr.model';
 import { ClassType, EnumConstantType, EnumType, MngFieldValidationMessage, MngFieldValidator } from '../types';
 import { AFieldDescriptor, FieldGroupDescriptor, FieldInputDescriptor, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor, FieldTabGroupDescriptor, ModelDescriptor, TableDescriptor, TableviewDescriptor } from './';
-import { TableviewTypeEnum } from './types';
+import { FieldInputTypeEnum, TableviewTypeEnum } from './types';
 export declare class EditorDescriptor<T> {
     static readonly defaultGroupName = "_default";
-    private readonly _model;
-    private readonly _tableviewEditorType;
-    private readonly _tabs;
-    private readonly _groups;
-    private readonly _fields;
-    private _currentTabGroup?;
-    private _currentGroup?;
-    private _disabled;
+    protected readonly _model: ModelDescriptor<T>;
+    protected readonly _modelType: ClassType<T>;
+    protected readonly _tableviewEditorType: TableviewTypeEnum;
+    protected readonly _tabs: Array<FieldTabGroupDescriptor<T>>;
+    protected readonly _groups: Array<FieldGroupDescriptor<T>>;
+    protected _fields: Array<AFieldDescriptor<any, T>>;
+    protected _currentTabGroup?: FieldTabGroupDescriptor<T>;
+    protected _currentGroup?: FieldGroupDescriptor<T>;
+    protected _disabled: boolean;
     constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string, tableviewEditorType?: TableviewTypeEnum);
+    /**
+     * auto generated editor descriptor based on openapi definition
+     * generates all fields from definition
+     * @param modelType class type
+     * @param idProperty
+     * @param titleProperty
+     * @param tableEditorType
+     */
+    static from<T>(modelType: ClassType<T>, idProperty?: string, titleProperty?: string, tableEditorType?: TableviewTypeEnum): EditorDescriptor<T>;
+    /**
+     * auto generated editor descriptor based on openapi definition
+     * generates only selected fields
+     * @param modelType class type
+     * @param attributes list of selected properties to generate fields based on
+     * @param idProperty
+     * @param titleProperty
+     * @param tableEditorType
+     */
+    static fromModelWithAttributes<T>(modelType: ClassType<T>, attributes: TableviewAttributeDef[], idProperty?: string, titleProperty?: string, tableEditorType?: TableviewTypeEnum): EditorDescriptor<T>;
     get model(): ModelDescriptor<T>;
     get tabs(): FieldTabGroupDescriptor<T>[];
     get fields(): AFieldDescriptor<any, T>[];
@@ -21,7 +43,11 @@ export declare class EditorDescriptor<T> {
     createFieldGroup(name: string, title?: string | null): FieldGroupDescriptor<T>;
     addFieldDescriptor<FT>(field: AFieldDescriptor<FT, T>): this;
     addField(property: string): FieldInputDescriptor<T>;
-    removeField(property: string): this;
+    /**
+     * removes filed if exists in descriptor
+     * @param property field name
+     */
+    removeField(property: string): void;
     getField(property: string): AFieldDescriptor<any, T> | null;
     addFieldLookup<FT>(property: string, modelType: ClassType<FT>): FieldLookupDescriptor<FT, T>;
     addFieldLookupEnum(property: string, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null): FieldLookupEnumDescriptor<T>;
@@ -31,7 +57,39 @@ export declare class EditorDescriptor<T> {
     addValidation(name: string, validator?: MngFieldValidator, message?: MngFieldValidationMessage): void;
     copy(): EditorDescriptor<T>;
     createFieldGroupDescriptor(fieldGroup: FieldGroupDescriptor<T>): this;
-    private createTabGroupDescriptor;
+    protected createTabGroupDescriptor(tabGroup: FieldTabGroupDescriptor<T>): this;
     private createDefaultGroup;
     private createDefaultTabGroup;
+    /**
+     * modifies selected field
+     * do not use it for enums! (use withFieldModifiedEnum instead)
+     * @param property field name
+     * @param fieldType new field type for selected field
+     * @param args additional parameters for field
+     */
+    withFieldModifiedType(property: string, fieldType: FieldInputTypeEnum, ...args: any[]): this;
+    /**
+     * modifies selected field with enum type
+     * @param property field property name
+     * @param enumType type of enum for new field
+     * @param optionsTitlePath
+     * @param values
+     * @param nameAsValue
+     */
+    withFieldModifiedEnum(property: string, enumType?: EnumType, optionsTitlePath?: string | null, values?: Array<EnumConstantType>, nameAsValue?: boolean): this;
+    /**
+     * adds lookup to given field
+     * @param property field property name
+     * @param modelType model type of field
+     * @param lookupProvider provider to be added to field
+     * @param titleProperty
+     */
+    withFieldModifiedLookup<MT>(property: string, modelType: ClassType<MT>, lookupProvider: ILookupDataProvider<any, any>, titleProperty?: string): this;
+    /**
+     * generates field based on attribute definition, used for auto model
+     * @param attribute definition
+     * @param field optional, if defined will be replaced, otherwise new will be generated
+     * @param args additional arguments
+     */
+    private upsertFieldFromAttributeDef;
 }

package/lib/descriptors/field.descriptor.d.ts

@@ -20,7 +20,6 @@ export declare abstract class AGenericFieldDescriptor<ET> {
 }
 export declare abstract class AFieldDescriptor<T, ET> extends AGenericFieldDescriptor<ET> {
     protected readonly _property: string;
-    protected _group?: AFieldGroupDescriptor<ET>;
     protected _label?: string | null;
     protected _placeholder?: string;
     protected _helpText?: string;
@@ -32,9 +31,9 @@ export declare abstract class AFieldDescriptor<T, ET> extends AGenericFieldDescr
     protected _setter?: (item: ET, value: T) => void;
     protected _validations: Array<FieldValidationDescriptor>;
     protected _asyncValidations: Array<FieldValidationDescriptor>;
-    protected _requiredExpression?: string | ((model: any, formState?: any, field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
-    protected _disabledExpression?: string | ((model: any, formState?: any, field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
-    protected _hiddenExpression?: string | ((model: any, formState?: any, field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
+    protected _requiredExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
+    protected _disabledExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
+    protected _hiddenExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
     protected _className: string;
     protected _fieldClassName?: string;
     protected _labelClassName: string;
@@ -43,7 +42,6 @@ export declare abstract class AFieldDescriptor<T, ET> extends AGenericFieldDescr
     protected readonly _eventsSubject: Subject<MngFormFieldEvent<T, ET>>;
     protected constructor(editor: EditorDescriptor<ET>, property: string);
     get property(): string;
-    get group(): AFieldGroupDescriptor<ET> | undefined;
     get label(): string | null | undefined;
     get placeholder(): string | undefined;
     get helpText(): string | undefined;
@@ -55,13 +53,13 @@ export declare abstract class AFieldDescriptor<T, ET> extends AGenericFieldDescr
     get setter(): ((item: ET, value: T) => void) | undefined;
     get validations(): FieldValidationDescriptor[];
     get asyncValidations(): FieldValidationDescriptor[];
-    get requiredExpression(): string | Observable<boolean> | ((model: any, formState?: any, field?: FormlyFieldConfig<import("@ngx-formly/core").FormlyFieldProps & {
+    get requiredExpression(): string | Observable<boolean> | ((field?: FormlyFieldConfig<import("@ngx-formly/core").FormlyFieldProps & {
         [additionalProperties: string]: any;
     }> | undefined) => boolean) | undefined;
-    get disabledExpression(): string | Observable<boolean> | ((model: any, formState?: any, field?: FormlyFieldConfig<import("@ngx-formly/core").FormlyFieldProps & {
+    get disabledExpression(): string | Observable<boolean> | ((field?: FormlyFieldConfig<import("@ngx-formly/core").FormlyFieldProps & {
         [additionalProperties: string]: any;
     }> | undefined) => boolean) | undefined;
-    get hiddenExpression(): string | Observable<boolean> | ((model: any, formState?: any, field?: FormlyFieldConfig<import("@ngx-formly/core").FormlyFieldProps & {
+    get hiddenExpression(): string | Observable<boolean> | ((field?: FormlyFieldConfig<import("@ngx-formly/core").FormlyFieldProps & {
         [additionalProperties: string]: any;
     }> | undefined) => boolean) | undefined;
     get className(): string;
@@ -75,9 +73,9 @@ export declare abstract class AFieldDescriptor<T, ET> extends AGenericFieldDescr
     withLabel(label: string | null): this;
     withPlaceholder(placeholder: string): this;
     withHelpText(helpText: string): this;
-    withRequired(required?: boolean, requiredExpression?: string | ((model: any, formState?: any, field?: FormlyFieldConfig) => boolean) | Observable<boolean>, hideLabelMarker?: boolean): this;
-    withDisabled(disabled?: boolean, disabledExpression?: string | ((model: any, formState?: any, field?: FormlyFieldConfig) => boolean) | Observable<boolean>): this;
-    withHidden(hiddenExpression: string | ((model: any, formState?: any, field?: FormlyFieldConfig) => boolean) | Observable<boolean>): this;
+    withRequired(required?: boolean, requiredExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>, hideLabelMarker?: boolean): this;
+    withDisabled(disabled?: boolean, disabledExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>): this;
+    withHidden(hiddenExpression: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>): this;
     withDefaultValue(defaultValue: T): this;
     withGetter(getter: (item: ET) => T): this;
     withSetter(setter: (item: ET, value: T) => void): this;
@@ -119,6 +117,12 @@ export declare class FieldInputDescriptor<ET> extends AFieldDescriptor<string |
     private _fileOnSelectHandler?;
     private _customComponentName?;
     constructor(editor: EditorDescriptor<ET>, property: string);
+    /**
+     * converts field to given type with additional arguments
+     * @param fieldType field type enum
+     * @param args any additional arguments for field (optional)
+     */
+    asType(fieldType: FieldInputTypeEnum, ...args: any[]): this;
     get fieldType(): FieldInputTypeEnum;
     get rows(): number | undefined;
     get numberMin(): number | undefined;
@@ -269,6 +273,7 @@ export declare abstract class AFieldGroupDescriptor<ET> extends AGenericFieldDes
     protected _fields: AGenericFieldDescriptor<ET>[];
     protected _validations: Array<FieldValidationDescriptor>;
     protected constructor(editor: EditorDescriptor<ET>, name: string);
+    removeField(property: string, filterFunction: (fields: AGenericFieldDescriptor<ET>[]) => AGenericFieldDescriptor<ET>[]): AGenericFieldDescriptor<ET>[];
     get title(): string | undefined;
     abstract get fields(): AGenericFieldDescriptor<ET>[];
     get validations(): FieldValidationDescriptor[];

package/lib/descriptors/filter.descriptor.d.ts

@@ -10,10 +10,10 @@ export declare class FilterDescriptor<T> {
     protected readonly _property: string;
     protected _filterType: FilterTypeEnum;
     protected _filterProperty?: string;
-    private _hasDefaultValue;
-    protected _defaultFilterMatchMode: FilterMatchModeEnum;
-    protected _defaultValue?: string;
-    private _defaultValueTo?;
+    protected _hasDefaultValue: boolean;
+    protected _defaultFilterMatchMode?: FilterMatchModeEnum;
+    protected _defaultValue?: string | string[];
+    protected _defaultValueTo?: string;
     protected _matchModes: string[] | null;
     protected _numberMinFractionDigits?: number;
     protected _numberMaxFractionDigits?: number;
@@ -28,9 +28,9 @@ export declare class FilterDescriptor<T> {
     constructor(property: string);
     get filterType(): FilterTypeEnum;
     get hasDefaultValue(): boolean;
-    get defaultValue(): string | undefined;
+    get defaultValue(): string | string[] | undefined;
     get defaultValueTo(): string | undefined;
-    get defaultFilterMatchMode(): FilterMatchModeEnum;
+    get defaultFilterMatchMode(): FilterMatchModeEnum | undefined;
     get filterProperty(): string | undefined;
     get matchModes(): string[] | null;
     get numberMinFractionDigits(): number | undefined;
@@ -93,6 +93,7 @@ export declare class FilterLookupDescriptor<T> extends FilterDescriptor<T> imple
     withLookupDataProvider(dataProvider: ILookupDataProvider<T, any>): this;
     withMultiselect(multiselect?: boolean): this;
     withDropdownClassName(dropdownClassName: string): this;
+    withDefaultFilter(filterValue: string | string[], filterValueTo?: string, filterMatchMode?: FilterMatchModeEnum): this;
     asAutocomplete(openOnFocus?: boolean, inlineSearch?: boolean): this;
     copy(): FilterLookupDescriptor<T>;
     protected copyFieldsTo(filter: FilterLookupDescriptor<T>): void;

package/lib/descriptors/index.d.ts

@@ -7,3 +7,5 @@ export * from './filter.descriptor';
 export * from './model.descriptor';
 export * from './table.descriptor';
 export * from './tableview.descriptor';
+export * from './button.descriptor';
+export * from './action/action-confirmation.descriptor';

package/lib/descriptors/table.descriptor.d.ts

@@ -1,16 +1,20 @@
 import { Type } from '@angular/core';
+import { MediusQueryResult } from '../api/models';
+import { ILookupDataProvider } from '../data-providers';
 import { IColumnValueComponent } from '../models';
+import { TableviewAttributeDef } from '../models/tableview-attr.model';
 import { ClassType, EnumType } from '../types';
-import { ColumnDescriptor } from './column.descriptor';
+import { ColumnDescriptor, ColumnDynamicDescriptor } from './column.descriptor';
 import { ModelDescriptor } from './model.descriptor';
-import { TableFilterDisplayEnum, TablePaginationModeEnum, TableSizeEnum } from './types';
+import { ColumnTypeEnum, TableDynamicColumnsModeEnum, TableFilterDisplayEnum, TablePaginationModeEnum, TableSizeEnum } from './types';
 export declare class TableDescriptor<T> {
     private readonly _model;
+    private _modelType;
     private _filterDisplay;
     private _paginationMode;
     private _rowsPerPageOptions;
     private _defaultNumRows;
-    private _columns;
+    protected _columns: Array<ColumnDescriptor<any, T>>;
     private _title?;
     private _hideHeader;
     private _dataKeyProperty?;
@@ -23,7 +27,26 @@ export declare class TableDescriptor<T> {
     private _rowHeight?;
     private _hasHover;
     private _hasGridlines;
+    private _headerClassName?;
+    private _rowClassName?;
+    private _rowClassNameMapFn?;
+    private _autoGenerated;
     constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string);
+    /**
+     * generates descriptor based on modelType attribute definition
+     * @param modelType class type
+     * @param idProperty
+     * @param titleProperty
+     */
+    static from<T>(modelType: ClassType<T>, idProperty?: string, titleProperty?: string): TableDescriptor<T>;
+    /**
+     * generates descriptor base on given attribute definition
+     * @param modelType class type
+     * @param attributes attributes from which descriptor is generated
+     * @param idProperty
+     * @param titleProperty
+     */
+    static fromModelWithAttributes<T>(modelType: ClassType<T>, attributes: TableviewAttributeDef[], idProperty?: string, titleProperty?: string): TableDescriptor<T>;
     get filterDisplay(): TableFilterDisplayEnum;
     get paginationMode(): TablePaginationModeEnum;
     get rowsPerPageOptions(): number[];
@@ -42,6 +65,10 @@ export declare class TableDescriptor<T> {
     get rowHeight(): number | undefined;
     get hasHover(): boolean;
     get hasGridlines(): boolean;
+    get rowClassName(): string | undefined;
+    get rowClassNameMapFn(): ((className?: string | undefined, item?: T | undefined) => string) | undefined;
+    get headerClassName(): string | undefined;
+    getColumn(property: string): ColumnDescriptor<string, T> | undefined;
     addColumnDescriptor<CT>(column: ColumnDescriptor<CT, T>): TableDescriptor<T>;
     addColumn(property: string): ColumnDescriptor<string, T>;
     addColumnNumber(property: string, displayFormat?: string): ColumnDescriptor<number, T>;
@@ -49,18 +76,107 @@ export declare class TableDescriptor<T> {
     addColumnBoolean(property: string, yes?: string, no?: string, asIcon?: boolean): ColumnDescriptor<boolean, T>;
     addColumnEnum(property: string, enumType: EnumType, nameAsValue?: boolean, titlePath?: string | null): ColumnDescriptor<EnumType, T>;
     addColumnCustomComponent(property: string, customComponentType: Type<IColumnValueComponent<T>>): ColumnDescriptor<any, T>;
+    removeColumn(property: string): void;
     withFilterDisplay(filterDisplayType: TableFilterDisplayEnum): this;
     withPaginationMode(paginationMode: TablePaginationModeEnum): this;
     withRowsPerPage(rows: number, options?: Array<number>): this;
-    withTitle(title: string): TableDescriptor<T>;
+    withTitle(title: string): this;
     withHideHeader(hideHeader?: boolean): this;
-    withDataKeyProperty(property: string): TableDescriptor<T>;
-    withDefaultSort(property: string, asc?: boolean): TableDescriptor<T>;
+    withDataKeyProperty(property: string): this;
+    withDefaultSort(property: string, asc?: boolean): this;
     withClassName(className: string): this;
     withSize(size?: TableSizeEnum): this;
-    withTableFullHeightOffset(tableFullHeightOffset: number): TableDescriptor<T>;
-    withRowHeight(rowHeight: number): TableDescriptor<T>;
+    withTableFullHeightOffset(tableFullHeightOffset: number): this;
+    withRowHeight(rowHeight: number): this;
     withHover(hover: boolean): this;
     withGridlines(gridlines: boolean): this;
+    withRowClassName(rowClassName?: string, classNameMapFn?: (className?: string, item?: T) => string): this;
+    withHeaderClassName(headerClassName: string): this;
+    protected copyFieldsTo(obj: TableDescriptor<T>): void;
     copy(): TableDescriptor<T>;
+    /**
+     * generates column based on attributes
+     * @param attribute attribute map
+     * @param column if provided, replaced by new, otherwise new is created
+     * @param args additional parameters
+     */
+    private upsertColumnFromAttributeDef;
+    /**
+     * defines modified type of column
+     * DO NOT USE with enum (use withCustomEnumType)
+     * @param property column name
+     * @param columnType modified type
+     * @param args additional attributes
+     */
+    withColumnModifiedType(property: string, columnType?: ColumnTypeEnum, ...args: any[]): this;
+    /**
+     * defines custom enum type for column
+     * @param property column name
+     * @param enumType
+     */
+    withColumnModifiedEnum(property: string, enumType?: EnumType): this;
+    /**
+     * modifies column with class and lookup provider
+     * @param property column name
+     * @param lookupProvider lookupProvider for class
+     * @param itemsLabelProperty
+     * @param filterProperty
+     */
+    withColumnModifiedLookup(property: string, lookupProvider: ILookupDataProvider<any, any>, itemsLabelProperty?: string, filterProperty?: string): this;
+}
+export declare class TableDynamicDescriptor extends TableDescriptor<any> {
+    private _excludedColumns;
+    private _filterColumns;
+    private _sortColumns;
+    private _sortColumnMode;
+    private _filterColumnMode;
+    protected _columns: ColumnDynamicDescriptor[];
+    constructor(idProperty?: string, titleProperty?: string);
+    get columns(): ColumnDynamicDescriptor[];
+    /**
+     * defines excluded columns when generating descriptor
+     * @param excludedColumn names of excluded columns
+     */
+    withColumnsExcluded(excludedColumn: string[]): 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: string[], sortColumnMode?: TableDynamicColumnsModeEnum): 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: string[], filterColumnMode?: TableDynamicColumnsModeEnum): 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 args addition arguments for column
+     */
+    withColumnModifiedType(property: string, type: ColumnTypeEnum, ...args: any[]): this;
+    /**
+     * sets title to column with given property and returns this table
+     * @param property column's property
+     * @param title column's title
+     */
+    withColumnTitle(property: string, title: string): this;
+    /**
+     * generates columns defined on table based on data fetched from api
+     * @param data data from api
+     */
+    toTableDescriptorFromData(data: MediusQueryResult<any>): TableDescriptor<any>;
+    /**
+     * adds ColumnDynamicDescriptor to this table
+     * @param property column's property
+     */
+    addColumn(property: string): ColumnDynamicDescriptor;
+    removeColumn(property: string): this;
+    /**
+     * creates deep copy of table dynamic descriptor
+     */
+    copy(): TableDynamicDescriptor;
+    toTableDescriptor(): TableDescriptor<any>;
 }

package/lib/descriptors/tableview.descriptor.d.ts

@@ -1,23 +1,44 @@
 import { Type } from '@angular/core';
 import { FieldValidatorFn } from '@ngx-formly/core/lib/models/config';
+import { ILookupDataProvider } from '../data-providers';
 import { IColumnValueComponent } from '../models';
+import { TableviewAttributeDef } from '../models/tableview-attr.model';
 import { ClassType, EnumConstantType, EnumType } from '../types';
-import { AFieldDescriptor, ColumnDescriptor, EditorDescriptor, FieldInputDescriptor, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor, ModelDescriptor, TableDescriptor } from './';
+import { AFieldDescriptor, ColumnDescriptor, EditorDescriptor, FieldInputDescriptor, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor, ModelDescriptor, TableDescriptor, TableDynamicDescriptor } from './index';
+import { ColumnTypeEnum, FieldInputTypeEnum, TableviewTypeEnum } from './types';
 export declare class TableviewDescriptor<T> {
     private readonly _model;
+    private _modelType;
+    protected _table: TableDescriptor<T>;
+    protected _viewEditor: EditorDescriptor<T>;
+    protected _addEditor: EditorDescriptor<T>;
+    protected _editEditor: EditorDescriptor<T>;
+    protected _tableTitle?: string;
     constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string);
-    private _table;
+    /**
+     * generates descriptor from attribute definition of openaapi model
+     * @param modelType class type
+     * @param idProperty
+     * @param titleProperty
+     */
+    static from<T>(modelType: ClassType<T>, idProperty?: string, titleProperty?: string): TableviewDescriptor<T>;
+    /**
+     * generates descriptor from given attribute definition
+     * @param modelType class type
+     * @param columnAttributes attribute definition to generate columns
+     * @param fieldAttributes attribute definition to generate fields, if undefined columnDefinition is used, if null editors are not generated
+     * @param idProperty
+     * @param titleProperty
+     */
+    static fromModelWithDefinition<T>(modelType: ClassType<T>, columnAttributes: TableviewAttributeDef[], fieldAttributes?: TableviewAttributeDef[] | null, idProperty?: string, titleProperty?: string): TableviewDescriptor<T>;
     get table(): TableDescriptor<T>;
-    private _viewEditor;
     get viewEditor(): EditorDescriptor<T>;
-    private _addEditor;
     get addEditor(): EditorDescriptor<T>;
-    private _editEditor;
     get editEditor(): EditorDescriptor<T>;
-    private _tableTitle;
-    get tableTitle(): string;
+    get tableTitle(): string | undefined;
     get model(): ModelDescriptor<T>;
     withTableDescriptor(descriptor: TableDescriptor<T>): this;
+    withEditorDescriptors(descriptor: EditorDescriptor<T>): this;
     withViewDescriptor(descriptor: EditorDescriptor<T>): this;
     withAddDescriptor(descriptor: EditorDescriptor<T>): this;
     withEditDescriptor(descriptor: EditorDescriptor<T>): this;
@@ -25,6 +46,9 @@ export declare class TableviewDescriptor<T> {
     withValidator(name: string, expression: FieldValidatorFn): this;
     addColumnDescriptor<CT>(column: ColumnDescriptor<CT, T>): TableDescriptor<T>;
     addColumn(property: string): ColumnDescriptor<string, T>;
+    removeColumn(property: string): void;
+    getField(property: string, editorType: TableviewTypeEnum): AFieldDescriptor<any, T> | null;
+    removeField(property: string): void;
     addColumnNumber(property: string, displayFormat?: string): ColumnDescriptor<number, T>;
     addColumnDate(property: string, displayFormat?: string): ColumnDescriptor<Date, T>;
     addColumnBoolean(property: string, yes?: string, no?: string, asIcon?: boolean): ColumnDescriptor<boolean, T>;
@@ -39,4 +63,54 @@ export declare class TableviewDescriptor<T> {
     addFieldManyEditor<FT>(property: string, tableviewDescriptor: TableviewDescriptor<FT>): FieldManyEditorDescriptor<FT, T>;
     addFieldManyToManyEditor<FT>(property: string, mainTableDescriptor: TableDescriptor<FT>, lookupTableDescriptor: TableDescriptor<FT>): FieldManyToManyEditorDescriptor<FT, T>;
     copy(): TableviewDescriptor<T>;
+    /**
+     * creates column and field with custom type, for example currency
+     * if field exists, it is replaced
+     * DO NOT USE WITH TYPES WHERE ARGS ARE REQUIRED - ERROR WILL BE THROWN
+     * for enum use withEnumType
+     * for custom class use withClassType
+     * @param property name of field
+     * @param columnType required column type
+     * @param fieldType optional, if not provided it is converted from column type
+     */
+    withModifiedType(property: string, columnType: ColumnTypeEnum, fieldType?: FieldInputTypeEnum): this;
+    /**
+     * creates column with enum type
+     * if fields exists, it is replaced
+     * @param property property name
+     * @param enumType type of enum
+     * @param fieldType type of field, optional, default is Text
+     */
+    withModifiedEnum(property: string, enumType?: EnumType, fieldType?: FieldInputTypeEnum): this;
+    /**
+     * generates column with custom class type
+     * field is generated only if lookupProvider is provided
+     * @param property property name
+     * @param modelType class type of object
+     * @param titleProperty
+     * @param lookupProvider
+     * @param itemsLabelProperty
+     * @param filterProperty
+     */
+    withModifiedLookup<MT>(property: string, modelType?: ClassType<MT>, lookupProvider?: ILookupDataProvider<MT, any>, titleProperty?: string, itemsLabelProperty?: string, filterProperty?: string): this;
+}
+export declare class TableviewDynamicDescriptor extends TableviewDescriptor<any> {
+    protected _table: TableDynamicDescriptor;
+    constructor(idProperty?: string, titleProperty?: string);
+    get table(): TableDynamicDescriptor;
+    /**
+     * sets custom table descriptor
+     * @param descriptor
+     */
+    withTableDescriptor(descriptor: TableDynamicDescriptor): this;
+    /**
+     * sets visibility hidden state to column with given property
+     * equals to be removing in auto and base tableview descriptor
+     * * @param property column's property
+     */
+    removeColumn(property: string): this;
+    /**
+     * creates depp copy of tableview object and its children
+     */
+    copy(): TableviewDynamicDescriptor;
 }

package/lib/descriptors/types/table.type.d.ts

@@ -11,3 +11,11 @@ export declare enum TableSizeEnum {
     Normal = 1,
     Large = 2
 }
+/**
+ * EXCLUDE default, all columns has sort and filter on by default, developer EXCLUDES properties from sort/filter
+ * INCLUDE_ONLY only selected columns have sort/filter, developers INCLUDES properties
+ */
+export declare enum TableDynamicColumnsModeEnum {
+    EXCLUDE = 0,
+    INCLUDE_ONLY = 1
+}