@mediusinc/mng-commons 0.2.1-rc → 0.2.4

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

@@ -0,0 +1,148 @@
+import { Observable } from 'rxjs';
+import { ClassType } from '../types';
+import { EditorDescriptor, ModelDescriptor } from './';
+import { IDataProvider, IEditorDataProvider } from '../data-providers';
+import { ActionExecContext } from '../components/action/models';
+export declare class ActionDescriptor<T> {
+    protected readonly _model: ModelDescriptor<T>;
+    protected readonly _actionName: string;
+    protected readonly _parentType?: ClassType<any>;
+    protected readonly _parentTypeName?: string;
+    protected readonly _parentProperty?: string;
+    protected readonly _i18nModelActionBaseKey: string;
+    protected _type: ActionTypeEnum;
+    protected _activationTrigger: ActionActivationTriggerEnum;
+    protected _position: ActionPositionEnum;
+    protected _level: ActionLevelEnum;
+    protected _routeUrl: string | null;
+    protected _title?: string | null;
+    protected _icon?: string;
+    protected _className: string;
+    protected _tooltip?: string | null;
+    protected _runFunction?: (ctx: ActionExecContext<T, any, IDataProvider<T, any>>) => Observable<T>;
+    protected _isVisibleFunction?: (ctx: ActionExecContext<T, any, IDataProvider<T, any>>) => Observable<boolean>;
+    protected _isEnabledFunction?: (ctx: ActionExecContext<T, any, IDataProvider<T, any>>) => Observable<boolean>;
+    private _hasRunConfirmation;
+    private _runConfirmationIcon?;
+    private _runConfirmationTitle?;
+    private _runConfirmationMessage?;
+    private _runConfirmationAcceptTitle?;
+    private _runConfirmationRejectTitle?;
+    protected _hasRunNotificationSuccess: boolean;
+    private _runNotificationSuccessTitle?;
+    private _runNotificationSuccessMessage?;
+    private _hasRunNotificationError;
+    private _runNotificationErrorTitle?;
+    private _runNotificationErrorMessage?;
+    constructor(model: ModelDescriptor<T>, actionName: string, parentType?: ClassType<any>, parentProperty?: string);
+    get model(): ModelDescriptor<T>;
+    get parentTypeName(): string | undefined;
+    get parentProperty(): string | undefined;
+    get i18nModelActionBaseKey(): string;
+    get type(): ActionTypeEnum;
+    get activationTrigger(): ActionActivationTriggerEnum;
+    get position(): ActionPositionEnum;
+    get level(): ActionLevelEnum;
+    get routeUrl(): string | null;
+    get title(): string | null | undefined;
+    get icon(): string | undefined;
+    get tooltip(): string | null | undefined;
+    get runFunction(): (ctx: ActionExecContext<T, any, IDataProvider<T, any>>) => Observable<T>;
+    get isVisibleFunction(): ((ctx: ActionExecContext<T, any, IDataProvider<T, any>>) => Observable<boolean>) | undefined;
+    get isEnabledFunction(): ((ctx: ActionExecContext<T, any, IDataProvider<T, any>>) => Observable<boolean>) | undefined;
+    get actionName(): string;
+    get className(): string;
+    get hasRunConfirmation(): boolean;
+    get runConfirmationIcon(): string | undefined;
+    get runConfirmationTitle(): string | undefined;
+    get runConfirmationMessage(): string | undefined;
+    get runConfirmationAcceptTitle(): string | undefined;
+    get runConfirmationRejectTitle(): string | undefined;
+    get hasRunNotificationSuccess(): boolean;
+    get runNotificationSuccessTitle(): string | undefined;
+    get runNotificationSuccessMessage(): string | undefined;
+    get hasRunNotificationError(): boolean;
+    get runNotificationErrorTitle(): string | undefined;
+    get runNotificationErrorMessage(): string | undefined;
+    withRunFunction<S>(fn: (ctx: ActionExecContext<T, S, IDataProvider<T, S>>) => Observable<T>): this;
+    withIsVisibleFunction<S>(fn: (ctx: ActionExecContext<T, S, IDataProvider<T, S>>) => Observable<boolean>): this;
+    withIsEnabledFunction<S>(fn: (ctx: ActionExecContext<T, S, IDataProvider<T, S>>) => Observable<boolean>): this;
+    withRouteTrigger(routeUrl: string): this;
+    withLevel(level: ActionLevelEnum): this;
+    /**
+     * Overrides default title key with model action key (${model.typeName}.actions.${actionName}). Not relevant if parentType name is provided.
+     */
+    withModelTitle(): this;
+    /**
+     * Overrides default title key (${actionName}.title). If null, no title will be shown.
+     * @param title Title i18n key or title.
+     */
+    withTitle(title: string | null): this;
+    withIcon(icon: string): this;
+    withTooltip(tooltip: string | null): this;
+    withClassName(className: string): this;
+    withPosition(position: ActionPositionEnum): this;
+    withRunConfirmation(icon?: string, title?: string, message?: string, acceptTitle?: string, rejectTitle?: string): this;
+    withRunNotificationSuccess(title?: string, message?: string, hasNotification?: boolean): void;
+    withRunNotificationError(title?: string, message?: string, hasNotification?: boolean): void;
+}
+export declare class ActionEditorDescriptor<T> extends ActionDescriptor<T> {
+    private readonly _editorDescriptor;
+    protected _editorTitle?: string;
+    private _hasFetchNotificationSuccess;
+    private _fetchNotificationSuccessTitle?;
+    private _fetchNotificationSuccessMessage?;
+    protected _fetchFunction?: (ctx: ActionExecContext<T, any, IEditorDataProvider<T, any>>) => Observable<T>;
+    protected _submitFunction?: (ctx: ActionExecContext<T, any, IEditorDataProvider<T, any>>) => Observable<T>;
+    constructor(editorDescriptor: EditorDescriptor<T>, actionName: string, parentType?: ClassType<any>, parentProperty?: string);
+    get editorTitle(): string | undefined;
+    get editorDescriptor(): EditorDescriptor<T>;
+    get hasFetchNotificationSuccess(): boolean;
+    get fetchNotificationSuccessTitle(): string | undefined;
+    get fetchNotificationSuccessMessage(): string | undefined;
+    get runFunction(): (ctx: ActionExecContext<T, any, IDataProvider<T, any>>) => Observable<T>;
+    get fetchFunction(): (ctx: ActionExecContext<T, any, IEditorDataProvider<T, any>>) => Observable<T>;
+    get submitFunction(): ((ctx: ActionExecContext<T, any, IEditorDataProvider<T, any>>) => Observable<T>) | undefined;
+    withEditorTitle(title: string): this;
+    withRunFunction<S>(fn: (ctx: ActionExecContext<T, S, IDataProvider<T, S>>) => Observable<T>): this;
+    withFetchFunction<S>(fn: (ctx: ActionExecContext<T, S, IEditorDataProvider<T, S>>) => Observable<T>): this;
+    withSubmitFunction<S>(fn: (ctx: ActionExecContext<T, S, IEditorDataProvider<T, S>>) => Observable<T>): this;
+    withFetchNotificationError(title?: string, message?: string, hasNotification?: boolean): void;
+}
+export declare class ActionEditorDetailsDescriptor<T> extends ActionEditorDescriptor<T> {
+    constructor(editorDescriptor: EditorDescriptor<T>);
+}
+export declare class ActionEditorAddDescriptor<T> extends ActionEditorDescriptor<T> {
+    constructor(editorDescriptor: EditorDescriptor<T>);
+}
+export declare class ActionEditorEditDescriptor<T> extends ActionEditorDescriptor<T> {
+    constructor(editorDescriptor: EditorDescriptor<T>);
+}
+export declare class ActionDeleteDescriptor<T> extends ActionDescriptor<T> {
+    constructor(model: ModelDescriptor<T>);
+}
+export declare enum ActionPositionEnum {
+    ToolbarLeft = 0,
+    ToolbarRight = 1,
+    TableHeader = 2,
+    RowInline = 3,
+    RowClick = 4
+}
+export declare enum ActionActivationTriggerEnum {
+    OnClick = 0,
+    OnRoute = 1
+}
+export declare enum ActionTypeEnum {
+    Direct = 0,
+    Editor = 1
+}
+export declare enum ActionLevelEnum {
+    Default = 0,
+    Primary = 1,
+    Secondary = 2,
+    Info = 3,
+    Help = 4,
+    Success = 5,
+    Warning = 6,
+    Danger = 7
+}

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

@@ -0,0 +1,255 @@
+import { Type } from '@angular/core';
+import { AbstractControl } from '@angular/forms';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { Observable } from 'rxjs';
+import { ClassType, EnumMemberType } from '../types';
+import { ILookupDataProvider, ITableDataProvider } from '../data-providers';
+import { ModelDescriptor, TableDescriptor, TableviewDescriptor, FieldValidator, ILookupDescriptor } from './';
+import { MediusQueryParam, MediusQueryResult } from '../api/models';
+export declare class EditorDescriptor<T> {
+    static readonly defaultGroupName = "_default";
+    private readonly _model;
+    private readonly _tabs;
+    private readonly _groups;
+    private readonly _fields;
+    private _currentTabGroup?;
+    private _currentGroup?;
+    private _disabled;
+    constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string);
+    get model(): ModelDescriptor<T>;
+    get tabs(): FieldTabGroupDescriptor<T>[];
+    get disabled(): boolean;
+    get fields(): AFieldDescriptor<any, T>[];
+    createTabGroup(name: string, title?: string): FieldTabGroupDescriptor<T>;
+    createFieldGroup(name: string, title?: string): FieldGroupDescriptor<T>;
+    addFieldDescriptor<FT>(field: AFieldDescriptor<FT, T>): this;
+    addField(property: string): FieldInputDescriptor<T>;
+    removeField(property: string): this;
+    getField(property: string): AFieldDescriptor<any, T> | null;
+    addFieldLookup<FT>(property: string, modelType: ClassType<FT>): FieldLookupDescriptor<FT, T>;
+    addFieldLookupEnum(property: string, options: Array<EnumMemberType>): FieldLookupEnumDescriptor<T>;
+    addFieldManyEditor<FT>(property: string, type: ClassType<FT>, tableviewDescriptor: TableviewDescriptor<FT>): FieldManyEditorDescriptor<FT, T>;
+    addFieldManyToManyEditor<FT>(property: string, type: ClassType<FT>, mainTableDescriptor: TableDescriptor<FT>, lookupTableDescriptor: TableDescriptor<FT>): FieldManyToManyEditorDescriptor<FT, T>;
+    withDisabled(disabled?: boolean): this;
+    addValidator(name: string, expression: (control: AbstractControl) => boolean): void;
+    copy(): EditorDescriptor<T>;
+    private createTabGroupDescriptor;
+    createFieldGroupDescriptor(fieldGroup: FieldGroupDescriptor<T>): this;
+    private createDefaultGroup;
+    private createDefaultTabGroup;
+}
+export declare abstract class AGenericFieldDescriptor<ET> {
+    protected readonly _editor: EditorDescriptor<ET>;
+    protected constructor(editor: EditorDescriptor<ET>);
+    get editor(): EditorDescriptor<ET>;
+}
+export declare abstract class AFieldDescriptor<T, ET> extends AGenericFieldDescriptor<ET> {
+    protected readonly _property: string;
+    protected _group?: AFieldGroupDescriptor<ET>;
+    protected _label?: string;
+    protected _placeholder?: string;
+    protected _required: boolean;
+    protected _disabled: boolean;
+    protected _className: string;
+    protected _getter?: (item: ET) => T;
+    protected _setter?: (item: ET, value: T) => void;
+    protected _validators: Array<FieldValidator>;
+    protected constructor(editor: EditorDescriptor<ET>, property: string);
+    abstract copy(): AFieldDescriptor<T, ET>;
+    get property(): string;
+    get group(): AFieldGroupDescriptor<ET> | undefined;
+    get label(): string | undefined;
+    get placeholder(): string | undefined;
+    get required(): boolean;
+    get disabled(): boolean;
+    get className(): string;
+    get getter(): ((item: ET) => T) | undefined;
+    get setter(): ((item: ET, value: T) => void) | undefined;
+    get validators(): FieldValidator[];
+    withLabel(label: string): this;
+    withPlaceholder(placeholder: string): this;
+    withRequired(required?: boolean): this;
+    withDisabled(disabled?: boolean): this;
+    withClassName(className: string): this;
+    withGetter(getter: (item: ET) => T): this;
+    withSetter(setter: (item: ET, value: T) => void): this;
+    withValidator(name: string, expression: (control: AbstractControl) => boolean, message: (err: any, field: FormlyFieldConfig) => string): this;
+    protected copyFieldsTo(obj: AFieldDescriptor<T, ET>): void;
+}
+export declare class FieldInputDescriptor<ET> extends AFieldDescriptor<string | number | boolean | Date, ET> {
+    private _fieldType;
+    private _rows?;
+    private _numberMin?;
+    private _numberMax?;
+    private _numberStep?;
+    private _numberMinFractionDigits?;
+    private _numberMaxFractionDigits?;
+    private _radioOptions;
+    private _datePickerFormat?;
+    private _datePickerMin?;
+    private _datePickerMax?;
+    private _datePickerShowTime;
+    private _maxLength?;
+    private _minLength?;
+    private _pattern?;
+    constructor(editor: EditorDescriptor<ET>, property: string);
+    get fieldType(): FieldInputDescriptor.TypeEnum;
+    get numberStep(): number | undefined;
+    get numberMin(): number | undefined;
+    get numberMax(): number | undefined;
+    get rows(): number | undefined;
+    get numberMinFractionDigits(): number | undefined;
+    get numberMaxFractionDigits(): number | undefined;
+    get radioOptions(): string[];
+    get datePickerFormat(): string | undefined;
+    get datePickerMin(): Date | undefined;
+    get datePickerMax(): Date | undefined;
+    get datePickerShowTime(): boolean;
+    get maxLength(): number | undefined;
+    get minLength(): number | undefined;
+    get pattern(): string | RegExp | undefined;
+    asText(minLength?: number, maxLength?: number, pattern?: string | RegExp): this;
+    asTextarea(rows?: number): this;
+    asNumber(step?: number, min?: number, max?: number, minFractionDigits?: number, maxFractionDigits?: number): this;
+    asSwitch(): this;
+    asRadio(options: Array<string>): this;
+    asDatePicker(format?: string, min?: Date, max?: Date, showTime?: boolean): this;
+    copy(): FieldInputDescriptor<ET>;
+}
+export declare namespace FieldInputDescriptor {
+    enum TypeEnum {
+        Text = 0,
+        Textarea = 1,
+        Number = 2,
+        Switch = 3,
+        Radio = 4,
+        Datepicker = 5
+    }
+}
+export declare class FieldLookupDescriptor<T, ET> extends AFieldDescriptor<T, ET> implements ILookupDescriptor<T> {
+    protected readonly _modelType: ClassType<T> | null;
+    protected _lookupType: FieldLookupDescriptor.LookupTypeEnum;
+    protected _itemsLabelProperty?: string;
+    protected _itemsValueProperty?: string;
+    protected _dataKeyProperty?: string;
+    protected _dataProvider?: ILookupDataProvider<T, any>;
+    constructor(editor: EditorDescriptor<ET>, property: string, modelType: ClassType<T> | null);
+    get modelType(): ClassType<T> | null;
+    get lookupType(): FieldLookupDescriptor.LookupTypeEnum;
+    get itemsLabelProperty(): string | undefined;
+    get itemsValueProperty(): string | undefined;
+    get dataKeyProperty(): string | undefined;
+    get dataProvider(): ILookupDataProvider<T, any> | undefined;
+    withItemsLabelProperty(itemsLabelProperty: string): this;
+    withItemsValueProperty(itemsValueProperty: string): this;
+    withDataKeyProperty(property: string): this;
+    withLookup<S>(lookup: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<T>>, serviceType?: Type<S>): this;
+    withLookupDataProvider(dataProvider: ILookupDataProvider<T, any>): this;
+    asAutocomplete(): this;
+    copy(): FieldLookupDescriptor<T, ET>;
+}
+export declare namespace FieldLookupDescriptor {
+    enum LookupTypeEnum {
+        Dropdown = 0,
+        Autocomplete = 1
+    }
+}
+export declare class FieldLookupEnumDescriptor<ET> extends FieldLookupDescriptor<EnumMemberType, ET> {
+    private readonly _enumName;
+    constructor(editor: EditorDescriptor<ET>, property: string, enumName: string, options: Array<EnumMemberType>);
+    get enumName(): string;
+    copy(): FieldLookupEnumDescriptor<ET>;
+}
+export declare class FieldManyToManyEditorDescriptor<T, ET> extends AFieldDescriptor<T, ET> {
+    private readonly _model;
+    private readonly _mainTableDescriptor;
+    private readonly _lookupTableDescriptor;
+    private _fieldType;
+    private _lookupTableDataProvider;
+    private _actions;
+    private _hasLookupExcludeValues;
+    private _excludeFilterProperty;
+    private _excludeValueProperty;
+    constructor(editor: EditorDescriptor<ET>, property: string, modelType: ClassType<T>, mainTableDescriptor: TableDescriptor<T>, lookupTableDescriptor: TableDescriptor<T>);
+    get mainTableDescriptor(): TableDescriptor<T>;
+    get lookupTableDescriptor(): TableDescriptor<T>;
+    get lookupTableDataProvider(): ITableDataProvider<T, any> | null;
+    get actions(): FieldManyToManyEditorDescriptor.ActionEnum[];
+    get fieldType(): FieldManyToManyEditorDescriptor.TypeEnum;
+    get hasLookupExcludeValues(): boolean;
+    get excludeFilterProperty(): string;
+    get excludeValueProperty(): string;
+    withLookup<S>(getAll: (queryParam: MediusQueryParam, service?: S) => Observable<MediusQueryResult<T>>, serviceType?: Type<S>): this;
+    withLookupDataProvider(dataProvider: ITableDataProvider<T, any>): this;
+    withActions(actions?: Array<FieldManyToManyEditorDescriptor.ActionEnum>): this;
+    withLookupExclude(filterProperty: string, valueProperty: string, hasLookupExclude?: boolean): this;
+    copy(): FieldManyToManyEditorDescriptor<T, ET>;
+}
+export declare namespace FieldManyToManyEditorDescriptor {
+    enum TypeEnum {
+        DialogTableMultiselect = 0
+    }
+    enum ActionEnum {
+        Add = 0,
+        Delete = 1
+    }
+}
+export declare class FieldManyEditorDescriptor<T, ET> extends AFieldDescriptor<T, ET> {
+    private readonly _modelType;
+    private readonly _tableviewDescriptor;
+    private _fieldType;
+    private _actions;
+    constructor(editor: EditorDescriptor<ET>, property: string, modelType: ClassType<T>, tableviewDescriptor: TableviewDescriptor<T>);
+    get tableviewDescriptor(): TableviewDescriptor<T>;
+    get tableDescriptor(): TableDescriptor<T>;
+    get editorForCreate(): EditorDescriptor<T>;
+    get editorForRead(): EditorDescriptor<T>;
+    get editorForUpdate(): EditorDescriptor<T>;
+    get fieldType(): FieldManyEditorDescriptor.TypeEnum;
+    get actions(): FieldManyEditorDescriptor.ActionEnum[];
+    withActions(actions?: Array<FieldManyToManyEditorDescriptor.ActionEnum>): this;
+    copy(): FieldManyEditorDescriptor<T, ET>;
+}
+export declare namespace FieldManyEditorDescriptor {
+    enum TypeEnum {
+        DialogEditor = 0
+    }
+    enum ActionEnum {
+        Add = 0,
+        Edit = 1,
+        Delete = 2
+    }
+}
+export declare abstract class AFieldGroupDescriptor<ET> extends AGenericFieldDescriptor<ET> {
+    protected readonly _name: string;
+    protected readonly _default: boolean;
+    protected _title?: string;
+    protected _fields: AGenericFieldDescriptor<ET>[];
+    protected _validators: Array<FieldValidator>;
+    protected constructor(editor: EditorDescriptor<ET>, name: string);
+    abstract get fields(): AGenericFieldDescriptor<ET>[];
+    abstract groupName(): string;
+    abstract addField(field: AGenericFieldDescriptor<ET>): this;
+    abstract copy(): AFieldGroupDescriptor<ET>;
+    get baseName(): string;
+    get name(): string;
+    get default(): boolean;
+    get title(): string | undefined;
+    get validators(): FieldValidator[];
+    withTitle(title: string): this;
+    withValidator(name: string, expression: (control: AbstractControl) => boolean): this;
+}
+export declare class FieldTabGroupDescriptor<ET> extends AFieldGroupDescriptor<ET> {
+    constructor(editor: EditorDescriptor<ET>, name: string);
+    get fields(): Array<FieldGroupDescriptor<ET>>;
+    groupName(): string;
+    addField(field: FieldGroupDescriptor<ET>): this;
+    copy(): FieldTabGroupDescriptor<ET>;
+}
+export declare class FieldGroupDescriptor<ET> extends AFieldGroupDescriptor<ET> {
+    constructor(editor: EditorDescriptor<ET>, name: string);
+    get fields(): Array<AFieldDescriptor<any, ET>>;
+    groupName(): string;
+    addField(field: AFieldDescriptor<any, ET>): this;
+    copy(): FieldGroupDescriptor<ET>;
+}

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

@@ -0,0 +1,18 @@
+import { AbstractControl } from '@angular/forms';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { Observable } from 'rxjs';
+export declare class FieldValidator {
+    private readonly _name;
+    private readonly _expression?;
+    private readonly _message?;
+    private readonly _options?;
+    constructor(name: string, expression?: (control: AbstractControl) => boolean, message?: (err: any, field: FormlyFieldConfig) => string | Observable<string>, options?: {
+        errorPath: string;
+    });
+    get name(): string;
+    get expression(): ((control: AbstractControl) => boolean) | undefined;
+    get message(): ((err: any, field: FormlyFieldConfig) => string | Observable<string>) | undefined;
+    get options(): {
+        errorPath: string;
+    } | undefined;
+}

package/{src/lib/descriptors/lookup.descriptor.ts → lib/descriptors/lookup.descriptor.d.ts}

@@ -1,13 +1,10 @@
-import {Type} from '@angular/core';
-
-import {Observable} from 'rxjs';
-
-import {ILookupDataProvider} from '../data-providers';
-import {ClassType} from '../types';
-import {MediusQueryParam} from '../api/models';
-
+import { Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ILookupDataProvider } from '../data-providers';
+import { ClassType } from '../types';
+import { MediusQueryParam } from '../api/models';
 export interface ILookupDescriptor<T> {
-    modelType: ClassType<T>|null;
+    modelType: ClassType<T> | null;
     itemsLabelProperty?: string;
     itemsValueProperty?: string;
     dataKeyProperty?: string;

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

@@ -0,0 +1,15 @@
+import { ClassType } from '../types';
+export declare class ModelDescriptor<T> {
+    private readonly _type;
+    private readonly _typeName;
+    private _idPropertyName?;
+    private _titlePropertyName?;
+    constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string);
+    get type(): ClassType<T>;
+    get typeName(): string;
+    get idPropertyName(): string | undefined;
+    get titlePropertyName(): string | undefined;
+    withIdPropertyName(idProperty: string): this;
+    withTitlePropertyName(titleProperty: string): this;
+    copy(): ModelDescriptor<T>;
+}

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

@@ -0,0 +1,164 @@
+import { Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ModelDescriptor } from './model.descriptor';
+import { ILookupDescriptor } from './lookup.descriptor';
+import { ClassType } from '../types';
+import { ILookupDataProvider } from '../data-providers';
+import { MediusQueryParam } from '../api/models';
+export declare class TableDescriptor<T> {
+    private readonly _model;
+    private _filterDisplay;
+    private _paginationMode;
+    private _columns;
+    private _title?;
+    private _dataKeyProperty?;
+    private _hasDefaultSort;
+    private _defaultSortProperty;
+    private _defaultSortAsc;
+    private _rowHeight;
+    private _tableFullHeightOffset;
+    constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string);
+    get model(): ModelDescriptor<T>;
+    get filterDisplay(): TableDescriptor.FilterDisplayEnum;
+    get paginationMode(): TableDescriptor.PaginationModeEnum;
+    get columns(): ColumnDescriptor<any, T>[];
+    get title(): string | undefined;
+    get dataKeyProperty(): string | undefined;
+    get hasDefaultSort(): boolean;
+    get defaultSortProperty(): string[];
+    get defaultSortAsc(): boolean[];
+    get rowHeight(): number;
+    get tableFullHeightOffset(): number;
+    addColumnDescriptor<CT>(column: ColumnDescriptor<CT, T>): TableDescriptor<T>;
+    addColumn(property: string): ColumnDescriptor<string, T>;
+    addColumnNumber(property: string, displayFormat?: string): ColumnDescriptor<number, T>;
+    addColumnDate(property: string, displayFormat?: string): ColumnDescriptor<Date, T>;
+    addColumnBoolean(property: string): ColumnDescriptor<boolean, T>;
+    addColumnObject<CT>(property: string, modelType: ClassType<CT>, displayProperty: string): ColumnDescriptor<CT, T>;
+    withFilterDisplay(filterDisplayType: TableDescriptor.FilterDisplayEnum): this;
+    withPaginationMode(paginationMode: TableDescriptor.PaginationModeEnum): this;
+    withTitle(title: string): TableDescriptor<T>;
+    withDataKeyProperty(property: string): TableDescriptor<T>;
+    withDefaultSort(property: string, asc?: boolean): TableDescriptor<T>;
+    withRowHeight(rowHeight: number): TableDescriptor<T>;
+    withTableFullHeightOffset(tableFullHeightOffset: number): TableDescriptor<T>;
+    private setDataKeyFromColumn;
+    copy(): TableDescriptor<T>;
+}
+export declare namespace TableDescriptor {
+    enum PaginationModeEnum {
+        Pagination = 0,
+        InfiniteScroll = 1
+    }
+    enum FilterDisplayEnum {
+        Row = 0,
+        Menu = 1
+    }
+}
+export declare class ColumnDescriptor<T, TT> {
+    private readonly _table;
+    private readonly _property;
+    private _modelType;
+    private _columnType;
+    private _title?;
+    private _displayPropertyPath?;
+    private _isSortEnabled;
+    private _filterDescriptor?;
+    private _displayFormat?;
+    constructor(table: TableDescriptor<TT>, property: string);
+    get table(): TableDescriptor<TT>;
+    get property(): string;
+    get modelType(): ClassType<T> | null;
+    get displayPropertyPath(): string | undefined;
+    get title(): string | undefined;
+    get isSortEnabled(): boolean;
+    get columnType(): ColumnDescriptor.TypeEnum;
+    get filterDescriptor(): FilterDescriptor<T> | undefined;
+    get displayFormat(): string | undefined;
+    asType(type?: ColumnDescriptor.TypeEnum): this;
+    asNumber(displayFormat?: string): this;
+    asDate(displayFormat?: string): this;
+    asBoolean(): this;
+    withModelType(modelType: ClassType<T>): this;
+    withTitle(title: string): this;
+    withDisplayPropertyPath(displayPropertyPath: string): this;
+    withFilter(): FilterDescriptor<T>;
+    withFilterLookup(): FilterLookupDescriptor<T>;
+    withSort(isEnabled?: boolean): this;
+    copy(): ColumnDescriptor<T, TT>;
+}
+export declare namespace ColumnDescriptor {
+    enum TypeEnum {
+        String = 0,
+        Number = 1,
+        Boolean = 2,
+        Date = 3
+    }
+}
+export declare class FilterDescriptor<T> {
+    protected readonly _property: string;
+    protected _filterType: FilterDescriptor.TypeEnum;
+    protected _filterProperty?: string;
+    protected _placeholder?: string;
+    protected _className: string;
+    constructor(property: string);
+    get property(): string;
+    get filterType(): FilterDescriptor.TypeEnum;
+    get filterProperty(): string | undefined;
+    get placeholder(): string | undefined;
+    get className(): string;
+    asFilterType(filterType: ColumnDescriptor.TypeEnum): this;
+    /**
+     * Sets different filter property name instead of default property. Use this if API requires different property provided to perform correct filter.
+     * @param filterProperty
+     */
+    withFilterProperty(filterProperty: string): this;
+    withPlaceholder(placeholder: string): this;
+    withClassName(className: string): this;
+    protected copyFieldsTo(descriptor: FilterDescriptor<T>): void;
+    copy(): FilterDescriptor<T>;
+}
+export declare namespace FilterDescriptor {
+    enum TypeEnum {
+        String = 0,
+        Number = 1,
+        Boolean = 2,
+        Date = 3,
+        Lookup = 4
+    }
+}
+export declare class FilterLookupDescriptor<T> extends FilterDescriptor<T> implements ILookupDescriptor<T> {
+    private readonly _modelType;
+    private _lookupType?;
+    private _dataProvider?;
+    private _itemsLabelProperty?;
+    private _itemsValueProperty?;
+    private _dataKeyProperty?;
+    private _multiselect;
+    protected _dropdownClassName: string;
+    constructor(property: string, modelType: ClassType<T> | null);
+    get modelType(): ClassType<T> | null;
+    get lookupType(): FilterLookupDescriptor.LookupTypeEnum | undefined;
+    get itemsLabelProperty(): string | undefined;
+    get itemsValueProperty(): string | undefined;
+    get dataKeyProperty(): string | undefined;
+    get dataProvider(): ILookupDataProvider<T, any> | undefined;
+    get multiselect(): boolean;
+    withItemsLabelProperty(itemsLabelProperty: string): this;
+    withItemsValueProperty(itemsValueProperty: string): this;
+    withDataKeyProperty(dataKeyProperty: string): this;
+    get dropdownClassName(): string;
+    withLookup<S>(lookup: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<T>>, serviceType?: Type<S>): this;
+    withLookupDataProvider(dataProvider: ILookupDataProvider<T, any>): this;
+    withMultiselect(multiselect?: boolean): this;
+    withDropdownClassName(dropdownClassName: string): this;
+    asAutocomplete(): this;
+    protected copyFieldsTo(descriptor: FilterLookupDescriptor<T>): void;
+    copy(): FilterLookupDescriptor<T>;
+}
+export declare namespace FilterLookupDescriptor {
+    enum LookupTypeEnum {
+        Dropdown = 0,
+        Autocomplete = 1
+    }
+}

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

@@ -0,0 +1,39 @@
+import { AbstractControl } from '@angular/forms';
+import { ModelDescriptor, AFieldDescriptor, EditorDescriptor, FieldInputDescriptor, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor, ColumnDescriptor, TableDescriptor } from './';
+import { ClassType, EnumMemberType } from '../types';
+export declare class TableviewDescriptor<T> {
+    private readonly _model;
+    private _table;
+    private _viewEditor;
+    private _addEditor;
+    private _editEditor;
+    private _tableTitle;
+    constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string);
+    get model(): ModelDescriptor<T>;
+    get table(): TableDescriptor<T>;
+    get viewEditor(): EditorDescriptor<T>;
+    get addEditor(): EditorDescriptor<T>;
+    get editEditor(): EditorDescriptor<T>;
+    get tableTitle(): string;
+    withTableDescriptor(descriptor: TableDescriptor<T>): this;
+    withViewDescriptor(descriptor: EditorDescriptor<T>): this;
+    withAddDescriptor(descriptor: EditorDescriptor<T>): this;
+    withEditDescriptor(descriptor: EditorDescriptor<T>): this;
+    withTableTitle(title: string): this;
+    withValidator(name: string, expression: (control: AbstractControl) => boolean): this;
+    addColumnDescriptor<CT>(column: ColumnDescriptor<CT, T>): TableDescriptor<T>;
+    addColumn(property: string): ColumnDescriptor<string, T>;
+    addColumnNumber(property: string, displayFormat?: string): ColumnDescriptor<number, T>;
+    addColumnDate(property: string, displayFormat?: string): ColumnDescriptor<Date, T>;
+    addColumnBoolean(property: string): ColumnDescriptor<boolean, T>;
+    addColumnObject<CT>(property: string, modelType: ClassType<CT>, displayProperty: string): ColumnDescriptor<CT, T>;
+    createTabGroup(name: string, title?: string): this;
+    createFieldGroup(name: string, title?: string): this;
+    addFieldDescriptor<FT>(field: AFieldDescriptor<FT, T>): this;
+    addField(property: string): FieldInputDescriptor<T>;
+    addFieldLookup<FT>(property: string, modelType: ClassType<FT>): FieldLookupDescriptor<FT, T>;
+    addFieldLookupEnum(property: string, options: Array<EnumMemberType>): FieldLookupEnumDescriptor<T>;
+    addFieldManyEditor<FT>(property: string, type: ClassType<FT>, tableviewDescriptor: TableviewDescriptor<FT>): FieldManyEditorDescriptor<FT, T>;
+    addFieldManyToManyEditor<FT>(property: string, type: ClassType<FT>, mainTableDescriptor: TableDescriptor<FT>, lookupTableDescriptor: TableDescriptor<FT>): FieldManyToManyEditorDescriptor<FT, T>;
+    copy(): TableviewDescriptor<T>;
+}