@mediusinc/mng-commons 4.1.0 → 5.0.0-rc.0-c31d5206

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

@@ -17,10 +17,10 @@ export type ActionEditorDescriptorCreateOptsProviderType<Model, Service> = {
 };
 export type ActionEditorProviderType<Model, Service> = ServiceClassType<Service> | IEditorDataProvider<Model, Service>;
 export declare const actionEditorGetProviderCfgObj: <Model, Service>(serviceOrDataProvider?: ActionEditorProviderType<Model, Service> | undefined) => ActionEditorDescriptorCreateOptsProviderType<Model, Service>;
-export declare class ActionEditorDescriptorInst<Model, Service = any> extends ActionDescriptorInst<Model, Service> {
+export declare class ActionEditorDescriptorInst<Item, Service = any> extends ActionDescriptorInst<Item, Service> {
     private readonly _editorDescriptor;
-    protected readonly _dataProvider?: IEditorDataProvider<Model, any>;
-    protected _editorActions: ActionDescriptorInst<Model>[];
+    protected readonly _dataProvider?: IEditorDataProvider<Item, any>;
+    protected _editorActions: ActionDescriptorInst<Item>[];
     protected _editorTitle?: string | null;
     protected _editorTitleParams?: any;
     protected _hasFetchNotificationSuccess: boolean;
@@ -28,26 +28,29 @@ export declare class ActionEditorDescriptorInst<Model, Service = any> extends Ac
     protected _fetchNotificationSuccessMessage?: string;
     protected _dialogSize: StyleSizeEnum;
     protected _dialogClassName?: string;
-    protected _fetchFunction?: (ctx: ActionContext<Model, any>) => Observable<Model>;
-    protected _submitFunction?: (ctx: ActionContext<Model, any>) => Observable<Model>;
+    protected _fetchFunction?: (ctx: ActionContext<Item, Service>) => Observable<Item>;
+    protected _submitFunction?: (ctx: ActionContext<Item, Service>) => Observable<Item>;
     protected _editorComponent?: Type<any>;
     protected _resubmitEnabled?: boolean;
     protected _resubmitRefetch: boolean;
     protected _unsavedChangesConfirmation: boolean;
-    constructor(editorDescriptor: EditorDescriptorInst<Model>, actionName: string, cfg?: ActionEditorDescriptorConstructorOptsType<Model, Service>);
+    constructor(editorDescriptor: EditorDescriptorInst<Item>, actionName: string, cfg?: ActionEditorDescriptorConstructorOptsType<Item, Service>);
     get editorTitle(): string | null | undefined;
     get editorTitleParams(): any;
-    get editorDescriptor(): EditorDescriptorInst<Model>;
+    get editorDescriptor(): EditorDescriptorInst<Item>;
     get dialogSize(): StyleSizeEnum;
     get dialogClassName(): string | undefined;
     get hasFetchNotificationSuccess(): boolean;
     get fetchNotificationSuccessTitle(): string | undefined;
     get fetchNotificationSuccessMessage(): string | undefined;
-    get dataProvider(): IEditorDataProvider<Model, any> | undefined;
-    get runFunction(): (ctx: ActionContext<Model, unknown>) => Observable<Model>;
-    get fetchFunction(): ((ctx: ActionContext<Model, any>) => Observable<Model>) | undefined;
-    get submitFunction(): ((ctx: ActionContext<Model, any>) => Observable<Model>) | undefined;
-    get editorActions(): ActionDescriptorInst<Model, any>[];
+    get dataProvider(): IEditorDataProvider<Item, any> | undefined;
+    get hasRunFunction(): boolean;
+    get runFunction(): (ctx: ActionContext<Item, unknown>) => Observable<Item>;
+    get hasFetchFunction(): boolean;
+    get fetchFunction(): ((ctx: ActionContext<Item, Service>) => Observable<Item>) | undefined;
+    get hasSubmitFunction(): boolean;
+    get submitFunction(): ((ctx: ActionContext<Item, Service>) => Observable<Item>) | undefined;
+    get editorActions(): ActionDescriptorInst<Item, any>[];
     get editorComponent(): Type<any> | undefined;
     get resubmitEnabled(): boolean | undefined;
     get resubmitRefetch(): boolean;
@@ -55,12 +58,12 @@ export declare class ActionEditorDescriptorInst<Model, Service = any> extends Ac
     withEditorTitle(title: string | null, params?: any): this;
     withDialogSize(size?: StyleSizeEnum): this;
     withDialogClassName(className: string): this;
-    withRunFunction(fn: (ctx: ActionContext<Model, Service>) => Observable<Model>): this;
-    withFetchFunction(fn: (ctx: ActionContext<Model, Service>) => Observable<Model>): this;
-    withSubmitFunction(fn: (ctx: ActionContext<Model, Service>) => Observable<Model>): this;
+    withRunFunction(fn: (ctx: ActionContext<Item, Service>) => Observable<Item>): this;
+    withFetchFunction(fn: (ctx: ActionContext<Item, Service>) => Observable<Item>): this;
+    withSubmitFunction(fn: (ctx: ActionContext<Item, Service>) => Observable<Item>): this;
     withFetchNotificationError(title?: string, message?: string, hasNotification?: boolean): this;
-    withEditorAction(action: ActionDescriptorInst<Model>): this;
-    withEditorActions(actions: ActionDescriptorInst<Model>[]): this;
+    withEditorAction(action: ActionDescriptorInst<Item>): this;
+    withEditorActions(actions: ActionDescriptorInst<Item>[]): this;
     withEditorComponent(editorComponent: Type<any>): this;
     withResubmit(enabled?: boolean, refetch?: boolean): this;
     withUnsavedChangesConfirmation(unsavedChangesConfirmation?: boolean): this;

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

@@ -3,8 +3,8 @@ import { Subject } from 'rxjs';
 import { MngFieldEventData, MngFormEvent, MngFormEventTypeEnum } from '../../components/form/models';
 import { ILookupDataProvider, ITableDataProvider } from '../../data-providers';
 import { TableviewAttributeDef } from '../../models';
-import { ArrayItemType, ClassType, EnumConstantType, EnumType, IdType, MngFieldValidationMessage, MngFieldValidator, Nullable } from '../../types';
-import { ModelDescriptor } from '../model';
+import { ArrayItemType, ClassType, EnumConstantType, IdType, MngFieldValidationMessage, MngFieldValidator, Nullable } from '../../types';
+import { EnumDescriptor, ModelDescriptor } from '../model';
 import { TableDescriptorInst } from '../table';
 import { TableviewDescriptorInst } from '../tableview';
 import { FieldInputTypeEnum, TableviewEditorTypeEnum } from '../types';
@@ -126,16 +126,14 @@ export declare class EditorDescriptorInst<EditorModel> implements IEditorDescrip
     addFieldLookupWithPropertyAsValueUnsafe<FieldModel, FieldValue = Nullable<IdType>>(property: string, optionsValueProperty: string): FieldLookupDescriptor<FieldModel, EditorModel, undefined, FieldValue, string>;
     addFieldLookupWithProvider<Service, Property extends keyof EditorModel, FieldModel = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, provider: FieldLookupProviderType<FieldModel, Service>, type?: ClassType<FieldModel>): FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue, string>;
     addFieldLookupWithProviderUnsafe<Service, FieldModel, FieldValue = FieldModel>(property: string, provider: FieldLookupProviderType<FieldModel, Service>, type?: ClassType<FieldModel>): FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue, string>;
-    addFieldLookupEnum(property: keyof EditorModel, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null): FieldLookupEnumDescriptor<EditorModel>;
+    addFieldLookupEnum<Property extends keyof EditorModel, Enum extends NonNullable<EditorModel[Property]>>(property: keyof EditorModel, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>): FieldLookupEnumDescriptor<Enum, EditorModel>;
     /**
      * Adds enum lookup field.
      * @param property Model's property name.
-     * @param enumType Type of enum.
+     * @param enumDesc Type of enum or enum descriptor.
      * @param options Provides subset of enum's available constants.
-     * @param nameAsValue If constant's name should be used as final value of the enum. Primarily, constant's value will be used.
-     * @param optionsTitlePath Title key path from where translations are provided. If null, the enum's values won't be translated.
      */
-    addFieldLookupEnumUnsafe(property: string, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null): FieldLookupEnumDescriptor<EditorModel>;
+    addFieldLookupEnumUnsafe<Enum = EnumConstantType>(property: string, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>): FieldLookupEnumDescriptor<Enum, EditorModel>;
     /**
      * Adds table/details/add/edit field for one-to-many (1:n) relations.
      * @param property Model's property name.
@@ -213,13 +211,11 @@ export declare class EditorDescriptorInst<EditorModel> implements IEditorDescrip
     /**
      * Modifies selected field with enum type.
      * @param property Model's property name.
-     * @param enumType type of enum for new field
-     * @param optionsTitlePath
+     * @param enumModel Enum descriptor.
      * @param values
-     * @param nameAsValue
      */
-    withFieldModifiedEnum(property: keyof EditorModel, enumType?: EnumType, optionsTitlePath?: string | null, values?: Array<EnumConstantType>, nameAsValue?: boolean): this;
-    withFieldModifiedEnumUnsafe(property: string, enumType?: EnumType, optionsTitlePath?: string | null, values?: Array<EnumConstantType>, nameAsValue?: boolean): this;
+    withFieldModifiedEnum<Property extends keyof EditorModel, Enum extends NonNullable<EditorModel[Property]>>(property: Property, enumModel?: EnumDescriptor<Enum>, values?: Array<Enum>): this;
+    withFieldModifiedEnumUnsafe<Enum = any>(property: string, enumDesc?: EnumDescriptor<Enum>, values?: Array<Enum>): this;
     /**
      * Modifies selected field with lookup field.
      * @param property Model's property name.

package/lib/descriptors/editor/field-base.descriptor.d.ts

@@ -64,16 +64,16 @@ export declare abstract class AFieldDescriptor<FieldModel, EditorModel, FieldVal
     get setter(): ((item: EditorModel, value: FieldValue) => void) | undefined;
     get validations(): FieldValidationDescriptor[];
     get asyncValidations(): FieldValidationDescriptor[];
-    get requiredExpression(): string | Observable<boolean> | ((field?: FormlyFieldConfig<import("@ngx-formly/core").FormlyFieldProps & {
+    get requiredExpression(): string | ((field?: FormlyFieldConfig<import("@ngx-formly/core").FormlyFieldProps & {
         [additionalProperties: string]: any;
-    }> | undefined) => boolean) | undefined;
+    }> | undefined) => boolean) | Observable<boolean> | undefined;
     get disabledExpression(): string | Observable<boolean> | ((field?: FormlyFieldConfig<import("@ngx-formly/core").FormlyFieldProps & {
         [additionalProperties: string]: any;
     }> | undefined) => boolean) | undefined;
     get hiddenExpression(): string | Observable<boolean> | ((field?: FormlyFieldConfig<import("@ngx-formly/core").FormlyFieldProps & {
         [additionalProperties: string]: any;
     }> | undefined) => boolean) | undefined;
-    get updateOn(): "submit" | "change" | "blur";
+    get updateOn(): "change" | "blur" | "submit";
     get onInit(): MngFormlyHookFn | undefined;
     get onChanges(): MngFormlyHookFn | undefined;
     get afterContentInit(): MngFormlyHookFn | undefined;

package/lib/descriptors/editor/field-lookup.descriptor.d.ts

@@ -1,7 +1,8 @@
 import { ILookupDataProvider, ITableDataProvider, LookupDataProviderLookupFnType } from '../../data-providers';
 import { EnumValue } from '../../models';
-import { ClassType, EnumConstantType, EnumType, ServiceClassType } from '../../types';
+import { ClassType, EnumConstantType, ServiceClassType } from '../../types';
 import { FieldLookupConfig, ILookupDescriptor } from '../interfaces';
+import { EnumDescriptor } from '../model';
 import { TableDescriptorInst } from '../table';
 import { FieldLookupTypeEnum, InputTrimType } from '../types';
 import { AFieldDescriptor } from './field-base.descriptor';
@@ -37,7 +38,7 @@ export declare class FieldLookupDescriptor<FieldModel, EditorModel, Service = an
     protected _autocompleteSelectFirst?: boolean;
     protected _autocompleteInputTrim?: InputTrimType;
     protected _dialogTableDescriptor?: TableDescriptorInst<FieldModel>;
-    protected _dialogTableDataProvider?: ITableDataProvider<FieldModel, any>;
+    protected _dialogTableDataProvider?: ITableDataProvider<FieldModel, any, any, any>;
     protected _customComponentName?: string;
     constructor(editor: IEditorDescriptorInternal<EditorModel>, property: Property, cfg?: FieldLookupDescriptorConstructorOptsType<FieldModel, Service>);
     get lookupType(): FieldLookupTypeEnum;
@@ -52,8 +53,8 @@ export declare class FieldLookupDescriptor<FieldModel, EditorModel, Service = an
     get autocompleteAutoClear(): boolean | undefined;
     get autocompleteSelectFirst(): boolean | undefined;
     get dropdownClassName(): string;
-    get dialogTableDescriptor(): TableDescriptorInst<FieldModel> | undefined;
-    get dialogTableDataProvider(): ITableDataProvider<FieldModel, any> | undefined;
+    get dialogTableDescriptor(): TableDescriptorInst<FieldModel, keyof FieldModel, keyof FieldModel> | undefined;
+    get dialogTableDataProvider(): ITableDataProvider<FieldModel, any, any, any> | undefined;
     get customComponentName(): string | undefined;
     get trimOption(): InputTrimType | undefined;
     withOptionsLabelProperty(property: keyof FieldModel, translate?: boolean): this;
@@ -66,18 +67,17 @@ export declare class FieldLookupDescriptor<FieldModel, EditorModel, Service = an
     withInputTrim(trimOption?: InputTrimType): this;
     withConfig(config: FieldLookupConfig): this;
     asAutocomplete(opts?: FieldLookupAutocompleteOptsType): this;
-    asDialog(lookupTableDescriptor: TableDescriptorInst<FieldModel>, tableDataProvider?: ITableDataProvider<FieldModel, any>): this;
+    asDialog(lookupTableDescriptor: TableDescriptorInst<FieldModel>, tableDataProvider?: ITableDataProvider<FieldModel, any, any, any>): this;
     asCustomComponent(customComponentName: string): this;
     copy(): FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue>;
 }
-export declare class FieldLookupEnumDescriptor<EditorModel> extends FieldLookupDescriptor<EnumValue, EditorModel, undefined, EnumConstantType> {
-    private readonly _enumType;
+export declare class FieldLookupEnumDescriptor<Enum, EditorModel> extends FieldLookupDescriptor<EnumValue, EditorModel, undefined, EnumConstantType> {
+    private readonly _enumModel;
     private readonly _optionEnumValues;
-    private readonly _nameAsValue;
-    constructor(editor: IEditorDescriptorInternal<EditorModel>, property: string, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null);
-    get enumType(): EnumType<EnumConstantType>;
+    constructor(editor: IEditorDescriptorInternal<EditorModel>, property: string, enumModel: EnumDescriptor<Enum>, options?: Array<Enum>);
+    get enumModel(): EnumDescriptor<Enum>;
     withDisabledOptions(...disabledOptions: Array<EnumConstantType>): this;
     withDefaultValueEnum(defaultValue: EnumConstantType): this;
     asAutocomplete(opts?: FieldLookupAutocompleteOptsType): this;
-    copy(): FieldLookupEnumDescriptor<EditorModel>;
+    copy(): FieldLookupEnumDescriptor<Enum, EditorModel>;
 }

package/lib/descriptors/editor/field-many.descriptor.d.ts

@@ -30,8 +30,8 @@ export declare class FieldManyToManyEditorDescriptor<FieldModel, EditorModel, Se
     get hasLookupExcludeValues(): boolean;
     get excludeFilterProperty(): string;
     get excludeValueProperty(): string;
-    get mainTableDescriptor(): TableDescriptorInst<FieldModel>;
-    get lookupTableDescriptor(): TableDescriptorInst<FieldModel>;
+    get mainTableDescriptor(): TableDescriptorInst<FieldModel, keyof FieldModel, keyof FieldModel>;
+    get lookupTableDescriptor(): TableDescriptorInst<FieldModel, keyof FieldModel, keyof FieldModel>;
     get lookupTableDataProvider(): ITableDataProvider<FieldModel, Service>;
     get searchEnabled(): boolean;
     get searchFields(): string[] | undefined;
@@ -51,8 +51,8 @@ export declare class FieldManyEditorDescriptor<FieldModel, EditorModel, FieldVal
     get fieldType(): FieldManyEditorTypeEnum;
     get fieldActions(): FieldManyEditorActionEnum[];
     get actions(): ActionDescriptorInst<FieldModel, any>[];
-    get tableviewDescriptor(): TableviewDescriptorInst<FieldModel>;
-    get tableDescriptor(): TableDescriptorInst<FieldModel>;
+    get tableviewDescriptor(): TableviewDescriptorInst<FieldModel, keyof FieldModel, keyof FieldModel>;
+    get tableDescriptor(): TableDescriptorInst<FieldModel, keyof FieldModel, keyof FieldModel>;
     get editorForCreate(): import("@mediusinc/mng-commons").EditorDescriptorInst<FieldModel>;
     get editorForRead(): import("@mediusinc/mng-commons").EditorDescriptorInst<FieldModel>;
     get editorForUpdate(): import("@mediusinc/mng-commons").EditorDescriptorInst<FieldModel>;

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

@@ -2,7 +2,7 @@ import { Type } from '@angular/core';
 import { AbstractControl } from '@angular/forms';
 import { AMngFormlyCustomFieldComponent } from '../../components/form/formly/fields/';
 import { RadioValue } from '../../models';
-import { EnumConstantType, EnumType } from '../../types';
+import { EnumDescriptor } from '../model';
 import { FieldInputTypeEnum, InputTrimType } from '../types';
 import { AFieldDescriptor } from './field-base.descriptor';
 import { IEditorDescriptorInternal } from './internal/editor.model';
@@ -148,7 +148,7 @@ export declare class FieldInputDescriptor<EditorModel, FieldModel = FieldInputDe
     asCurrencyUnsafe(opts?: FieldInputCurrencyOptsType): this;
     asSwitch(): this;
     asRadio(options: Array<string | number | boolean>, optionsTitlePath?: string): this;
-    asRadioFromEnum(enumType: EnumType, optionsTitlePath?: string | null, values?: Array<EnumConstantType>, nameAsValue?: boolean): this;
+    asRadioFromEnum<Enum>(enumModel: EnumDescriptor<Enum>, values?: Array<Enum>): this;
     asDatePicker(opts?: FieldInputDatePickerOptsType): this;
     asMask(mask: string, slotChar: string): this;
     asFile(opts?: FieldInputFileOpts): this;

package/lib/descriptors/editor/internal/editor-fields.model.d.ts

@@ -1,5 +1,6 @@
 import { ITableDataProvider } from '../../../data-providers';
-import { ArrayItemType, ClassType, EnumConstantType, EnumType, IdType, Nullable } from '../../../types';
+import { ArrayItemType, ClassType, EnumConstantType, IdType, Nullable } from '../../../types';
+import { EnumDescriptor } from '../../model';
 import { ITableDescriptorInternal } from '../../table/internal/table.model';
 import { ITableviewDescriptorInternal } from '../../tableview/internal/tableview.model';
 import { TableviewEditorTypeEnum } from '../../types';
@@ -21,10 +22,10 @@ export interface IFieldsManageInterface<EditorModel> {
     addFieldLookupWithPropertyAsValueUnsafe<FieldModel, FieldValue = Nullable<IdType>>(property: string, optionsValueProperty: string): FieldLookupDescriptor<FieldModel, EditorModel, undefined, FieldValue>;
     addFieldLookupWithProvider<Service, Property extends keyof EditorModel, FieldModel = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, provider: FieldLookupProviderType<FieldModel, Service>, type?: ClassType<FieldModel>): FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue>;
     addFieldLookupWithProviderUnsafe<Service, FieldModel, FieldValue = FieldModel>(property: string, provider: FieldLookupProviderType<FieldModel, Service>, type?: ClassType<FieldModel>): FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue>;
-    addFieldLookupEnum(property: keyof EditorModel, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null): FieldLookupEnumDescriptor<EditorModel>;
-    addFieldLookupEnumUnsafe(property: string, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null): FieldLookupEnumDescriptor<EditorModel>;
-    addFieldManyEditor<Property extends keyof EditorModel, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, tableviewDescriptor: ITableviewDescriptorInternal<FieldModel>): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue>;
-    addFieldManyEditorUnsafe<FieldModel, FieldValue = FieldModel[]>(property: string, tableviewDescriptor: ITableviewDescriptorInternal<FieldModel>): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue>;
+    addFieldLookupEnum<Property extends keyof EditorModel, Enum extends NonNullable<EditorModel[Property]>>(property: keyof EditorModel, enumModel: EnumDescriptor<Enum>, options?: Array<Enum>): FieldLookupEnumDescriptor<Enum, EditorModel>;
+    addFieldLookupEnumUnsafe<Enum = EnumConstantType>(property: string, enumModel: EnumDescriptor<Enum>, options?: Array<Enum>): FieldLookupEnumDescriptor<Enum, EditorModel>;
+    addFieldManyEditor<Property extends keyof EditorModel, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, tableviewDescriptor: ITableviewDescriptorInternal<FieldModel, any, any>): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue>;
+    addFieldManyEditorUnsafe<FieldModel, FieldValue = FieldModel[]>(property: string, tableviewDescriptor: ITableviewDescriptorInternal<FieldModel, any, any>): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue>;
     addFieldManyToManyEditor<Property extends keyof EditorModel, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, mainTableDescriptor: ITableDescriptorInternal<FieldModel>, lookupTableDescriptor: ITableDescriptorInternal<FieldModel>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, undefined, FieldValue>;
     addFieldManyToManyEditorUnsafe<FieldModel, FieldValue = FieldModel[]>(property: string, mainTableDescriptor: ITableDescriptorInternal<FieldModel>, lookupTableDescriptor: ITableDescriptorInternal<FieldModel>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, undefined, FieldValue>;
     addFieldManyToManyEditorWithProvider<Property extends keyof EditorModel, Service, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, mainTableDescriptor: ITableDescriptorInternal<FieldModel>, lookupTableDescriptor: ITableDescriptorInternal<FieldModel>, lookupDataProvider: ITableDataProvider<FieldModel, Service>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, Service, FieldValue>;

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

@@ -1,8 +1,9 @@
 import { ILookupDataProvider, LookupDataProviderLookupFnType } from '../../data-providers';
-import { EnumValue } from '../../models';
-import { ClassType, EnumConstantType, EnumType, ServiceClassType } from '../../types';
+import { EnumValue, FilterMatchModeExtendedType } from '../../models';
+import { ClassType, EnumConstantType, ServiceClassType } from '../../types';
 import { ILookupDescriptor } from '../interfaces';
-import { FilterLookupTypeEnum, FilterMatchModeEnum } from '../types';
+import { EnumDescriptor } from '../model';
+import { FilterLookupTypeEnum } from '../types';
 import { FilterDescriptor } from './filter.descriptor';
 export type FilterLookupDescriptorConstructorOptsType<FilterModel, Service> = FilterLookupDescriptorCreateOptsProviderType<FilterModel, Service> & {
     type?: ClassType<FilterModel>;
@@ -17,7 +18,7 @@ export type FilterLookupAutocompleteOptsType = {
     inlineSearch?: boolean;
     autoClear?: boolean;
 };
-export declare class FilterLookupDescriptor<FilterModel, Service = any> extends FilterDescriptor<FilterModel> implements ILookupDescriptor<FilterModel> {
+export declare class FilterLookupDescriptor<FilterModel, TableModel, Service = any> extends FilterDescriptor<FilterModel, TableModel> implements ILookupDescriptor<FilterModel> {
     protected readonly _dataProvider: ILookupDataProvider<FilterModel, Service>;
     protected readonly _optionsValueProperty?: string | null;
     protected _lookupType?: FilterLookupTypeEnum;
@@ -50,20 +51,20 @@ export declare class FilterLookupDescriptor<FilterModel, Service = any> extends
     withLookup(lookup?: LookupDataProviderLookupFnType<FilterModel, Service>): this;
     withMultiselect(multiselect?: boolean): this;
     withDropdownClassName(dropdownClassName: string): this;
-    withDefaultFilter(filterValue: FilterModel | FilterModel[], filterValueTo?: FilterModel, filterMatchMode?: FilterMatchModeEnum): this;
+    withDefaultFilter(value: FilterModel | FilterModel[] | undefined, matchMode: FilterMatchModeExtendedType): this;
     asAutocomplete(opts?: FilterLookupAutocompleteOptsType): this;
-    copy(): FilterLookupDescriptor<FilterModel>;
-    protected copyFieldsTo(filter: FilterLookupDescriptor<FilterModel>): void;
+    copy(): FilterLookupDescriptor<FilterModel, TableModel, Service>;
+    protected copyFieldsTo(filter: FilterLookupDescriptor<FilterModel, TableModel, Service>): void;
 }
-export declare class FilterLookupEnumDescriptor extends FilterLookupDescriptor<EnumValue> {
-    private readonly _enumType;
+export declare class FilterLookupEnumDescriptor<Enum, TableModel> extends FilterLookupDescriptor<EnumValue, TableModel> {
+    private readonly _enum;
     private readonly _optionEnumValues;
     private readonly _nameAsValue;
-    constructor(property: string, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null);
-    get enumType(): EnumType<EnumConstantType>;
+    constructor(property: string, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>);
+    get enum(): EnumDescriptor<Enum>;
     asAutocomplete(opts?: FilterLookupAutocompleteOptsType): this;
-    withMultiselectEnum(multiselect?: boolean): FilterLookupEnumDescriptor;
+    withMultiselectEnum(multiselect?: boolean): FilterLookupEnumDescriptor<Enum, TableModel>;
     withDefaultFilter(): this;
-    withDefaultFilterEnum(filterValue: EnumConstantType | EnumConstantType[], filterValueTo?: EnumConstantType, filterMatchMode?: FilterMatchModeEnum): this;
-    copy(): FilterLookupEnumDescriptor;
+    withDefaultFilterEnum(value: EnumConstantType | EnumConstantType[] | undefined, matchMode: FilterMatchModeExtendedType): this;
+    copy(): FilterLookupEnumDescriptor<Enum, TableModel>;
 }

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

@@ -1,18 +1,19 @@
-import { FilterMatchModeEnum, FilterTypeEnum, InputTrimType } from '../types';
-export declare class FilterDescriptor<FilterModel> {
+import { FilterMatchModeExtendedType } from '../../models';
+import { FilterTypeEnum, InputTrimType } from '../types';
+export declare class FilterDescriptor<FilterModel, TableModel> {
     protected readonly _property: string;
+    protected _showOnColumn: string;
     protected _filterType: FilterTypeEnum;
-    protected _filterProperty?: string;
     protected _hasDefaultValue: boolean;
-    protected _defaultFilterMatchMode?: FilterMatchModeEnum;
+    protected _defaultMatchMode?: FilterMatchModeExtendedType;
     protected _defaultValue?: FilterModel | FilterModel[];
-    protected _defaultValueTo?: FilterModel;
     protected _matchModes: string[] | null;
     protected _numberMinFractionDigits?: number;
     protected _numberMaxFractionDigits?: number;
     protected _numberUseGrouping: boolean;
     protected _datePickerFormat?: string;
     protected _datePickerShowTime: boolean;
+    protected _datePickerShowSeconds: boolean;
     protected _datePickerValueNoTime?: boolean;
     protected _datePickerValueNoTimezone?: boolean;
     protected _datePickerValueUtc?: boolean;
@@ -24,17 +25,17 @@ export declare class FilterDescriptor<FilterModel> {
     protected _inputTrim?: InputTrimType;
     constructor(property: string);
     get filterType(): FilterTypeEnum;
+    get showOnColumn(): string;
     get hasDefaultValue(): boolean;
     get defaultValue(): FilterModel | FilterModel[] | undefined;
-    get defaultValueTo(): FilterModel | undefined;
-    get defaultFilterMatchMode(): FilterMatchModeEnum | undefined;
-    get filterProperty(): string | undefined;
+    get defaultMatchMode(): string | undefined;
     get matchModes(): string[] | null;
     get numberMinFractionDigits(): number | undefined;
     get numberMaxFractionDigits(): number | undefined;
     get numberUseGrouping(): boolean;
     get datePickerFormat(): string | undefined;
     get datePickerShowTime(): boolean;
+    get datePickerShowSeconds(): boolean;
     get datePickerValueUtc(): boolean | undefined;
     get datePickerValueNoTimezone(): boolean | undefined;
     get datePickerValueNoTime(): boolean | undefined;
@@ -46,22 +47,20 @@ export declare class FilterDescriptor<FilterModel> {
     get trimOption(): InputTrimType | undefined;
     get property(): string;
     asFilterType(filterType: FilterTypeEnum): 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;
-    withDefaultFilter(filterValue: FilterModel, filterValueTo?: FilterModel, filterMatchMode?: FilterMatchModeEnum): this;
+    withShowOnColumn(property: keyof TableModel): this;
+    withShowOnColumnUnsafe(property: string): this;
+    withDefaultFilter(value: FilterModel | FilterModel[] | undefined, matchMode: FilterMatchModeExtendedType): this;
+    protected validateDefaultFilter(value: FilterModel | FilterModel[] | undefined, matchMode: FilterMatchModeExtendedType): void;
     withNumberFractions(min?: number, max?: number): this;
     withNumberGrouping(useGrouping?: boolean): this;
-    withDateFormat(format?: string, showTime?: boolean): this;
+    withDateFormat(format?: string, showTime?: boolean, showSeconds?: boolean): this;
     withDateValue(utc?: boolean, noTimezone?: boolean, noTime?: boolean): this;
     withPlaceholder(placeholder: string): this;
     withClassName(className: string): this;
     withColumnClassName(className: string): this;
     withColumnWidth(width?: number, minWidth?: number): this;
     withInputTrimming(trimOption?: InputTrimType): this;
-    withMatchModes(matchModes: Array<FilterMatchModeEnum>): this;
-    copy(): FilterDescriptor<FilterModel>;
-    protected copyFieldsTo(descriptor: FilterDescriptor<FilterModel>): void;
+    withMatchModes(matchModes: Array<FilterMatchModeExtendedType>): this;
+    copy(): FilterDescriptor<FilterModel, TableModel>;
+    protected copyFieldsTo(descriptor: FilterDescriptor<FilterModel, TableModel>): void;
 }

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

@@ -0,0 +1,14 @@
+import { EnumType } from '../../types';
+export declare class EnumDescriptor<Enum> {
+    private readonly _value;
+    private readonly _type;
+    private readonly _nameAsValue;
+    private readonly _i18nBaseKey?;
+    protected constructor(value: Enum, type: EnumType, i18nBaseKey?: string | null, nameAsValue?: boolean);
+    get type(): EnumType<import("../../types").EnumConstantType>;
+    get i18nBaseKey(): string | null | undefined;
+    get nameAsValue(): boolean;
+    static create<Enum>(value: Enum, type: EnumType, i18nBaseKey?: string | null, nameAsValue?: boolean): EnumDescriptor<Enum>;
+}
+export declare function enumModel<Enum>(value: Enum, type: EnumType, i18nBaseKey?: string | null, nameAsValue?: boolean): EnumDescriptor<Enum>;
+export declare function enumModelGeneric(type: EnumType, i18nBaseKey?: string | null, nameAsValue?: boolean): EnumDescriptor<any>;

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

@@ -1 +1,3 @@
+export * from './enum.descriptor';
 export * from './model.descriptor';
+export * from './type.descriptor';

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

@@ -1,4 +1,5 @@
 import { ClassOptType, ClassType } from '../../types';
+import { TypeDescriptor } from './type.descriptor';
 export declare class ModelDescriptor<Model, ModelClass = ClassOptType<Model>> {
     private readonly _type;
     private readonly _typeName?;
@@ -20,3 +21,11 @@ export declare class ModelDescriptor<Model, ModelClass = ClassOptType<Model>> {
     withI18nBase(base: ClassType<any> | string): this;
     copy(): ModelDescriptor<Model, ModelClass>;
 }
+export type ModelDescriptorCreateOpts<Model> = {
+    id?: keyof Model;
+    title?: keyof Model;
+    i18nBase?: string | ClassType<any>;
+};
+export declare function modelFromClass<Model>(type: ClassType<Model>, opts?: ModelDescriptorCreateOpts<Model>): ModelDescriptor<Model, ClassType<Model>>;
+export declare function modelFromType<Model>(type: TypeDescriptor<Model>, opts?: ModelDescriptorCreateOpts<Model>): ModelDescriptor<Model, undefined>;
+export declare function model<Model>(opts?: ModelDescriptorCreateOpts<Model>): ModelDescriptor<Model, undefined>;

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

@@ -0,0 +1,5 @@
+export declare class TypeDescriptor<Type> {
+    protected constructor();
+    static create<Type>(): TypeDescriptor<Type>;
+}
+export declare function type<Type>(): TypeDescriptor<Type>;

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

@@ -1,8 +1,8 @@
 import { Type } from '@angular/core';
-import { ILookupDataProvider } from '../../data-providers';
 import { IColumnValueComponent } from '../../models';
-import { EnumConstantType, EnumType, GetterFn } from '../../types';
-import { FilterDescriptor, FilterLookupDescriptor, FilterLookupEnumDescriptor } from '../filter';
+import { GetterFn } from '../../types';
+import { FilterDescriptor } from '../filter';
+import { EnumDescriptor } from '../model';
 import { ColumnDisplayTypeEnum, ColumnTypeEnum } from '../types';
 import { ITableDescriptorInternal } from './internal/table.model';
 export type ColumnCurrencyOptsType<Property = string> = {
@@ -22,15 +22,12 @@ export type ColumnNumberFractionOptsType = {
 export type ColumnLocaleOptsType = {
     locale?: string;
 };
-export declare class ColumnDescriptor<ColumnModel, TableModel, ColumnValue = ColumnModel, Property = string> {
+export declare class ColumnDescriptor<ColumnModel, TableModel, ColumnValue = ColumnModel> {
     protected readonly _table: ITableDescriptorInternal<TableModel>;
     protected readonly _property: string;
     private _columnType;
     private _columnDisplayType;
     protected _title?: string;
-    private _isSortEnabled;
-    private _sortProperty?;
-    private _filterDescriptor?;
     private _displayFormat?;
     private _locale?;
     private _template?;
@@ -46,9 +43,7 @@ export declare class ColumnDescriptor<ColumnModel, TableModel, ColumnValue = Col
     private _width;
     private _minWidth;
     private _maxWidth;
-    private _enumType?;
-    private _enumTitlePath?;
-    private _enumNameAsValue;
+    private _enum?;
     private _booleanAsIcon;
     private _booleanYes?;
     private _booleanNo?;
@@ -60,13 +55,10 @@ export declare class ColumnDescriptor<ColumnModel, TableModel, ColumnValue = Col
     private _clipboardValueGetter?;
     private _isLocalized;
     private _localizationExistsProperty?;
-    constructor(table: ITableDescriptorInternal<TableModel>, property: Property);
+    constructor(table: ITableDescriptorInternal<TableModel>, property: string);
     get columnType(): ColumnTypeEnum;
     get columnDisplayType(): ColumnDisplayTypeEnum;
     get title(): string | undefined;
-    get isSortEnabled(): boolean;
-    get sortProperty(): string | undefined;
-    get filterDescriptor(): FilterDescriptor<any> | undefined;
     get displayFormat(): string | undefined;
     get table(): ITableDescriptorInternal<TableModel>;
     get property(): string;
@@ -76,9 +68,7 @@ export declare class ColumnDescriptor<ColumnModel, TableModel, ColumnValue = Col
     get width(): number | null;
     get minWidth(): number | null;
     get maxWidth(): number | null;
-    get enumType(): EnumType<EnumConstantType> | undefined;
-    get enumTitlePath(): string | null | undefined;
-    get enumNameAsValue(): boolean;
+    get enum(): EnumDescriptor<any> | undefined;
     get booleanAsIcon(): boolean;
     get booleanYes(): string | undefined;
     get booleanNo(): string | undefined;
@@ -110,18 +100,14 @@ export declare class ColumnDescriptor<ColumnModel, TableModel, ColumnValue = Col
     asCurrencyUnsafe(opts?: ColumnCurrencyOptsType): this;
     asDate(displayFormat?: string): this;
     asBoolean(yes?: string, no?: string, asIcon?: boolean): this;
-    asEnum(enumType: EnumType, nameAsValue?: boolean, titlePath?: string | null): this;
+    asEnumUnsafe(enumDesc: EnumDescriptor<any>): this;
     asCustomComponent(customComponentType: Type<IColumnValueComponent<TableModel>>): this;
     asHtml(): this;
     withClassName(className?: string, headerClassName?: string, classNameMapFn?: (className?: string, item?: TableModel) => string): this;
     withWidth(width?: number, minWidth?: number, maxWidth?: number): this;
     withTitle(title: string): this;
-    withFilter(forceSimple?: boolean): FilterDescriptor<any>;
-    withFilterLookup<FLT = ColumnModel, S = undefined>(provider?: ILookupDataProvider<FLT, S>, optionsValueProperty?: keyof FLT | null): FilterLookupDescriptor<FLT, S>;
-    withFilterLookupUnsafe<FLT = ColumnModel, S = undefined>(provider?: ILookupDataProvider<FLT, S>, optionsValueProperty?: string | null): FilterLookupDescriptor<FLT, S>;
-    withFilterLookupEnum(options?: Array<EnumConstantType>): FilterLookupEnumDescriptor;
-    withSort(isEnabled?: boolean, sortProperty?: string): this;
-    withDefaultSort(asc?: boolean): this;
+    withFilterUnsafe(forceSimple?: boolean): FilterDescriptor<any, TableModel>;
+    withSortUnsafe(isDefault?: boolean, ascending?: boolean): this;
     withCopyToClipboard(hasCopyToClipboard?: boolean, clipboardValueGetter?: GetterFn<ColumnValue, TableModel>): this;
     withTemplate(template: string): this;
     withGetter(getter?: GetterFn<ColumnValue, TableModel>): this;

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

@@ -1,2 +1,3 @@
 export * from './column.descriptor';
+export * from './sort.descriptor';
 export * from './table.descriptor';

package/lib/descriptors/table/internal/table-columns.model.d.ts

@@ -1,11 +1,42 @@
-import { ColumnDescriptor } from '../../table';
-export interface IColumnsManageInterface<TableModel> {
+import { ILookupDataProvider } from '../../../data-providers';
+import { EnumConstantType } from '../../../types';
+import { FilterDescriptor, FilterLookupDescriptor, FilterLookupEnumDescriptor } from '../../filter';
+import { EnumDescriptor } from '../../model';
+import { ColumnDescriptor, SortDescriptor } from '../../table';
+export interface IColumnsManageInterface<TableModel, Sorts, Filters> {
     getColumn(property: keyof TableModel): ColumnDescriptor<any, TableModel> | null;
     getColumnUnsafe(property: string): ColumnDescriptor<any, TableModel> | null;
     removeColumn(property: keyof TableModel): void;
     removeColumnUnsafe(property: string): void;
-    addColumnDescriptor<ColumnModel>(column: ColumnDescriptor<ColumnModel, TableModel>): this;
-    addColumn<PropertyKey extends keyof TableModel>(property: PropertyKey): ColumnDescriptor<TableModel[PropertyKey], TableModel>;
+    withColumn<ColumnModel, ColumnValue = ColumnModel>(column: ColumnDescriptor<ColumnModel, TableModel, ColumnValue>): this;
+    addColumn<PropertyKey extends keyof TableModel>(property: PropertyKey): ColumnDescriptor<NonNullable<TableModel[PropertyKey]>, TableModel, TableModel[PropertyKey]>;
+    addColumnEnum<PropertyKey extends keyof TableModel, Enum extends NonNullable<TableModel[PropertyKey]>>(property: PropertyKey, enumDesc: EnumDescriptor<Enum>): ColumnDescriptor<Enum, TableModel, TableModel[PropertyKey]>;
     addColumnUnsafe<ColumnModel = any>(property: string): ColumnDescriptor<ColumnModel, TableModel>;
-    addColumns(...properties: (keyof TableModel)[]): this;
+    withColumns(...properties: (keyof TableModel)[]): this;
+    getSort(property: Sorts): SortDescriptor<TableModel> | null;
+    getSortUnsafe(property: string): SortDescriptor<TableModel> | null;
+    removeSort(property: Sorts): void;
+    removeSortUnsafe(property: string): void;
+    addSort(property: Sorts, isDefault: boolean, ascending?: boolean): SortDescriptor<TableModel>;
+    addSortUnsafe(property: string, isDefault: boolean, ascending?: boolean): SortDescriptor<TableModel>;
+    withSort(property: Sorts, isDefault: boolean, ascending?: boolean): this;
+    withSortUnsafe(property: string, isDefault: boolean, ascending?: boolean): this;
+    withSorts(...properties: Sorts[]): this;
+    withSortsUnsafe(...properties: string[]): this;
+    getFilter(property: Filters): FilterDescriptor<any, TableModel> | null;
+    getFilterUnsafe(property: string): FilterDescriptor<any, TableModel> | null;
+    removeFilter(property: Filters): void;
+    removeFilterUnsafe(property: string): void;
+    addFilter<FilterModel = Filters extends keyof TableModel ? TableModel[Filters] : never>(property: Filters): FilterDescriptor<FilterModel, TableModel>;
+    addFilterUnsafe<FilterModel>(property: string): FilterDescriptor<FilterModel, TableModel>;
+    addFilterLookup<FilterModel = Filters extends keyof TableModel ? NonNullable<TableModel[Filters]> : never, Service = undefined>(property: Filters, provider?: ILookupDataProvider<FilterModel, Service>, optionsValueProperty?: keyof FilterModel): FilterLookupDescriptor<FilterModel, TableModel, Service>;
+    addFilterLookupUnsafe<FilterModel, Service = undefined>(property: string, provider?: ILookupDataProvider<FilterModel, Service>, optionsValueProperty?: string): FilterLookupDescriptor<FilterModel, TableModel, Service>;
+    addFilterLookupEnum<Enum>(property: Filters, enumDesc: EnumDescriptor<any>, options?: Array<Enum>): FilterLookupEnumDescriptor<Enum, TableModel>;
+    addFilterLookupEnumUnsafe<Enum = EnumConstantType>(property: string, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>): FilterLookupEnumDescriptor<Enum, TableModel>;
+    addFilterFromColumn(property: Extract<Filters, keyof TableModel>, forceSimple: boolean): FilterDescriptor<any, TableModel>;
+    addFilterFromColumnUnsafe(property: string, forceSimple: boolean): FilterDescriptor<any, TableModel>;
+    withFiltersFromColumns(...properties: Extract<Filters, keyof TableModel>[]): this;
+    withFiltersFromColumnsUnsafe(...properties: string[]): this;
+    withFilter<FilterModel>(property: Filters, filter: FilterDescriptor<FilterModel, TableModel>): this;
+    withFilterUnsafe<FilterModel>(filter: FilterDescriptor<FilterModel, TableModel>): this;
 }

package/lib/descriptors/table/internal/table.model.d.ts

@@ -1,9 +1,12 @@
+import { FilterDescriptor } from '../../filter';
 import { ModelDescriptor } from '../../model';
+import { ColumnDescriptor } from '../column.descriptor';
 /**
  * This one is internal only to prevent circular dependencies between editor and fields.
  */
 export interface ITableDescriptorInternal<TableModel> {
     model: ModelDescriptor<TableModel>;
-    withDefaultSort(property: keyof TableModel, asc?: boolean): this;
-    withDefaultSortUnsafe(property: string, asc: boolean): this;
+    withDefaultSortUnsafe(property: string, ascending?: boolean, order?: number, enabled?: boolean): this;
+    withSortUnsafe(property: string, isDefault: boolean, ascending?: boolean): this;
+    addFilterFromColumnDescriptorUnsafe<ColumnModel, ColumnValue>(column: ColumnDescriptor<ColumnModel, TableModel, ColumnValue>, forceSimple: boolean): FilterDescriptor<any, TableModel>;
 }