@mediusinc/mng-commons 0.3.2 → 0.4.1

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

@@ -0,0 +1,301 @@
+import { Type } from '@angular/core';
+import { AbstractControl } from '@angular/forms';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { Observable, Subject } from 'rxjs';
+import { MediusQueryParam, MediusQueryResult } from '../api/models';
+import { MngFormFieldEvent, MngFormFieldEventData, MngFormFieldEventTypeEnum } from '../components/form/models';
+import { ILookupDataProvider, ITableDataProvider } from '../data-providers';
+import { EnumValue } from '../models';
+import { ClassType, EnumConstantType, EnumType } from '../types';
+import { ActionDescriptor, EditorDescriptor, FieldValidator, ILookupDescriptor, TableDescriptor, TableviewDescriptor } from './';
+import { FieldConfig, FieldLookupConfig } from './field.descriptor.interface';
+export declare abstract class AGenericFieldDescriptor<ET> {
+    protected readonly _editor: EditorDescriptor<ET>;
+    protected _config: FieldConfig;
+    protected constructor(editor: EditorDescriptor<ET>);
+    get editor(): EditorDescriptor<ET>;
+    get config(): FieldConfig;
+    withConfig(config: FieldConfig): this;
+}
+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 _helpText?: string;
+    protected _required: boolean;
+    protected _disabled: boolean;
+    protected _defaultValue?: T;
+    protected _getter?: (item: ET) => T;
+    protected _setter?: (item: ET, value: T) => void;
+    protected _validators: Array<FieldValidator>;
+    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 _className: string;
+    protected _labelClassName: string;
+    protected _inputClassName: string;
+    protected _size: FieldDescriptor.SizeEnum;
+    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 | undefined;
+    get placeholder(): string | undefined;
+    get helpText(): string | undefined;
+    get required(): boolean;
+    get disabled(): boolean;
+    get defaultValue(): T | undefined;
+    get getter(): ((item: ET) => T) | undefined;
+    get setter(): ((item: ET, value: T) => void) | undefined;
+    get validators(): FieldValidator[];
+    get requiredExpression(): string | Observable<boolean> | ((model: any, formState?: any, field?: FormlyFieldConfig | undefined) => boolean) | undefined;
+    get disabledExpression(): string | Observable<boolean> | ((model: any, formState?: any, field?: FormlyFieldConfig | undefined) => boolean) | undefined;
+    get hiddenExpression(): string | Observable<boolean> | ((model: any, formState?: any, field?: FormlyFieldConfig | undefined) => boolean) | undefined;
+    get className(): string;
+    get labelClassName(): string;
+    get inputClassName(): string;
+    get size(): FieldDescriptor.SizeEnum;
+    get isSizeSmall(): boolean;
+    get isSizeLarge(): boolean;
+    abstract copy(): AFieldDescriptor<T, ET>;
+    withLabel(label: string): this;
+    withPlaceholder(placeholder: string): this;
+    withHelpText(helpText: string): this;
+    withRequired(required?: boolean, requiredExpression?: string | ((model: any, formState?: any, field?: FormlyFieldConfig) => boolean) | Observable<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;
+    withDefaultValue(defaultValue: T): 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;
+    withClassName(className: string, labelClassName?: string, inputClassName?: string): this;
+    withSize(size?: FieldDescriptor.SizeEnum): this;
+    nextEvent(type: MngFormFieldEventTypeEnum, cmpType: Type<any>, cmpInstance: any, data?: MngFormFieldEventData<T, ET>): void;
+    get events$(): Observable<MngFormFieldEvent<T, ET>>;
+    protected copyFieldsTo(obj: AFieldDescriptor<T, ET>): void;
+}
+export declare namespace FieldDescriptor {
+    enum SizeEnum {
+        Small = 0,
+        Normal = 1,
+        Large = 2
+    }
+}
+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 _numberUseGrouping;
+    private _radioOptions;
+    private _datePickerFormat?;
+    private _datePickerMin?;
+    private _datePickerMax?;
+    private _datePickerShowTime;
+    private _maxLength?;
+    private _minLength?;
+    private _pattern?;
+    private _mask?;
+    private _slotChar?;
+    private _customComponentName?;
+    constructor(editor: EditorDescriptor<ET>, property: string);
+    get fieldType(): FieldInputDescriptor.TypeEnum;
+    get rows(): number | undefined;
+    get numberMin(): number | undefined;
+    get numberMax(): number | undefined;
+    get numberStep(): number | undefined;
+    get numberMinFractionDigits(): number | undefined;
+    get numberMaxFractionDigits(): number | undefined;
+    get numberUseGrouping(): boolean;
+    get radioOptions(): EnumValue<string | number | boolean | Date>[];
+    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;
+    get mask(): string | undefined;
+    get slotChar(): string | undefined;
+    get customComponentName(): string | undefined;
+    asHidden(): this;
+    asText(minLength?: number, maxLength?: number, pattern?: string | RegExp, isEmail?: boolean): this;
+    asTextarea(rows?: number, minLength?: number, maxLength?: number, pattern?: string | RegExp): this;
+    asNumber(step?: number, min?: number, max?: number, minFractionDigits?: number, maxFractionDigits?: number, numberUseGrouping?: boolean): this;
+    asSwitch(): this;
+    asRadio(options: Array<string | number>, optionsTitlePath?: string): this;
+    asRadioFromEnum(enumType: EnumType, optionsTitlePath?: string | null, values?: Array<EnumConstantType>, nameAsValue?: boolean): this;
+    asDatePicker(format?: string, min?: Date, max?: Date, showTime?: boolean): this;
+    asMask(mask: string, slotChar: string): this;
+    asCustomComponent(customComponentName: string): this;
+    copy(): FieldInputDescriptor<ET>;
+}
+export declare namespace FieldInputDescriptor {
+    enum TypeEnum {
+        Hidden = 0,
+        Text = 1,
+        Textarea = 2,
+        Number = 3,
+        Switch = 4,
+        Radio = 5,
+        Datepicker = 6,
+        Mask = 7,
+        Custom = 8
+    }
+}
+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 _itemsLabelTranslate: boolean;
+    protected _itemsValueProperty?: string;
+    protected _itemsDisabledProperty?: string;
+    protected _dataKeyProperty?: string;
+    protected _dataProvider?: ILookupDataProvider<T, any>;
+    protected _dropdownClassName: string;
+    protected _autocompleteOpenOnFocus: boolean;
+    protected _autocompleteInlineSearch: boolean;
+    protected _dialogTableDescriptor?: TableDescriptor<T>;
+    protected _dialogTableDataProvider?: ITableDataProvider<T, any>;
+    constructor(editor: EditorDescriptor<ET>, property: string, modelType: ClassType<T> | null);
+    get lookupType(): FieldLookupDescriptor.LookupTypeEnum;
+    get itemsLabelProperty(): string | undefined;
+    get itemsLabelTranslate(): boolean;
+    get itemsValueProperty(): string | undefined;
+    get itemsDisabledProperty(): string | undefined;
+    get dataKeyProperty(): string | undefined;
+    get dataProvider(): ILookupDataProvider<T, any> | undefined;
+    get autocompleteOpenOnFocus(): boolean;
+    get autocompleteInlineSearch(): boolean;
+    get dropdownClassName(): string;
+    get modelType(): ClassType<T> | null;
+    get dialogTableDescriptor(): TableDescriptor<T> | undefined;
+    get dialogTableDataProvider(): ITableDataProvider<T, any> | undefined;
+    withItemsLabelProperty(itemsLabelProperty: string, translate?: boolean): this;
+    withItemsValueProperty(itemsValueProperty: string): this;
+    withItemsDisabledProperty(itemsDisabledProperty: 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;
+    withConfig(config: FieldLookupConfig): this;
+    asAutocomplete(openOnFocus?: boolean, inlineSearch?: boolean): this;
+    asDialog(lookupTableDescriptor: TableDescriptor<T>, tableDataProvider?: ITableDataProvider<T, any>): this;
+    copy(): FieldLookupDescriptor<T, ET>;
+}
+export declare namespace FieldLookupDescriptor {
+    enum LookupTypeEnum {
+        Dropdown = 0,
+        Autocomplete = 1,
+        Dialog = 2
+    }
+}
+export declare class FieldLookupEnumDescriptor<ET> extends FieldLookupDescriptor<EnumValue<string | number>, ET> {
+    private readonly _enumType;
+    private readonly _optionEnumValues;
+    private readonly _nameAsValue;
+    constructor(editor: EditorDescriptor<ET>, property: string, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null);
+    get enumType(): EnumType;
+    withDisabledOptions(...disabledOptions: Array<EnumConstantType>): this;
+    asAutocomplete(openOnFocus?: boolean): this;
+    copy(): FieldLookupEnumDescriptor<ET>;
+}
+export declare class FieldManyToManyEditorDescriptor<T, ET> extends AFieldDescriptor<T, ET> {
+    private readonly _mainTableDescriptor;
+    private readonly _lookupTableDescriptor;
+    private _fieldType;
+    private _lookupTableDataProvider;
+    private _actions;
+    private _hasLookupExcludeValues;
+    private _excludeFilterProperty;
+    private _excludeValueProperty;
+    constructor(editor: EditorDescriptor<ET>, property: string, mainTableDescriptor: TableDescriptor<T>, lookupTableDescriptor: TableDescriptor<T>);
+    get fieldType(): FieldManyToManyEditorDescriptor.TypeEnum;
+    get lookupTableDataProvider(): ITableDataProvider<T, any> | null;
+    get actions(): FieldManyToManyEditorDescriptor.ActionEnum[];
+    get hasLookupExcludeValues(): boolean;
+    get excludeFilterProperty(): string;
+    get excludeValueProperty(): string;
+    get mainTableDescriptor(): TableDescriptor<T>;
+    get lookupTableDescriptor(): TableDescriptor<T>;
+    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 _tableviewDescriptor;
+    private _fieldType;
+    private _fieldActions;
+    private _actions;
+    constructor(editor: EditorDescriptor<ET>, property: string, tableviewDescriptor: TableviewDescriptor<T>);
+    get fieldType(): FieldManyEditorDescriptor.TypeEnum;
+    get fieldActions(): FieldManyEditorDescriptor.ActionEnum[];
+    get actions(): ActionDescriptor<T>[];
+    get tableviewDescriptor(): TableviewDescriptor<T>;
+    get tableDescriptor(): TableDescriptor<T>;
+    get editorForCreate(): EditorDescriptor<T>;
+    get editorForRead(): EditorDescriptor<T>;
+    get editorForUpdate(): EditorDescriptor<T>;
+    withFieldAction(action: FieldManyEditorDescriptor.ActionEnum): this;
+    withFieldActions(actions: FieldManyEditorDescriptor.ActionEnum[]): this;
+    withAction(action: ActionDescriptor<T>): this;
+    copy(): FieldManyEditorDescriptor<T, ET>;
+}
+export declare namespace FieldManyEditorDescriptor {
+    enum TypeEnum {
+        DialogEditor = 0
+    }
+    enum ActionEnum {
+        View = 0,
+        Add = 1,
+        Edit = 2,
+        Delete = 3
+    }
+}
+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);
+    get title(): string | undefined;
+    abstract get fields(): AGenericFieldDescriptor<ET>[];
+    get validators(): FieldValidator[];
+    get baseName(): string;
+    get name(): string;
+    get default(): boolean;
+    abstract groupName(): string;
+    abstract addField(field: AGenericFieldDescriptor<ET>): this;
+    abstract copy(): AFieldGroupDescriptor<ET>;
+    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/filter.descriptor.d.ts

@@ -0,0 +1,108 @@
+import { Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { MediusQueryParam } from '../api/models';
+import { ILookupDataProvider } from '../data-providers';
+import { EnumValue } from '../models';
+import { ClassType, EnumConstantType, EnumType } from '../types';
+import { ILookupDescriptor } from './lookup.descriptor';
+export declare class FilterDescriptor<T> {
+    protected readonly _property: string;
+    protected _filterType: FilterDescriptor.TypeEnum;
+    protected _filterProperty?: string;
+    protected _matchModes: string[] | null;
+    protected _placeholder?: string;
+    protected _className: string;
+    constructor(property: string);
+    get filterType(): FilterDescriptor.TypeEnum;
+    get filterProperty(): string | undefined;
+    get matchModes(): string[] | null;
+    get placeholder(): string | undefined;
+    get className(): string;
+    get property(): string;
+    asFilterType(filterType: FilterDescriptor.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;
+    withMatchModes(matchModes: Array<FilterDescriptor.MatchModeEnum>): this;
+    copy(): FilterDescriptor<T>;
+    protected copyFieldsTo(descriptor: FilterDescriptor<T>): void;
+}
+export declare namespace FilterDescriptor {
+    enum TypeEnum {
+        String = 0,
+        Number = 1,
+        Boolean = 2,
+        Date = 3,
+        Lookup = 4,
+        LookupEnum = 5
+    }
+    enum MatchModeEnum {
+        StartsWith = "startsWith",
+        Contains = "contains",
+        EndsWith = "endsWith",
+        Equals = "equals",
+        NotEquals = "notEquals",
+        In = "in",
+        LessThan = "lt",
+        LessThanOrEqualTo = "lte",
+        GreaterThan = "gt",
+        GreaterThanOrEqualTo = "gte",
+        Between = "between",
+        DateIs = "dateIs",
+        DateIsNot = "dateIsNot",
+        DateBefore = "dateBefore",
+        DateAfter = "dateAfter"
+    }
+}
+export declare class FilterLookupDescriptor<T> extends FilterDescriptor<T> implements ILookupDescriptor<T> {
+    protected readonly _modelType: ClassType<T> | null;
+    protected _lookupType?: FilterLookupDescriptor.LookupTypeEnum;
+    protected _dataProvider?: ILookupDataProvider<T, any>;
+    protected _itemsLabelProperty?: string;
+    protected _itemsLabelTranslate: boolean;
+    protected _itemsValueProperty?: string;
+    protected _dataKeyProperty?: string;
+    protected _multiselect: boolean;
+    protected _dropdownClassName: string;
+    protected _autocompleteOpenOnFocus: boolean;
+    protected _autocompleteInlineSearch: boolean;
+    constructor(property: string, modelType: ClassType<T> | null);
+    get lookupType(): FilterLookupDescriptor.LookupTypeEnum | undefined;
+    get dataProvider(): ILookupDataProvider<T, any> | undefined;
+    get itemsLabelProperty(): string | undefined;
+    get itemsLabelTranslate(): boolean;
+    get itemsValueProperty(): string | undefined;
+    get dataKeyProperty(): string | undefined;
+    get multiselect(): boolean;
+    get autocompleteOpenOnFocus(): boolean;
+    get autocompleteInlineSearch(): boolean;
+    get dropdownClassName(): string;
+    get modelType(): ClassType<T> | null;
+    withItemsLabelProperty(itemsLabelProperty: string, translate?: boolean): this;
+    withItemsValueProperty(itemsValueProperty: string): this;
+    withDataKeyProperty(dataKeyProperty: string): this;
+    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(openOnFocus?: boolean, inlineSearch?: boolean): this;
+    copy(): FilterLookupDescriptor<T>;
+    protected copyFieldsTo(filter: FilterLookupDescriptor<T>): void;
+}
+export declare class FilterLookupEnumDescriptor extends FilterLookupDescriptor<EnumValue<string | number>> {
+    private readonly _enumType;
+    constructor(property: string, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null);
+    get enumType(): EnumType;
+    asAutocomplete(openOnFocus?: boolean): this;
+    copy(): FilterLookupEnumDescriptor;
+}
+export declare namespace FilterLookupDescriptor {
+    enum LookupTypeEnum {
+        Dropdown = 0,
+        Autocomplete = 1
+    }
+}

package/lib/descriptors/index.d.ts

@@ -1,6 +1,10 @@
 export * from './action.descriptor';
+export * from './column.descriptor';
 export * from './editor.descriptor';
+export * from './field.descriptor';
+export * from './field.descriptor.interface';
 export * from './field.validator';
+export * from './filter.descriptor';
 export * from './lookup.descriptor';
 export * from './model.descriptor';
 export * from './table.descriptor';

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

@@ -1,10 +1,7 @@
 import { Type } from '@angular/core';
-import { Observable } from 'rxjs';
-import { MediusQueryParam } from '../api/models';
-import { ILookupDataProvider } from '../data-providers';
-import { EnumValue } from '../models';
-import { ClassType, EnumConstantType, EnumType } from '../types';
-import { ILookupDescriptor } from './lookup.descriptor';
+import { IColumnValueComponent } from '../models';
+import { ClassType, EnumType } from '../types';
+import { ColumnDescriptor } from './column.descriptor';
 import { ModelDescriptor } from './model.descriptor';
 export declare class TableDescriptor<T> {
     private readonly _model;
@@ -37,8 +34,8 @@ export declare class TableDescriptor<T> {
     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>;
-    addColumnEnum(property: string, enumType: EnumType, nameAsValue?: boolean, titlePath?: string | null): ColumnDescriptor<boolean, T>;
-    addColumnObject<CT>(property: string, modelType: ClassType<CT>, displayProperty: string): ColumnDescriptor<CT, T>;
+    addColumnEnum(property: string, enumType: EnumType, nameAsValue?: boolean, titlePath?: string | null): ColumnDescriptor<EnumType, T>;
+    addColumnCustomComponent(property: string, customComponentType: Type<IColumnValueComponent<T>>): ColumnDescriptor<any, T>;
     withFilterDisplay(filterDisplayType: TableDescriptor.FilterDisplayEnum): this;
     withPaginationMode(paginationMode: TableDescriptor.PaginationModeEnum): this;
     withTitle(title: string): TableDescriptor<T>;
@@ -60,154 +57,3 @@ export declare namespace TableDescriptor {
         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?;
-    private _enumType?;
-    private _enumTitlePath?;
-    private _enumNameAsValue;
-    private _booleanAsIcon;
-    private _booleanYes?;
-    private _booleanNo?;
-    constructor(table: TableDescriptor<TT>, property: string);
-    get modelType(): ClassType<T> | null;
-    get columnType(): ColumnDescriptor.TypeEnum;
-    get title(): string | undefined;
-    get displayPropertyPath(): string | undefined;
-    get isSortEnabled(): boolean;
-    get filterDescriptor(): FilterDescriptor<T> | undefined;
-    get displayFormat(): string | undefined;
-    get table(): TableDescriptor<TT>;
-    get property(): string;
-    get enumType(): EnumType | undefined;
-    get enumTitlePath(): string | null | undefined;
-    get enumNameAsValue(): boolean;
-    get booleanAsIcon(): boolean;
-    get booleanYes(): string | undefined;
-    get booleanNo(): string | undefined;
-    asType(type?: ColumnDescriptor.TypeEnum): this;
-    asNumber(displayFormat?: string): this;
-    asDate(displayFormat?: string): this;
-    asBoolean(yes?: string, no?: string, asIcon?: boolean): this;
-    asEnum(enumType: EnumType, nameAsValue?: boolean, titlePath?: string | null): this;
-    withModelType(modelType: ClassType<T>): this;
-    withTitle(title: string): this;
-    withDisplayPropertyPath(displayPropertyPath: string): this;
-    withFilter(): FilterDescriptor<T>;
-    withFilterLookup(): FilterLookupDescriptor<T>;
-    withFilterLookupEnum(options?: Array<EnumConstantType>): FilterLookupEnumDescriptor;
-    withSort(isEnabled?: boolean): this;
-    copy(): ColumnDescriptor<T, TT>;
-}
-export declare namespace ColumnDescriptor {
-    enum TypeEnum {
-        String = 0,
-        Number = 1,
-        Boolean = 2,
-        Date = 3,
-        Enum = 4
-    }
-}
-export declare class FilterDescriptor<T> {
-    protected readonly _property: string;
-    protected _filterType: FilterDescriptor.TypeEnum;
-    protected _filterProperty?: string;
-    protected _matchModes: string[] | null;
-    protected _placeholder?: string;
-    protected _className: string;
-    constructor(property: string);
-    get filterType(): FilterDescriptor.TypeEnum;
-    get filterProperty(): string | undefined;
-    get matchModes(): string[] | null;
-    get placeholder(): string | undefined;
-    get className(): string;
-    get property(): string;
-    asFilterType(filterType: FilterDescriptor.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;
-    withMatchModes(matchModes: Array<FilterDescriptor.MatchModeEnum>): this;
-    copy(): FilterDescriptor<T>;
-    protected copyFieldsTo(descriptor: FilterDescriptor<T>): void;
-}
-export declare namespace FilterDescriptor {
-    enum TypeEnum {
-        String = 0,
-        Number = 1,
-        Boolean = 2,
-        Date = 3,
-        Lookup = 4,
-        LookupEnum = 5
-    }
-    enum MatchModeEnum {
-        StartsWith = "startsWith",
-        Contains = "contains",
-        EndsWith = "endsWith",
-        Equals = "equals",
-        NotEquals = "notEquals",
-        In = "in",
-        LessThan = "lt",
-        LessThanOrEqualTo = "lte",
-        GreaterThan = "gt",
-        GreaterThanOrEqualTo = "gte",
-        Between = "between",
-        DateIs = "dateIs",
-        DateIsNot = "dateIsNot",
-        DateBefore = "dateBefore",
-        DateAfter = "dateAfter"
-    }
-}
-export declare class FilterLookupDescriptor<T> extends FilterDescriptor<T> implements ILookupDescriptor<T> {
-    private readonly _modelType;
-    private _lookupType?;
-    private _dataProvider?;
-    private _itemsLabelProperty?;
-    private _itemsLabelTranslate;
-    private _itemsValueProperty?;
-    private _dataKeyProperty?;
-    private _multiselect;
-    protected _dropdownClassName: string;
-    constructor(property: string, modelType: ClassType<T> | null);
-    get lookupType(): FilterLookupDescriptor.LookupTypeEnum | undefined;
-    get dataProvider(): ILookupDataProvider<T, any> | undefined;
-    get itemsLabelProperty(): string | undefined;
-    get itemsLabelTranslate(): boolean;
-    get itemsValueProperty(): string | undefined;
-    get dataKeyProperty(): string | undefined;
-    get multiselect(): boolean;
-    get dropdownClassName(): string;
-    get modelType(): ClassType<T> | null;
-    withItemsLabelProperty(itemsLabelProperty: string, translate?: boolean): this;
-    withItemsValueProperty(itemsValueProperty: string): this;
-    withDataKeyProperty(dataKeyProperty: string): this;
-    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;
-    copy(): FilterLookupDescriptor<T>;
-    protected copyFieldsTo(descriptor: FilterLookupDescriptor<T>): void;
-}
-export declare class FilterLookupEnumDescriptor extends FilterLookupDescriptor<EnumValue<string | number>> {
-    private readonly _enumType;
-    constructor(property: string, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null);
-    get enumType(): EnumType;
-    copy(): FilterLookupEnumDescriptor;
-}
-export declare namespace FilterLookupDescriptor {
-    enum LookupTypeEnum {
-        Dropdown = 0,
-        Autocomplete = 1
-    }
-}

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

@@ -1,4 +1,6 @@
+import { Type } from '@angular/core';
 import { AbstractControl } from '@angular/forms';
+import { IColumnValueComponent } from '../models';
 import { ClassType, EnumConstantType, EnumType } from '../types';
 import { AFieldDescriptor, ColumnDescriptor, EditorDescriptor, FieldInputDescriptor, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor, ModelDescriptor, TableDescriptor } from './';
 export declare class TableviewDescriptor<T> {
@@ -26,8 +28,8 @@ export declare class TableviewDescriptor<T> {
     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>;
-    addColumnEnum(property: string, enumType: EnumType, nameAsValue?: boolean, titlePath?: string | null): ColumnDescriptor<boolean, T>;
-    addColumnObject<CT>(property: string, modelType: ClassType<CT>, displayProperty: string): ColumnDescriptor<CT, T>;
+    addColumnEnum(property: string, enumType: EnumType, nameAsValue?: boolean, titlePath?: string | null): ColumnDescriptor<EnumType, T>;
+    addColumnCustomComponent(property: string, customComponentType: Type<IColumnValueComponent<T>>): ColumnDescriptor<any, T>;
     createTabGroup(name: string, title?: string): this;
     createFieldGroup(name: string, title?: string): this;
     addFieldDescriptor<FT>(field: AFieldDescriptor<FT, T>): this;

package/lib/directives/component.directive.d.ts

@@ -3,10 +3,14 @@ import * as i0 from "@angular/core";
 export declare class MngComponentDirective<C> implements OnInit {
     viewContainerRef: ViewContainerRef;
     component: Type<C>;
+    inputs?: {
+        [key: string]: any;
+    };
     private componentInstanceEventEmitter;
     componentRef: ComponentRef<C>;
     constructor(viewContainerRef: ViewContainerRef);
     ngOnInit(): void;
+    private isCmpInstanceOfColumnValue;
     static ɵfac: i0.ɵɵFactoryDeclaration<MngComponentDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<MngComponentDirective<any>, "[mngComponent]", never, { "component": "mngComponent"; }, { "componentInstanceEventEmitter": "instanceCreated"; }, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MngComponentDirective<any>, "[mngComponent]", never, { "component": "mngComponent"; "inputs": "inputs"; }, { "componentInstanceEventEmitter": "instanceCreated"; }, never>;
 }