@mediusinc/mng-commons 4.2.0 → 5.0.0-rc.0

package/tableview/api/editor/descriptors/field-lookup.descriptor.d.ts

@@ -0,0 +1,80 @@
+import { ClassType, EnumConstantType, EnumValue, IEditorDescriptorInternal, ILookupDataProvider, ILookupDescriptor, LookupDataProviderLookupFnType, ServiceClassType } from '@mediusinc/mng-commons/core';
+import { InputTrimType } from '@mediusinc/mng-commons/form/api';
+import { EnumDescriptor } from '@mediusinc/mng-commons/model';
+import { ITableDataProvider, TableDescriptorInst } from '@mediusinc/mng-commons/table/api';
+import { FieldLookupConfig, FieldLookupTypeEnum } from '../models/field.model';
+import { AFieldDescriptor } from './field-base.descriptor';
+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> 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 _autocompleteInputTrim?: InputTrimType;
+    protected _dialogTableDescriptor?: TableDescriptorInst<FieldModel>;
+    protected _dialogTableDataProvider?: ITableDataProvider<FieldModel, any, any, any>;
+    protected _customComponentName?: string;
+    constructor(editor: IEditorDescriptorInternal<EditorModel>, property: string, 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, 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;
+    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;
+    withInputTrim(trimOption?: InputTrimType): this;
+    withConfig(config: FieldLookupConfig): this;
+    asAutocomplete(opts?: FieldLookupAutocompleteOptsType): 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<Enum, EditorModel> extends FieldLookupDescriptor<EnumValue, EditorModel, undefined, EnumConstantType> {
+    private readonly _enumModel;
+    private readonly _optionEnumValues;
+    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<Enum, EditorModel>;
+}

package/tableview/api/editor/descriptors/field-many.descriptor.d.ts

@@ -0,0 +1,61 @@
+import { IEditorDescriptorInternal, ServiceClassType } from '@mediusinc/mng-commons/core';
+import { ITableDataProvider, TableDataProviderGetAllFnType, TableDescriptorInst } from '@mediusinc/mng-commons/table/api';
+import { ActionDescriptorInst } from '../../action/descriptors/action.descriptor';
+import { TableviewDescriptorInst } from '../../tableview/descriptors/tableview.descriptor';
+import { FieldManyEditorActionEnum, FieldManyEditorTypeEnum, FieldManyToManyEditorActionEnum, FieldManyToManyEditorTypeEnum } from '../models/field.model';
+import { AFieldDescriptor } from './field-base.descriptor';
+export type FieldManyToManyEditorDescriptorConstructorOptsType<FieldModel, Service> = FieldManyToManyEditorDescriptorCreateOptsProviderType<FieldModel, Service>;
+export type FieldManyToManyEditorDescriptorCreateOptsProviderType<FieldModel, Service> = {
+    lookupServiceType?: ServiceClassType<Service>;
+    lookupDataProvider?: ITableDataProvider<FieldModel, Service>;
+};
+export type FieldManyToManyEditorProviderType<FieldModel, Service> = ServiceClassType<Service> | ITableDataProvider<FieldModel, Service>;
+export declare const fieldManyToManyGetProviderCfgObj: <FieldModel, Service>(serviceOrDataProvider?: FieldManyToManyEditorProviderType<FieldModel, Service> | undefined) => FieldManyToManyEditorDescriptorCreateOptsProviderType<FieldModel, Service>;
+export declare class FieldManyToManyEditorDescriptor<FieldModel, EditorModel, Service = any, FieldValue = FieldModel[]> extends AFieldDescriptor<FieldModel, EditorModel, FieldValue> {
+    private readonly _mainTableDescriptor;
+    private readonly _lookupTableDescriptor;
+    private readonly _lookupTableDataProvider;
+    private _fieldType;
+    private _actions;
+    private _hasLookupExcludeValues;
+    private _excludeFilterProperty;
+    private _excludeValueProperty;
+    private _searchEnabled;
+    private _searchFields?;
+    constructor(editor: IEditorDescriptorInternal<EditorModel>, property: string, mainTableDescriptor: TableDescriptorInst<FieldModel>, lookupTableDescriptor: TableDescriptorInst<FieldModel>, cfg?: FieldManyToManyEditorDescriptorConstructorOptsType<FieldModel, Service>);
+    get fieldType(): FieldManyToManyEditorTypeEnum;
+    get actions(): FieldManyToManyEditorActionEnum[];
+    get hasLookupExcludeValues(): boolean;
+    get excludeFilterProperty(): string;
+    get excludeValueProperty(): string;
+    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;
+    withLookup(fn: TableDataProviderGetAllFnType<FieldModel, Service>): this;
+    withActions(actions?: Array<FieldManyToManyEditorActionEnum>): this;
+    withLookupExclude(filterProperty: keyof FieldModel, valueProperty: keyof FieldModel, hasLookupExclude?: boolean): this;
+    withLookupExcludeUnsafe(filterProperty: string, valueProperty: string, hasLookupExclude?: boolean): this;
+    withSearch(enabled?: boolean, searchFields?: string[]): this;
+    copy(): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, Service, FieldValue>;
+}
+export declare class FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue = FieldModel[]> extends AFieldDescriptor<FieldModel, EditorModel, FieldValue> {
+    private readonly _tableviewDescriptor;
+    private _fieldType;
+    private _fieldActions;
+    private _actions;
+    constructor(editor: IEditorDescriptorInternal<EditorModel>, property: string, tableviewDescriptor: TableviewDescriptorInst<FieldModel, any, any>);
+    get fieldType(): FieldManyEditorTypeEnum;
+    get fieldActions(): FieldManyEditorActionEnum[];
+    get actions(): ActionDescriptorInst<FieldModel, any>[];
+    get tableviewDescriptor(): TableviewDescriptorInst<FieldModel, any, any>;
+    get tableDescriptor(): TableDescriptorInst<FieldModel, any, any>;
+    get editorForCreate(): import("@mediusinc/mng-commons/tableview/api").EditorDescriptorInst<FieldModel>;
+    get editorForRead(): import("@mediusinc/mng-commons/tableview/api").EditorDescriptorInst<FieldModel>;
+    get editorForUpdate(): import("@mediusinc/mng-commons/tableview/api").EditorDescriptorInst<FieldModel>;
+    withFieldAction(action: FieldManyEditorActionEnum): this;
+    withFieldActions(actions: FieldManyEditorActionEnum[]): this;
+    withAction(action: ActionDescriptorInst<FieldModel>): this;
+    copy(): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue>;
+}

package/tableview/api/editor/descriptors/field-validation.descriptor.d.ts

@@ -0,0 +1,19 @@
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { Observable } from 'rxjs';
+import { FieldAsyncValidator, FieldValidationMessage, FieldValidator } from '../models/field.model';
+export declare class FieldValidationDescriptor {
+    private readonly _name;
+    private readonly _validator?;
+    private readonly _message?;
+    private readonly _options?;
+    constructor(name: string, validator?: FieldValidator | FieldAsyncValidator, message?: string | ((error: any, field: FormlyFieldConfig) => string | Observable<string>), options?: {
+        errorPath: string;
+    });
+    get name(): string;
+    get validator(): FieldValidator | FieldAsyncValidator | undefined;
+    get message(): FieldValidationMessage | undefined;
+    get options(): {
+        errorPath: string;
+    } | undefined;
+    copy(): FieldValidationDescriptor;
+}

package/tableview/api/editor/descriptors/field.descriptor.d.ts

@@ -0,0 +1,168 @@
+import { Type } from '@angular/core';
+import { AbstractControl } from '@angular/forms';
+import { IEditorDescriptorInternal } from '@mediusinc/mng-commons/core';
+import { InputTrimType } from '@mediusinc/mng-commons/form/api';
+import { EnumDescriptor } from '@mediusinc/mng-commons/model';
+import { FieldInputTypeEnum } from '../models/field.model';
+import { AFormlyCustomFieldComponent } from '../models/formly-custom-field.model';
+import { RadioValue } from '../models/radio.model';
+import { AFieldDescriptor } from './field-base.descriptor';
+export type FieldInputDescriptorType = string | string[] | number | boolean | Date | File | File[];
+export type FieldInputTextOptsType = {
+    email?: boolean;
+} & FieldInputTextValidationOptsType;
+export type FieldInputTextareaOptsType = {
+    rows?: number;
+} & FieldInputTextValidationOptsType;
+export type FieldInputTextValidationOptsType = {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string | RegExp;
+};
+export type FieldInputCurrencyOptsType<Property = string> = {
+    currencyProperty?: Property;
+    currency?: string;
+    currencyDisplay?: 'symbol' | 'code' | 'name';
+} & FieldInputNumberGroupingOptsType & FieldInputNumberFractionOptsType & FieldInputNumberValidationOptsType & FieldInputLocaleOptsType;
+export type FieldInputNumberOptsType = FieldInputNumberGroupingOptsType & FieldInputNumberFractionOptsType & FieldInputNumberValidationOptsType & FieldInputLocaleOptsType;
+export type FieldInputNumberGroupingOptsType = {
+    groupSeparator?: boolean;
+};
+export type FieldInputNumberValidationOptsType = {
+    min?: number;
+    max?: number;
+    step?: number;
+    autoCorrect?: boolean;
+};
+export type FieldInputNumberFractionOptsType = {
+    minFractionDigits?: number;
+    maxFractionDigits?: number;
+};
+export type FieldInputLocaleOptsType = {
+    locale?: string;
+};
+export type FieldInputDatePickerOptsType = {
+    format?: string;
+    min?: Date;
+    max?: Date;
+    showTime?: boolean;
+    showSeconds?: boolean;
+};
+export type FieldInputFileOpts = {
+    multiple?: boolean;
+    maxFileSize?: number;
+    accept?: string;
+    onFileSelectHandlerFn?: FieldInputFileOnSelectHandlerFnType;
+};
+export type FieldInputImageUrlOpts = {
+    multiple?: boolean;
+    preview?: boolean;
+    inputVisibleOnDisabled?: boolean;
+};
+export type FieldInputComponentOpts = {
+    fieldWrappers?: string[];
+    inputs?: Record<string, any>;
+};
+export type FieldInputFileOnSelectHandlerFnType = (file: File[] | null, control: AbstractControl) => void;
+export declare class FieldInputDescriptor<EditorModel, FieldModel = FieldInputDescriptorType, FieldValue = FieldModel> extends AFieldDescriptor<FieldModel, EditorModel, FieldValue> {
+    private _fieldType;
+    private _rows?;
+    private _numberMin?;
+    private _numberMax?;
+    private _numberStep?;
+    private _numberAutoCorrect?;
+    private _numberMinFractionDigits?;
+    private _numberMaxFractionDigits?;
+    private _numberUseGrouping;
+    private _locale?;
+    private _currency?;
+    private _currencyDisplay;
+    private _currencyFromProperty?;
+    private _radioOptions;
+    private _datePickerFormat?;
+    private _datePickerMin?;
+    private _datePickerMax?;
+    private _datePickerShowTime?;
+    private _datePickerShowSeconds?;
+    private _maxLength?;
+    private _minLength?;
+    private _pattern?;
+    private _inputTrim?;
+    private _mask?;
+    private _slotChar?;
+    private _fileMultiple?;
+    private _fileMaxFileSize?;
+    private _fileAccept?;
+    private _fileOnSelectHandler?;
+    private _imagePreview?;
+    private _imageUrlInputHiddenOnDisabled?;
+    private _customComponentType?;
+    private _customComponentInputs?;
+    private _customComponentWrappers?;
+    constructor(editor: IEditorDescriptorInternal<EditorModel>, property: string);
+    /**
+     * converts field to given type with additional arguments
+     * @param fieldType field type enum
+     * @param args any additional arguments for field (optional)
+     */
+    asType(fieldType: FieldInputTypeEnum, ...args: any[]): this;
+    get fieldType(): FieldInputTypeEnum;
+    get rows(): number | undefined;
+    get numberMin(): number | undefined;
+    get numberMax(): number | undefined;
+    get numberStep(): number | undefined;
+    get numberAutoCorrect(): boolean | undefined;
+    get numberMinFractionDigits(): number | undefined;
+    get numberMaxFractionDigits(): number | undefined;
+    get numberUseGrouping(): boolean;
+    get radioOptions(): RadioValue<string | number | boolean>[];
+    get datePickerFormat(): string | undefined;
+    get datePickerMin(): Date | undefined;
+    get datePickerMax(): Date | undefined;
+    get datePickerShowTime(): boolean | undefined;
+    get datePickerShowSeconds(): boolean | undefined;
+    get maxLength(): number | undefined;
+    get minLength(): number | undefined;
+    get pattern(): string | RegExp | undefined;
+    get trimOption(): InputTrimType | undefined;
+    get mask(): string | undefined;
+    get slotChar(): string | undefined;
+    get fileMultiple(): boolean | undefined;
+    get fileMaxFileSize(): number | undefined;
+    get fileAccept(): string | undefined;
+    get fileOnSelectHandler(): FieldInputFileOnSelectHandlerFnType | undefined;
+    get imagePreview(): boolean | undefined;
+    get imageUrlInputVisibleOnDisabled(): boolean | undefined;
+    get customComponentType(): Type<AFormlyCustomFieldComponent> | undefined;
+    get customComponentInputs(): Record<string, any> | undefined;
+    get customComponentWrappers(): string[] | undefined;
+    get locale(): string | undefined;
+    get currency(): string | undefined;
+    get currencyFromProperty(): string | undefined;
+    get currencyDisplay(): "symbol" | "name" | "code";
+    asHidden(): this;
+    asLabel(): this;
+    asText(opts?: FieldInputTextOptsType): this;
+    asTextarea(opts?: FieldInputTextareaOptsType): this;
+    asNumber(opts?: FieldInputNumberOptsType): this;
+    asCurrency(opts?: FieldInputCurrencyOptsType<keyof EditorModel>): this;
+    asCurrencyUnsafe(opts?: FieldInputCurrencyOptsType): this;
+    asSwitch(): this;
+    asRadio(options: Array<string | number | boolean>, optionsTitlePath?: string): this;
+    asRadioFromEnum<Enum>(enumModel: EnumDescriptor<Enum>, values?: Array<Enum>): this;
+    asDatePicker(opts?: FieldInputDatePickerOptsType): this;
+    asMask(mask: string, slotChar: string): this;
+    asFile(opts?: FieldInputFileOpts): this;
+    asImageFile(opts?: FieldInputFileOpts): this;
+    asImageUrl(opts?: FieldInputImageUrlOpts): this;
+    asCustomComponent(component: Type<AFormlyCustomFieldComponent>, opts?: FieldInputComponentOpts): this;
+    withNumberValidation(opts?: FieldInputNumberValidationOptsType): this;
+    withLocale(locale?: string): this;
+    withNumberFractions(opts?: FieldInputNumberFractionOptsType): this;
+    withNumberGrouping(useGrouping?: boolean): this;
+    withTextValidation(opts?: FieldInputTextValidationOptsType): this;
+    withInputTrim(trimOption?: InputTrimType): this;
+    withTextValidationEmail(email?: boolean): this;
+    withFileOnSelectHandler(fn?: FieldInputFileOnSelectHandlerFnType): this;
+    copy(): FieldInputDescriptor<EditorModel, FieldModel, FieldValue>;
+}

package/tableview/api/editor/helpers/class-attribute-converter.d.ts

@@ -0,0 +1,21 @@
+import { ClassAttributeDef, ClassType } from '@mediusinc/mng-commons/core';
+import { ColumnDisplayTypeEnum, ColumnTypeEnum } from '@mediusinc/mng-commons/table/api';
+import { EditorClassAttributeDef } from '../models/class-tableview-attribute.model';
+import { FieldInputTypeEnum } from '../models/field.model';
+/**
+ * converts string type to type enum, default is text
+ * @param attributeType
+ */
+export declare function getFieldInputTypeFromClassAttributeDefType(attributeType: string): FieldInputTypeEnum;
+/**
+ * convert column type to equivalent field input type
+ * @param type column type
+ * @param displayType column display type
+ */
+export declare function getFieldInputTypeFromColumnType(type: ColumnTypeEnum, displayType?: ColumnDisplayTypeEnum): FieldInputTypeEnum;
+export declare function expandClassAttributeDefWithEditorDef(attributes?: Array<ClassAttributeDef> | null): EditorClassAttributeDef[];
+/**
+ * returns attributes from class type and extends to typed def with column and field enum type
+ * @param type class type
+ */
+export declare function getEditorClassAttributeDef<T>(type: ClassType<T>): EditorClassAttributeDef[];

package/tableview/api/editor/helpers/field-validators.d.ts

@@ -0,0 +1,3 @@
+import { FieldValidator } from '../models/field.model';
+export declare const minDateValidator: (min: Date) => FieldValidator;
+export declare const maxDateValidator: (max: Date) => FieldValidator;

package/tableview/api/editor/models/class-tableview-attribute.model.d.ts

@@ -0,0 +1,7 @@
+import { ClassAttributeDef, ClassType, EnumType } from '@mediusinc/mng-commons/core';
+import { FieldInputTypeEnum } from '../../editor/models/field.model';
+export interface EditorClassAttributeDef extends ClassAttributeDef {
+    classType?: ClassType<any>;
+    fieldType?: FieldInputTypeEnum;
+    enumType?: EnumType;
+}

package/tableview/api/editor/models/editor-fields.model.d.ts

@@ -0,0 +1,34 @@
+import { ArrayItemType, EnumConstantType, ITableviewDescriptorInternal, IdType, Nullable } from '@mediusinc/mng-commons/core';
+import { EnumDescriptor, TypeDescriptor } from '@mediusinc/mng-commons/model';
+import { ITableDataProvider, ITableDescriptorInternal } from '@mediusinc/mng-commons/table/api';
+import { AFieldDescriptor } from '../descriptors/field-base.descriptor';
+import { FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldLookupProviderType } from '../descriptors/field-lookup.descriptor';
+import { FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor } from '../descriptors/field-many.descriptor';
+import { FieldInputDescriptor, FieldInputDescriptorType } from '../descriptors/field.descriptor';
+import { TableviewEditorTypeEnum } from './editor.model';
+export interface IFieldsManageInterface<EditorModel> {
+    getField(property: keyof EditorModel, editorType: TableviewEditorTypeEnum): AFieldDescriptor<any, EditorModel> | null;
+    getFieldUnsafe(property: string, editorType: TableviewEditorTypeEnum): AFieldDescriptor<any, EditorModel> | null;
+    removeField(property: keyof EditorModel): void;
+    removeFieldUnsafe(property: string): void;
+    addFieldDescriptor<FieldModel>(field: AFieldDescriptor<FieldModel, EditorModel>): this;
+    addField<Property extends keyof EditorModel, FieldModel = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property): FieldInputDescriptor<EditorModel, FieldModel, FieldValue>;
+    addFieldUnsafe<FieldModel = FieldInputDescriptorType, FieldValue = FieldModel>(property: string): FieldInputDescriptor<EditorModel, FieldModel, FieldValue>;
+    addFields(...properties: (keyof EditorModel)[]): this;
+    addFieldLookup<Property extends keyof EditorModel, FieldModel = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, type?: TypeDescriptor<FieldModel>): FieldLookupDescriptor<FieldModel, EditorModel, undefined, FieldValue>;
+    addFieldLookupUnsafe<FieldModel, FieldValue = FieldModel>(property: string, type?: TypeDescriptor<FieldModel>): FieldLookupDescriptor<FieldModel, EditorModel, undefined, FieldValue>;
+    addFieldLookupWithOptionsValueProperty<Property extends keyof EditorModel, FieldModel, FieldValue = EditorModel[Property]>(property: Property, type: TypeDescriptor<FieldModel>, lookupOptionsValueProperty: any): FieldLookupDescriptor<FieldModel, EditorModel, undefined, FieldValue>;
+    addFieldLookupWithOptionsValuePropertyUnsafe<FieldModel, FieldValue = Nullable<IdType>>(property: string, type: TypeDescriptor<FieldModel>, lookupOptionsValueProperty: string): FieldLookupDescriptor<FieldModel, EditorModel, undefined, FieldValue>;
+    addFieldLookupWithProvider<Property extends keyof EditorModel, Service, FieldModel = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, provider: FieldLookupProviderType<FieldModel, Service>, type?: TypeDescriptor<FieldModel>): FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue>;
+    addFieldLookupWithProviderUnsafe<FieldModel, Service, FieldValue = FieldModel>(property: string, provider: FieldLookupProviderType<FieldModel, Service>, type?: TypeDescriptor<FieldModel>): FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue>;
+    addFieldLookupWithProviderAndOptionsValueProperty<Property extends keyof EditorModel, Service, FieldModel, FieldValue = EditorModel[Property]>(property: Property, provider: FieldLookupProviderType<FieldModel, Service>, type: TypeDescriptor<FieldModel>, lookupOptionsValueProperty: any): FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue>;
+    addFieldLookupWithProviderAndOptionsValuePropertyUnsafe<Service, FieldModel, FieldValue = FieldModel>(property: string, provider: FieldLookupProviderType<FieldModel, Service>, type: TypeDescriptor<FieldModel>, lookupOptionsValueProperty: string): FieldLookupDescriptor<FieldModel, EditorModel, Service, 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>;
+    addFieldManyToManyEditorWithProviderUnsafe<FieldModel, Service, FieldValue = FieldModel[]>(property: string, mainTableDescriptor: ITableDescriptorInternal<FieldModel>, lookupTableDescriptor: ITableDescriptorInternal<FieldModel>, lookupDataProvider: ITableDataProvider<FieldModel, Service>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, Service, FieldValue>;
+}

package/tableview/api/editor/models/editor.model.d.ts

@@ -0,0 +1,7 @@
+export declare enum TableviewEditorTypeEnum {
+    None = 0,
+    Details = 1,
+    Edit = 2,
+    Add = 3
+}
+export declare const EDITOR_DEFAULT_GROUP_NAME = "_default";

package/tableview/api/editor/models/field-action-context.model.d.ts

@@ -0,0 +1,24 @@
+import { AbstractControl, FormArray, FormGroup } from '@angular/forms';
+import { FormlyFormOptions } from '@ngx-formly/core';
+import { FieldActionDescriptor } from '../descriptors/field-action.descriptor';
+import { IFormEditorComponent } from './form-editor.interface';
+import { CommonsFormlyFieldProps } from './formly-field.model';
+export interface FieldActionContext<ET> {
+    descriptor: FieldActionDescriptor<ET>;
+    formEditorComponent: IFormEditorComponent<ET>;
+    formly: {
+        model: ET;
+        formControl: AbstractControl;
+        form: FormGroup | FormArray;
+        options: FormlyFormOptions;
+        props: CommonsFormlyFieldProps;
+        formState: any;
+    };
+}
+export interface FieldActionResult {
+    message?: FieldActionResultMessage;
+}
+export interface FieldActionResultMessage {
+    content: string;
+    severity?: 'success' | 'warn' | 'error';
+}

package/tableview/api/editor/models/field.model.d.ts

@@ -0,0 +1,66 @@
+import { Type } from '@angular/core';
+import { AbstractControl, ValidationErrors } from '@angular/forms';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { Observable } from 'rxjs';
+export declare enum FieldSizeEnum {
+    Small = 0,
+    Normal = 1,
+    Large = 2
+}
+export declare enum FieldInputTypeEnum {
+    Hidden = 0,
+    Label = 1,
+    Text = 2,
+    Textarea = 3,
+    Number = 4,
+    Currency = 5,
+    Switch = 6,
+    Radio = 7,
+    Datepicker = 8,
+    Mask = 9,
+    File = 10,
+    ImageFile = 11,
+    ImageUrl = 12,
+    Custom = 13
+}
+export declare enum FieldLookupTypeEnum {
+    Dropdown = 0,
+    Autocomplete = 1,
+    Dialog = 2,
+    Custom = 3
+}
+export declare enum FieldManyToManyEditorTypeEnum {
+    DialogTableMultiselect = 0
+}
+export declare enum FieldManyToManyEditorActionEnum {
+    Add = 0,
+    Delete = 1
+}
+export declare enum FieldManyEditorTypeEnum {
+    DialogEditor = 0
+}
+export declare enum FieldManyEditorActionEnum {
+    View = 0,
+    Add = 1,
+    Edit = 2,
+    Delete = 3
+}
+export declare enum FieldGroupTypeEnum {
+    Fieldset = 0,
+    Logical = 1
+}
+export type FieldValidator = (control: AbstractControl, field: FormlyFieldConfig, options?: {
+    [id: string]: any;
+}) => ValidationErrors | boolean | null;
+export type FieldAsyncValidator = (control: AbstractControl, field: FormlyFieldConfig, options?: {
+    [id: string]: any;
+}) => Observable<ValidationErrors | boolean | null>;
+export type FieldValidationMessage = string | ((error: any, field: FormlyFieldConfig) => string | Observable<string>);
+export interface FieldConfig {
+}
+export interface FieldLookupConfig extends FieldConfig {
+    table?: {
+        captionComponent?: Type<any>;
+        columnActionComponent?: Type<any>;
+    };
+}

package/tableview/api/editor/models/form-editor.event.d.ts

@@ -0,0 +1,55 @@
+import { Type } from '@angular/core';
+export interface FormEditorSubmitEvent<Item> {
+    formItem: Item;
+    success: boolean;
+}
+export declare enum FormFieldEventTypeEnum {
+    ComponentLifecycle = "ComponentLifecycle",
+    ValueChange = "ValueChange",
+    DataProvider = "DataProvider",
+    DialogLifecycle = "DialogLifecycle",
+    Other = "Other"
+}
+export declare enum FormEventTypeEnum {
+    ComponentLifecycle = "ComponentLifecycle",
+    ValueChange = "ValueChange",
+    Submit = "Submit",
+    Other = "Other"
+}
+export declare class FormFieldEventComponentSubtype {
+    static readonly ON_INIT = "Component.OnInit";
+    static readonly ON_VIEW_INIT = "Component.OnViewInit";
+    static readonly ON_CONTENT_INIT = "Component.OnContentInit";
+    static readonly ON_DESTROY = "Component.OnDestroy";
+}
+export declare class FormFieldEventDialogSubtype {
+    static readonly VISIBILITY = "Dialog.Visibility";
+    static readonly TABLE_CAPTION_COMPONENT_INSTANCE = "Dialog.MngTable.CaptionComponentInstance";
+    static readonly TABLE_COLUMN_ACTIONS_COMPONENT_INSTANCE = "Dialog.MngTable.ColumnActionsComponentInstance";
+}
+export interface FormFieldEventData<T, ET> {
+    eventSubtype?: string;
+    value?: T;
+    formValue?: ET;
+    [key: string]: any;
+}
+export interface FieldEventData<ET> {
+    eventSubtype?: string;
+    value?: any;
+    formValue?: () => ET;
+    submitValid?: boolean;
+    submitValue?: ET;
+    [key: string]: any;
+}
+export interface FormFieldEvent<T, ET> {
+    type: FormFieldEventTypeEnum;
+    componentType: Type<any>;
+    componentInstance: any;
+    data?: FormFieldEventData<T, ET>;
+}
+export interface FormEvent<ET> {
+    type: FormEventTypeEnum;
+    componentType: Type<any>;
+    componentInstance: any;
+    data?: FieldEventData<ET>;
+}

package/tableview/api/editor/models/formly-custom-field.model.d.ts

@@ -0,0 +1,27 @@
+import { AbstractControl, FormArray, FormGroup } from '@angular/forms';
+import { FieldType, FormlyFormOptions } from '@ngx-formly/core';
+import { CommonsFormlyFieldConfig } from './formly-field.model';
+import * as i0 from "@angular/core";
+export declare abstract class AFormlyCustomFieldComponent extends FieldType<CommonsFormlyFieldConfig> {
+    field: CommonsFormlyFieldConfig;
+    _model: any;
+    _form: FormGroup | FormArray;
+    _options: FormlyFormOptions;
+    _key: string | number | (string | number)[];
+    _formControl: AbstractControl;
+    _props: CommonsFormlyFieldConfig['props'];
+    _showError: boolean;
+    _id: string;
+    _formState: any;
+    get model(): any;
+    get form(): FormGroup<any> | FormArray<any>;
+    get options(): FormlyFormOptions;
+    get key(): string | number | (string | number)[];
+    get formControl(): AbstractControl<any, any>;
+    get props(): import("./formly-field.model").CommonsFormlyFieldProps;
+    get showError(): boolean;
+    get id(): string;
+    get formState(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AFormlyCustomFieldComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AFormlyCustomFieldComponent, never, never, { "field": { "alias": "field"; "required": false; }; "_model": { "alias": "model"; "required": false; }; "_form": { "alias": "form"; "required": false; }; "_options": { "alias": "options"; "required": false; }; "_key": { "alias": "key"; "required": false; }; "_formControl": { "alias": "formControl"; "required": false; }; "_props": { "alias": "props"; "required": false; }; "_showError": { "alias": "showError"; "required": false; }; "_id": { "alias": "id"; "required": false; }; "_formState": { "alias": "formState"; "required": false; }; }, {}, never, never, false, never>;
+}

package/tableview/api/editor/models/formly-field.model.d.ts

@@ -0,0 +1,18 @@
+import { FieldType, FormlyFieldConfig, FormlyFieldProps } from '@ngx-formly/core';
+import { AFieldDescriptor } from '../descriptors/field-base.descriptor';
+import { AFieldGroupDescriptor } from '../descriptors/field-group.descriptor';
+import { IFormEditorComponent } from './form-editor.interface';
+export type CommonsFormlyFieldProps = FormlyFieldProps & CommonsFormlyFieldAdditionalProps<unknown, unknown>;
+export interface CommonsFormlyFieldConfig<Props = CommonsFormlyFieldProps> extends FormlyFieldConfig<Props> {
+    props: Props;
+}
+export type CommonsFormlyHookFn = (field: CommonsFormlyFieldConfig) => void;
+export interface CommonsFormlyFieldAdditionalProps<T, ET> {
+    descriptor?: AFieldDescriptor<T, ET> | AFieldGroupDescriptor<ET>;
+    formEditorComponent?: IFormEditorComponent<ET>;
+    fieldComponent?: FieldType<CommonsFormlyFieldConfig>;
+    required?: boolean;
+    hide?: boolean;
+    disabled?: boolean;
+    [additionalProperties: string]: any;
+}