@mediusinc/mng-commons 3.6.0-rc.3 → 3.7.0-rc.0

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

@@ -1,70 +1,54 @@
 import { Type } from '@angular/core';
-import { Observable, Subject } from 'rxjs';
-import { MediusQueryParam } from '../../api/models';
+import { Subject } from 'rxjs';
 import { MngFieldEventData, MngFormEvent, MngFormEventTypeEnum } from '../../components/form/models';
-import { ILookupDataProvider } from '../../data-providers';
+import { ILookupDataProvider, ITableDataProvider } from '../../data-providers';
 import { TableviewAttributeDef } from '../../models';
-import { ClassType, EnumConstantType, EnumType, MngFieldValidationMessage, MngFieldValidator } from '../../types';
-import { ModelDescriptor } from '../model.descriptor';
-import { TableDescriptor } from '../table';
-import { TableviewDescriptor } from '../tableview';
+import { ArrayItemType, ClassType, EnumConstantType, EnumType, IdType, MngFieldValidationMessage, MngFieldValidator, Nullable } from '../../types';
+import { ModelDescriptor } from '../model';
+import { TableDescriptorInst } from '../table';
+import { TableviewDescriptorInst } from '../tableview';
 import { FieldInputTypeEnum, TableviewEditorTypeEnum } from '../types';
-import { AFieldDescriptor, FieldActionDescriptor, FieldGroupDescriptor, FieldInputDescriptor, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor, FieldTabGroupDescriptor } from './field.descriptor';
-export declare class EditorDescriptor<T> {
+import { FieldActionDescriptor } from './field-action.descriptor';
+import { AFieldDescriptor } from './field-base.descriptor';
+import { FieldGroupDescriptor, FieldTabGroupDescriptor } from './field-group.descriptor';
+import { FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldLookupProviderType } from './field-lookup.descriptor';
+import { FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor } from './field-many.descriptor';
+import { FieldInputDescriptor, FieldInputDescriptorType } from './field.descriptor';
+import { IFieldsManageInterface } from './internal/editor-fields.model';
+import { IEditorDescriptorInternal } from './internal/editor.model';
+export declare class EditorDescriptorInst<EditorModel> implements IEditorDescriptorInternal<EditorModel>, IFieldsManageInterface<EditorModel> {
     static readonly defaultGroupName = "_default";
-    /** @ignore */ protected readonly _model: ModelDescriptor<T>;
-    /** @ignore */ protected readonly _modelType: ClassType<T>;
+    /** @ignore */ protected readonly _model: ModelDescriptor<EditorModel>;
     /** @ignore */ protected readonly _tableviewEditorType: TableviewEditorTypeEnum;
-    /** @ignore */ protected readonly _tabs: Array<FieldTabGroupDescriptor<T>>;
-    /** @ignore */ protected readonly _groups: Array<FieldGroupDescriptor<T>>;
-    /** @ignore */ protected _fields: Array<AFieldDescriptor<any, T>>;
-    /** @ignore */ protected _currentTabGroup?: FieldTabGroupDescriptor<T>;
-    /** @ignore */ protected _currentGroup?: FieldGroupDescriptor<T>;
+    /** @ignore */ protected readonly _tabs: Array<FieldTabGroupDescriptor<EditorModel>>;
+    /** @ignore */ protected readonly _groups: Array<FieldGroupDescriptor<EditorModel>>;
+    /** @ignore */ protected _fields: Array<AFieldDescriptor<any, EditorModel>>;
+    /** @ignore */ protected _currentTabGroup?: FieldTabGroupDescriptor<EditorModel>;
+    /** @ignore */ protected _currentGroup?: FieldGroupDescriptor<EditorModel>;
     /** @ignore */ protected _disabled: boolean;
     /** @ignore */ protected _isLocalized: boolean;
     /** @ignore */ protected _localizationLocaleProperty?: string;
+    /** @ignore */ protected _localizationModel?: ModelDescriptor<any>;
     /** @ignore */ protected _localizationLocalizationProperty?: string;
-    /** @ignore */ protected _localizationModelType?: ClassType<any>;
-    /** @ignore */ protected _localeLookup?: (queryParam?: MediusQueryParam, service?: any, search?: string) => Observable<Array<string>>;
-    /** @ignore */ protected readonly _eventsSubject: Subject<MngFormEvent<T>>;
+    /** @ignore */ protected readonly _eventsSubject: Subject<MngFormEvent<EditorModel>>;
     /**
      * Creates new instance of editor descriptor.
-     * @param modelType Model's class.
-     * @param idProperty Id property representing model (optional).
-     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.
+     * @param model Model descriptor.
      * @param tableviewEditorType Type of editor in tableview (add, edit, view or none).
-     * @param i18nBaseKey Base key for translations.
-     */
-    constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string, tableviewEditorType?: TableviewEditorTypeEnum, i18nBaseKey?: string | ClassType<unknown>);
-    /**
-     * Creates editor descriptor automatically based on openapi model's attributes definition which is automatically extracted. All fields will be included.
-     * @param modelType Model's class.
-     * @param idProperty Id property representing model (optional).
-     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.
-     * @param tableEditorType Type of editor in tableview (add, edit, view or none).
      */
-    static from<T>(modelType: ClassType<T>, idProperty?: string, titleProperty?: string, tableEditorType?: TableviewEditorTypeEnum): EditorDescriptor<T>;
-    /**
-     * Creates editor descriptor automatically based on openapi model's attributes definition provided in parameters. Only fields for provided attributes will be included.
-     * @param modelType Model's class.
-     * @param attributes List of attribute definitions from which fields should be created.
-     * @param idProperty Id property representing model (optional).
-     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.
-     * @param tableEditorType Type of editor in tableview (add, edit, view or none).
-     */
-    static fromModelWithAttributes<T>(modelType: ClassType<T>, attributes: TableviewAttributeDef[], idProperty?: string, titleProperty?: string, tableEditorType?: TableviewEditorTypeEnum): EditorDescriptor<T>;
+    protected constructor(model: ModelDescriptor<EditorModel>, tableviewEditorType?: TableviewEditorTypeEnum);
     /**
      * Model descriptor for editor.
      */
-    get model(): ModelDescriptor<T>;
+    get model(): ModelDescriptor<EditorModel, import("../../types").ClassOptType<EditorModel>>;
     /**
      * Editor's tabs.
      */
-    get tabs(): FieldTabGroupDescriptor<T>[];
+    get tabs(): FieldTabGroupDescriptor<EditorModel>[];
     /**
      * Editor's fields.
      */
-    get fields(): AFieldDescriptor<any, T, any>[];
+    get fields(): AFieldDescriptor<any, EditorModel, any>[];
     /**
      * Type of editor for tableview.
      */
@@ -76,69 +60,110 @@ export declare class EditorDescriptor<T> {
     get isLocalized(): boolean;
     get localizationLocaleProperty(): string | undefined;
     get localizationLocalizationProperty(): string | undefined;
-    get localizationBeanType(): ClassType<any> | undefined;
-    get localeLookup(): ((queryParam?: MediusQueryParam | undefined, service?: any, search?: string | undefined) => Observable<string[]>) | undefined;
+    get localizationModel(): ModelDescriptor<any, import("../../types").ClassOptType<any>> | undefined;
     /**
      * Creates new tab group. Next added fields are added to newly created tab group.
      * @param name Name of the group.
      * @param title Title key for the tab.
      */
-    createTabGroup(name: string, title?: string): FieldTabGroupDescriptor<T>;
+    createTabGroup(name: string, title?: string): FieldTabGroupDescriptor<EditorModel>;
     /**
      * Creates new field group. Next added fields are added to newly created field group.
      * @param name Name of the group.
      * @param title Title key for the group.
      */
-    createFieldGroup(name: string, title?: string | null): FieldGroupDescriptor<T>;
+    createFieldGroup(name: string, title?: string | null): FieldGroupDescriptor<EditorModel>;
+    /**
+     * Gets field by the model property name.
+     * @param property Model property name.
+     */
+    getField(property: keyof EditorModel): AFieldDescriptor<any, EditorModel, any> | null;
+    /**
+     * Gets field by the model property name (UNSAFE).
+     * @param property Model property name.
+     */
+    getFieldUnsafe(property: string): AFieldDescriptor<any, EditorModel> | null;
+    /**
+     * Removes field by the model property name.
+     * @param property Model property name.
+     */
+    removeField(property: keyof EditorModel): void;
+    /**
+     * Removes field by the model property name (UNSAFE).
+     * @param property Model property name.
+     */
+    removeFieldUnsafe(property: string): void;
     /**
      * Adds field by the descriptor.
      * @param field Field descriptor.
      */
-    addFieldDescriptor<FT, FVT = FT>(field: AFieldDescriptor<FT, T, FVT>): this;
+    addFieldDescriptor<FieldModel, FieldValue = FieldModel>(field: AFieldDescriptor<FieldModel, EditorModel, FieldValue>): this;
     /**
      * Adds field by the model property name.
      * @param property Model property name.
      */
-    addField(property: string): FieldInputDescriptor<T>;
+    addField<Property extends keyof EditorModel, FieldModel = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property): FieldInputDescriptor<EditorModel, FieldModel, FieldValue>;
     /**
-     * Removes field by the model property name.
+     * Adds field by the model property name (UNSAFE). Property is not checked on editor model.
+     * Use {addField} for safe usage.
      * @param property Model property name.
      */
-    removeField(property: string): void;
+    addFieldUnsafe<FieldModel = FieldInputDescriptorType, FieldValue = FieldModel>(property: string): FieldInputDescriptor<EditorModel, FieldModel, FieldValue>;
+    addFields(...properties: (keyof EditorModel)[]): this;
+    addFieldAction(actionName: string): FieldActionDescriptor<EditorModel>;
     /**
-     * Gets field by the model property name.
+     * Adds lookup field.
      * @param property Model property name.
+     * @param type Model's class type.
      */
-    getField(property: string): AFieldDescriptor<any, T> | null;
-    addFieldAction(actionName: string): FieldActionDescriptor<T>;
+    addFieldLookup<K extends keyof EditorModel, FieldModel = NonNullable<EditorModel[K]>, FieldValue = EditorModel[K]>(property: K, type?: ClassType<FieldModel>): FieldLookupDescriptor<FieldModel, EditorModel, undefined, FieldValue, string>;
     /**
-     * Adds lookup field.
+     * Adds lookup field (UNSAFE).
      * @param property Model property name.
-     * @param modelType Model's class type (must be registered in ObjectSerializer!).
+     * @param type Model's class type.
      */
-    addFieldLookup<FT>(property: string, modelType: ClassType<FT>): FieldLookupDescriptor<FT, T>;
+    addFieldLookupUnsafe<FieldModel, FieldValue = FieldModel>(property: string, type?: ClassType<FieldModel>): FieldLookupDescriptor<FieldModel, EditorModel, undefined, FieldValue, string>;
+    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>;
     /**
      * Adds enum lookup field.
      * @param property Model's property name.
-     * @param enumType Type of enum (must be registered in ObjectSerializer!).
+     * @param enumType Type of enum.
      * @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.
      */
-    addFieldLookupEnum(property: string, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null): FieldLookupEnumDescriptor<T>;
+    addFieldLookupEnumUnsafe(property: string, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null): FieldLookupEnumDescriptor<EditorModel>;
     /**
      * Adds table/details/add/edit field for one-to-many (1:n) relations.
      * @param property Model's property name.
      * @param tableviewDescriptor Tableview descriptor for related model.
      */
-    addFieldManyEditor<FT>(property: string, tableviewDescriptor: TableviewDescriptor<FT>): FieldManyEditorDescriptor<FT, T>;
+    addFieldManyEditor<Property extends keyof EditorModel, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, tableviewDescriptor: TableviewDescriptorInst<FieldModel>): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue>;
+    /**
+     * Adds table/details/add/edit field for one-to-many (1:n) relations (UNSAFE).
+     * @param property Model's property name.
+     * @param tableviewDescriptor Tableview descriptor for related model.
+     */
+    addFieldManyEditorUnsafe<FieldModel, FieldValue = FieldModel[]>(property: string, tableviewDescriptor: TableviewDescriptorInst<FieldModel>): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue>;
     /**
      * Adds tables for many-to-many (m:n) relations.
      * @param property Model's property name.
      * @param mainTableDescriptor Main table descriptor for displaying items added to main model's property.
      * @param lookupTableDescriptor Lookup table descriptor for displaying items to be added to main model's property.
      */
-    addFieldManyToManyEditor<FT>(property: string, mainTableDescriptor: TableDescriptor<FT>, lookupTableDescriptor: TableDescriptor<FT>): FieldManyToManyEditorDescriptor<FT, T>;
+    addFieldManyToManyEditor<Property extends keyof EditorModel, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, mainTableDescriptor: TableDescriptorInst<FieldModel>, lookupTableDescriptor: TableDescriptorInst<FieldModel>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, undefined, FieldValue>;
+    /**
+     * Adds tables for many-to-many (m:n) relations (UNSAFE).
+     * @param property Model's property name.
+     * @param mainTableDescriptor Main table descriptor for displaying items added to main model's property.
+     * @param lookupTableDescriptor Lookup table descriptor for displaying items to be added to main model's property.
+     */
+    addFieldManyToManyEditorUnsafe<FieldModel, FieldValue = FieldModel[]>(property: string, mainTableDescriptor: TableDescriptorInst<FieldModel>, lookupTableDescriptor: TableDescriptorInst<FieldModel>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, undefined, FieldValue>;
+    addFieldManyToManyEditorWithProvider<Property extends keyof EditorModel, ServiceType, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, mainTableDescriptor: TableDescriptorInst<FieldModel>, lookupTableDescriptor: TableDescriptorInst<FieldModel>, lookupDataProvider: ITableDataProvider<FieldModel, ServiceType>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, ServiceType, FieldValue>;
+    addFieldManyToManyEditorWithProviderUnsafe<FieldModel, ServiceType, FieldValue = FieldModel[]>(property: string, mainTableDescriptor: TableDescriptorInst<FieldModel>, lookupTableDescriptor: TableDescriptorInst<FieldModel>, lookupDataProvider: ITableDataProvider<FieldModel, ServiceType>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, ServiceType, FieldValue>;
     /**
      * Disables field on editor.
      * @param disabled
@@ -154,19 +179,19 @@ export declare class EditorDescriptor<T> {
     /**
      * Creates a copy of editor descriptor object.
      */
-    copy(): EditorDescriptor<T>;
+    copy(): EditorDescriptorInst<EditorModel>;
     /**
      * Created group from field group descriptor.
      * @param fieldGroup Field group descriptor.
      * @internal
      */
-    createFieldGroupDescriptor(fieldGroup: FieldGroupDescriptor<T>): this;
+    createFieldGroupDescriptor(fieldGroup: FieldGroupDescriptor<EditorModel>): this;
     /**
      * Creates tab group from tab group descriptor.
      * @param tabGroup Tab group descriptor.
      * @internal
      */
-    protected createTabGroupDescriptor(tabGroup: FieldTabGroupDescriptor<T>): this;
+    protected createTabGroupDescriptor(tabGroup: FieldTabGroupDescriptor<EditorModel>): this;
     /**
      * Creates default field group.
      * @internal
@@ -183,40 +208,67 @@ export declare class EditorDescriptor<T> {
      * @param fieldType new field type for selected field
      * @param args additional parameters for field
      */
-    withFieldModifiedType(property: string, fieldType: FieldInputTypeEnum, ...args: any[]): this;
+    withFieldModifiedType(property: keyof EditorModel, fieldType: FieldInputTypeEnum, ...args: any[]): this;
+    withFieldModifiedTypeUnsafe(property: string, fieldType: FieldInputTypeEnum, ...args: any[]): this;
     /**
      * Modifies selected field with enum type.
      * @param property Model's property name.
      * @param enumType type of enum for new field
      * @param optionsTitlePath
      * @param values
+     * @param nameAsValue
      */
-    withFieldModifiedEnum(property: string, enumType?: EnumType, optionsTitlePath?: string | null, values?: Array<EnumConstantType>, nameAsValue?: boolean): this;
+    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;
     /**
      * Modifies selected field with lookup field.
      * @param property Model's property name.
-     * @param modelType model type of field
      * @param lookupProvider provider to be added to field
      * @param titleProperty
      */
-    withFieldModifiedLookup<MT>(property: string, modelType: ClassType<MT>, lookupProvider: ILookupDataProvider<any, any>, titleProperty?: string): this;
+    withFieldModifiedLookupWithProvider<ServiceType, FieldModel>(property: keyof EditorModel, lookupProvider: ILookupDataProvider<FieldModel, ServiceType>, titleProperty?: keyof FieldModel): this;
+    withFieldModifiedLookupWithProviderUnsafe<ServiceType, FieldModel>(property: string, lookupProvider: ILookupDataProvider<FieldModel, ServiceType>, titleProperty?: string): this;
+    /**
+     * This method takes care of displaying correct/localized data in the editor
+     * @param property property that tells us where on the model are localizations accessible
+     * @param model Model for localizations
+     * @param localeProperty property by which we find the locale
+     */
+    localized<Property extends keyof EditorModel, LocalizationModel = ArrayItemType<EditorModel[Property]>>(property: Property, model: ModelDescriptor<LocalizationModel>, localeProperty: keyof LocalizationModel): this;
+    localizedUnsafe<LocalizationType>(property: string, model: ModelDescriptor<LocalizationType>, localeProperty: string): this;
+    nextEvent(type: MngFormEventTypeEnum, cmpType: Type<any>, cmpInstance: any, data?: MngFieldEventData<EditorModel>): void;
+    completeEvents(): void;
+    get events$(): import("rxjs").Observable<MngFormEvent<EditorModel>>;
     /**
      * Generates field based on attribute definition, used for auto model
+     * @param descriptor Editor descriptor instance.
      * @param attribute Attribute definition.
      * @param field Optional, if defined will be replaced, otherwise new will be generated.
      * @param args Optional additional arguments mapped to filed type. Arguments depend on possible arguments on fields.
      * @internal
      */
-    private upsertFieldFromAttributeDef;
+    protected static upsertFieldFromAttributeDef<T>(descriptor: EditorDescriptorInst<T>, attribute: TableviewAttributeDef, field?: AFieldDescriptor<any, T>, ...args: any[]): AFieldDescriptor<any, T>;
+}
+export declare class EditorDescriptor extends EditorDescriptorInst<any> {
+    protected constructor();
+    static create<EditorModel>(idProperty: keyof EditorModel, titleProperty: keyof EditorModel, i18nBaseKey: string | ClassType<unknown>, tableviewEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel>;
+    static fromClass<EditorModel>(type: ClassType<EditorModel>, idProperty?: keyof EditorModel, titleProperty?: keyof EditorModel, i18nBaseKey?: ClassType<unknown> | string, tableviewEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel>;
+    static fromModel<EditorModel>(model: ModelDescriptor<EditorModel>, tableviewEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel>;
     /**
-     * This method takes care of displaying correct/localized data in the editor
-     * @param localizationsProperty property that tells us where on the model are localizations accessible
-     * @param localeProperty property by which we find the locale
-     * @param localizationModelType model type for localizations if it is different from the whole model
-     * @param localeLookup lookup provider for locales supported by the application.
+     * Creates editor descriptor automatically based on openapi model's attributes definition which is automatically extracted. All fields will be included.
+     * @param type Model's class.
+     * @param idProperty Id property representing model (optional).
+     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.
+     * @param tableEditorType Type of editor in tableview (add, edit, view or none).
      */
-    localized<S>(localizationsProperty?: string, localeProperty?: string, localizationModelType?: ClassType<any>, localeLookup?: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<string>>): this;
-    nextEvent(type: MngFormEventTypeEnum, cmpType: Type<any>, cmpInstance: any, data?: MngFieldEventData<T>): void;
-    completeEvents(): void;
-    get events$(): Observable<MngFormEvent<T>>;
+    static fromClassWithAutoAttrsDef<EditorModel>(type: ClassType<EditorModel>, idProperty?: keyof EditorModel, titleProperty?: keyof EditorModel, tableEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel>;
+    /**
+     * Creates editor descriptor automatically based on openapi model's attributes definition provided in parameters. Only fields for provided attributes will be included.
+     * @param type Model's class.
+     * @param attributes List of attribute definitions from which fields should be created.
+     * @param idProperty Id property representing model (optional).
+     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.
+     * @param tableEditorType Type of editor in tableview (add, edit, view or none).
+     */
+    static fromClassWithCustomAttrsDef<EditorModel>(type: ClassType<EditorModel>, attributes: TableviewAttributeDef[], idProperty?: keyof EditorModel, titleProperty?: keyof EditorModel, tableEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel>;
 }

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

@@ -0,0 +1,23 @@
+import { Observable } from 'rxjs';
+import { FieldActionContext, FieldActionResult } from '../../components/form/models';
+import { StyleLevelEnum } from '../../styles/models';
+import { ActionButtonDescriptor } from '../action';
+import { AFieldDescriptor } from './field-base.descriptor';
+import { IEditorDescriptorInternal } from './internal/editor.model';
+export type FieldActionRunFnType<EditorModel> = (ctx: FieldActionContext<EditorModel>) => void | FieldActionResult | Observable<FieldActionResult>;
+export declare class FieldActionDescriptor<EditorModel> extends AFieldDescriptor<void, EditorModel> {
+    protected readonly _fieldActionName: string;
+    protected readonly _fieldActionNameLong: string;
+    protected _button: ActionButtonDescriptor;
+    protected _runFunction?: FieldActionRunFnType<EditorModel>;
+    private _wrappers;
+    constructor(editor: IEditorDescriptorInternal<EditorModel>, property: string);
+    get button(): ActionButtonDescriptor;
+    get runFunction(): FieldActionRunFnType<EditorModel> | undefined;
+    get wrappers(): string[];
+    withButtonDescriptor(button: ActionButtonDescriptor): this;
+    withButton(label?: string | null, icon?: string | null, styleLevel?: StyleLevelEnum, styleText?: boolean): this;
+    withRunFunction(fn: FieldActionRunFnType<EditorModel>): this;
+    withWrappers(wrappers: string[]): this;
+    copy(): FieldActionDescriptor<EditorModel>;
+}

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

@@ -0,0 +1,126 @@
+import { Type } from '@angular/core';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { Observable, Subject } from 'rxjs';
+import { MngFormlyFieldConfig, MngFormlyHookFn } from '../../components/form/formly/models';
+import { MngFormFieldEvent, MngFormFieldEventData, MngFormFieldEventTypeEnum } from '../../components/form/models';
+import { GetterFn, MngFieldAsyncValidator, MngFieldValidationMessage, MngFieldValidator } from '../../types';
+import { FieldConfig } from '../interfaces';
+import { ITableviewDescriptorInternal } from '../tableview/internal/tableview.model';
+import { FieldSizeEnum } from '../types';
+import { FieldValidationDescriptor } from './field-validation.descriptor';
+import { IEditorDescriptorInternal } from './internal/editor.model';
+export declare abstract class AGenericFieldDescriptor<EditorModel> {
+    protected readonly _editor: IEditorDescriptorInternal<EditorModel>;
+    protected _config: FieldConfig;
+    protected constructor(editor: IEditorDescriptorInternal<EditorModel>);
+    get editor(): IEditorDescriptorInternal<EditorModel>;
+    get config(): FieldConfig;
+    withConfig(config: FieldConfig): this;
+    /**
+     * Override toJSON implementation to prevent overflow with circular dependency.
+     * @ignore
+     */
+    protected toJSON(): string;
+}
+export declare abstract class AFieldDescriptor<FieldModel, EditorModel, FieldValue = FieldModel> extends AGenericFieldDescriptor<EditorModel> {
+    /** @ignore */ protected readonly _property: string;
+    /** @ignore */ protected _label?: string | null;
+    /** @ignore */ protected _placeholder?: string;
+    /** @ignore */ protected _helpText?: string;
+    /** @ignore */ protected _required: boolean;
+    /** @ignore */ protected _requiredHideLabelMarker: boolean;
+    /** @ignore */ protected _disabled: boolean;
+    /** @ignore */ protected _defaultValue?: FieldValue;
+    /** @ignore */ protected _getter?: GetterFn<FieldValue, EditorModel>;
+    /** @ignore */ protected _setter?: (item: EditorModel, value: FieldValue) => void;
+    /** @ignore */ protected _validations: Array<FieldValidationDescriptor>;
+    /** @ignore */ protected _asyncValidations: Array<FieldValidationDescriptor>;
+    /** @ignore */ protected _requiredExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
+    /** @ignore */ protected _disabledExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
+    /** @ignore */ protected _hiddenExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
+    /** @ignore */ protected _updateOn: 'change' | 'blur' | 'submit';
+    /** @ignore */ protected _onInit?: MngFormlyHookFn;
+    /** @ignore */ protected _onChanges?: MngFormlyHookFn;
+    /** @ignore */ protected _afterContentInit?: MngFormlyHookFn;
+    /** @ignore */ protected _afterViewInit?: MngFormlyHookFn;
+    /** @ignore */ protected _onDestroy?: MngFormlyHookFn;
+    /** @ignore */ protected _onValueChange?: (field: MngFormlyFieldConfig, value: any) => void;
+    /** @ignore */ protected _className: string;
+    /** @ignore */ protected _fieldClassName?: string;
+    /** @ignore */ protected _labelClassName: string;
+    /** @ignore */ protected _inputClassName: string;
+    /** @ignore */ protected _size: FieldSizeEnum;
+    /** @ignore */ protected _isLocalized: boolean;
+    /** @ignore */ protected _localizationTableview?: ITableviewDescriptorInternal<any>;
+    /** @ignore */ protected readonly _eventsSubject: Subject<MngFormFieldEvent<FieldModel, EditorModel>>;
+    protected constructor(editor: IEditorDescriptorInternal<EditorModel>, property: string);
+    get property(): string;
+    get label(): string | null | undefined;
+    get placeholder(): string | undefined;
+    get helpText(): string | undefined;
+    get required(): boolean;
+    get requiredHideLabelMarker(): boolean;
+    get disabled(): boolean;
+    get defaultValue(): FieldValue | undefined;
+    get getter(): GetterFn<FieldValue, EditorModel> | undefined;
+    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 & {
+        [additionalProperties: string]: any;
+    }> | undefined) => 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 onInit(): MngFormlyHookFn | undefined;
+    get onChanges(): MngFormlyHookFn | undefined;
+    get afterContentInit(): MngFormlyHookFn | undefined;
+    get afterViewInit(): MngFormlyHookFn | undefined;
+    get onDestroy(): MngFormlyHookFn | undefined;
+    get onValueChange(): ((field: MngFormlyFieldConfig<import("../../components/form/formly/models").MngFormlyFieldProps>, value: any) => void) | undefined;
+    get className(): string;
+    get fieldClassName(): string | undefined;
+    get labelClassName(): string;
+    get inputClassName(): string;
+    get size(): FieldSizeEnum;
+    get localizationTableview(): ITableviewDescriptorInternal<any> | undefined;
+    get isSizeSmall(): boolean;
+    get isSizeLarge(): boolean;
+    get isLocalized(): boolean;
+    abstract copy(): AFieldDescriptor<FieldModel, EditorModel, FieldValue>;
+    withLabel(label: string | null): this;
+    withPlaceholder(placeholder: string): this;
+    withHelpText(helpText: string): this;
+    withRequired(required?: boolean, requiredExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>, hideLabelMarker?: boolean): this;
+    withDisabled(disabled?: boolean, disabledExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>): this;
+    withHidden(hiddenExpression: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>): this;
+    withUpdateOn(updateOn: 'change' | 'blur' | 'submit'): this;
+    withOnInit(onInit?: MngFormlyHookFn): this;
+    withOnChanges(onChanges?: MngFormlyHookFn): this;
+    withAfterContentInit(afterContentInit?: MngFormlyHookFn): this;
+    withAfterViewInit(afterViewInit?: MngFormlyHookFn): this;
+    withOnDestroy(onDestroy?: MngFormlyHookFn): this;
+    withOnValueChange(onValueChange?: (field: MngFormlyFieldConfig, value: any) => void): this;
+    withDefaultValue(defaultValue: FieldValue): this;
+    withGetter(fn?: GetterFn<FieldValue, EditorModel>): this;
+    withSetter(fn?: (item: EditorModel, value: FieldValue) => void): this;
+    withValidation(name: string, validator?: MngFieldValidator, message?: MngFieldValidationMessage): this;
+    removeValidation(name: string): this;
+    withAsyncValidation(name: string, asyncValidator?: MngFieldAsyncValidator, message?: MngFieldValidationMessage): this;
+    removeAsyncValidation(name: string): this;
+    withClassName(className: string, labelClassName?: string, inputClassName?: string, fieldClassName?: string): this;
+    withSize(size?: FieldSizeEnum): this;
+    /**
+     * This method adds an icon with text Show all translations above the field and after clicking on it, it displays a new dialog with tableview.
+     * This new table view shows all available translations for specific property and allows editing it.
+     * @param tableview with lookup provider for locales
+     */
+    localized<LocalizationModel = any>(tableview?: ITableviewDescriptorInternal<LocalizationModel>): this;
+    nextEvent(type: MngFormFieldEventTypeEnum, cmpType: Type<any>, cmpInstance: any, data?: MngFormFieldEventData<FieldModel, EditorModel>): void;
+    get events$(): Observable<MngFormFieldEvent<FieldModel, EditorModel>>;
+    protected copyFieldsTo(obj: AFieldDescriptor<FieldModel, EditorModel, FieldValue>): void;
+}

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

@@ -0,0 +1,42 @@
+import { MngFieldValidationMessage, MngFieldValidator } from '../../types';
+import { FieldGroupTypeEnum } from '../types';
+import { AFieldDescriptor, AGenericFieldDescriptor } from './field-base.descriptor';
+import { FieldValidationDescriptor } from './field-validation.descriptor';
+import { IEditorDescriptorInternal } from './internal/editor.model';
+export declare abstract class AFieldGroupDescriptor<EditorModel> extends AGenericFieldDescriptor<EditorModel> {
+    protected readonly _name: string;
+    protected readonly _default: boolean;
+    protected _title?: string;
+    protected _fields: AGenericFieldDescriptor<EditorModel>[];
+    protected _validations: Array<FieldValidationDescriptor>;
+    protected constructor(editor: IEditorDescriptorInternal<EditorModel>, name: string);
+    removeField(property: string, filterFunction: (fields: AGenericFieldDescriptor<EditorModel>[]) => AGenericFieldDescriptor<EditorModel>[]): AGenericFieldDescriptor<EditorModel>[];
+    get title(): string | undefined;
+    abstract get fields(): AGenericFieldDescriptor<EditorModel>[];
+    get validations(): FieldValidationDescriptor[];
+    get baseName(): string;
+    get name(): string;
+    get default(): boolean;
+    abstract groupName(): string;
+    abstract addField(field: AGenericFieldDescriptor<EditorModel>): this;
+    abstract copy(): AFieldGroupDescriptor<EditorModel>;
+    withTitle(title: string): this;
+    withValidation(name: string, validator?: MngFieldValidator, message?: MngFieldValidationMessage): this;
+}
+export declare class FieldTabGroupDescriptor<EditorModel> extends AFieldGroupDescriptor<EditorModel> {
+    constructor(editor: IEditorDescriptorInternal<EditorModel>, name: string);
+    get fields(): Array<FieldGroupDescriptor<EditorModel>>;
+    groupName(): string;
+    addField(field: FieldGroupDescriptor<EditorModel>): this;
+    copy(): FieldTabGroupDescriptor<EditorModel>;
+}
+export declare class FieldGroupDescriptor<EditorModel> extends AFieldGroupDescriptor<EditorModel> {
+    private _type;
+    constructor(editor: IEditorDescriptorInternal<EditorModel>, name: string);
+    get type(): FieldGroupTypeEnum;
+    get fields(): Array<AFieldDescriptor<any, EditorModel>>;
+    groupName(): string;
+    addField(field: AFieldDescriptor<any, EditorModel>): this;
+    asLogical(): this;
+    copy(): FieldGroupDescriptor<EditorModel>;
+}

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

@@ -0,0 +1,80 @@
+import { ILookupDataProvider, ITableDataProvider, LookupDataProviderLookupFnType } from '../../data-providers';
+import { EnumValue } from '../../models';
+import { ClassType, EnumConstantType, EnumType, ServiceClassType } from '../../types';
+import { FieldLookupConfig, ILookupDescriptor } from '../interfaces';
+import { TableDescriptorInst } from '../table';
+import { FieldLookupTypeEnum } from '../types';
+import { AFieldDescriptor } from './field-base.descriptor';
+import { IEditorDescriptorInternal } from './internal/editor.model';
+export type FieldLookupDescriptorConstructorOptsType<EditorModel, Service> = FieldLookupDescriptorCreateOptsProviderType<EditorModel, Service> & {
+    type?: ClassType<EditorModel>;
+    optionsValueProperty?: string;
+};
+export type FieldLookupDescriptorCreateOptsProviderType<FieldModel, Service> = {
+    serviceType?: ServiceClassType<Service>;
+    dataProvider?: ILookupDataProvider<FieldModel, Service>;
+};
+export type FieldLookupProviderType<FieldModel, Service> = ServiceClassType<Service> | ILookupDataProvider<FieldModel, Service>;
+export type FieldLookupAutocompleteOptsType = {
+    openOnFocus?: boolean;
+    inlineSearch?: boolean;
+    selectFirst?: boolean;
+    autoClear?: boolean;
+};
+export declare const fieldLookupGetProviderCfgObj: <FieldModel, Service>(serviceOrDataProvider?: FieldLookupProviderType<FieldModel, Service> | undefined) => FieldLookupDescriptorCreateOptsProviderType<FieldModel, Service>;
+export declare class FieldLookupDescriptor<FieldModel, EditorModel, Service = any, FieldValue = FieldModel, Property = string> extends AFieldDescriptor<FieldModel, EditorModel, FieldValue> implements ILookupDescriptor<FieldModel, Service> {
+    protected readonly _dataProvider: ILookupDataProvider<FieldModel, Service>;
+    protected readonly _optionsValueProperty?: string;
+    protected _lookupType: FieldLookupTypeEnum;
+    protected _optionsLabelProperty?: string;
+    protected _optionsLabelTranslate: boolean;
+    protected _optionsDisabledProperty?: string;
+    protected _optionsTrackProperty?: string;
+    protected _dropdownClassName: string;
+    protected _autocompleteOpenOnFocus?: boolean;
+    protected _autocompleteInlineSearch?: boolean;
+    protected _autocompleteAutoClear?: boolean;
+    protected _autocompleteSelectFirst?: boolean;
+    protected _dialogTableDescriptor?: TableDescriptorInst<FieldModel>;
+    protected _dialogTableDataProvider?: ITableDataProvider<FieldModel, any>;
+    protected _customComponentName?: string;
+    constructor(editor: IEditorDescriptorInternal<EditorModel>, property: Property, cfg?: FieldLookupDescriptorConstructorOptsType<FieldModel, Service>);
+    get lookupType(): FieldLookupTypeEnum;
+    get optionsLabelProperty(): string | undefined;
+    get optionsLabelTranslate(): boolean;
+    get optionsValueProperty(): string | undefined;
+    get optionsDisabledProperty(): string | undefined;
+    get optionsTrackProperty(): string | undefined;
+    get dataProvider(): ILookupDataProvider<FieldModel, Service>;
+    get autocompleteOpenOnFocus(): boolean | undefined;
+    get autocompleteInlineSearch(): boolean | undefined;
+    get autocompleteAutoClear(): boolean | undefined;
+    get autocompleteSelectFirst(): boolean | undefined;
+    get dropdownClassName(): string;
+    get dialogTableDescriptor(): TableDescriptorInst<FieldModel> | undefined;
+    get dialogTableDataProvider(): ITableDataProvider<FieldModel, any> | undefined;
+    get customComponentName(): string | undefined;
+    withOptionsLabelProperty(property: keyof FieldModel, translate?: boolean): this;
+    withOptionsLabelPropertyUnsafe(property: string, translate?: boolean): this;
+    withOptionsDisabledProperty(property: keyof FieldModel): this;
+    withOptionsDisabledPropertyUnsafe(property: string): this;
+    withOptionsTrackProperty(property: keyof FieldModel): this;
+    withOptionsTrackPropertyUnsafe(property: string): this;
+    withLookup(lookup?: LookupDataProviderLookupFnType<FieldModel, Service>): this;
+    withConfig(config: FieldLookupConfig): this;
+    asAutocomplete(opts?: FieldLookupAutocompleteOptsType): this;
+    asDialog(lookupTableDescriptor: TableDescriptorInst<FieldModel>, tableDataProvider?: ITableDataProvider<FieldModel, 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;
+    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>;
+    withDisabledOptions(...disabledOptions: Array<EnumConstantType>): this;
+    withDefaultValueEnum(defaultValue: EnumConstantType): this;
+    asAutocomplete(opts?: FieldLookupAutocompleteOptsType): this;
+    copy(): FieldLookupEnumDescriptor<EditorModel>;
+}