@mediusinc/mng-commons 0.0.1-rc.4 → 0.2.4

package/esm2020/lib/descriptors/editor.descriptor.mjs

@@ -0,0 +1,670 @@
+import { of } from 'rxjs';
+import { LookupDataProvider, TableviewDataProvider } from '../data-providers';
+import { ModelDescriptor, FieldValidator } from './';
+import { ObjectSerializer } from '../api/utils';
+import { ModelUtil } from '../utils';
+export class EditorDescriptor {
+    constructor(modelType, idProperty, titleProperty) {
+        this._tabs = [];
+        this._groups = [];
+        this._fields = [];
+        this._disabled = false;
+        this._model = new ModelDescriptor(modelType, idProperty, titleProperty);
+    }
+    get model() {
+        return this._model;
+    }
+    get tabs() {
+        return this._tabs;
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    get fields() {
+        return this._fields;
+    }
+    createTabGroup(name, title) {
+        const tabGroup = new FieldTabGroupDescriptor(this, name);
+        if (title) {
+            tabGroup.withTitle(title);
+        }
+        this.createTabGroupDescriptor(tabGroup);
+        return tabGroup;
+    }
+    createFieldGroup(name, title) {
+        const fieldGroup = new FieldGroupDescriptor(this, name);
+        if (title) {
+            fieldGroup.withTitle(title);
+        }
+        this.createFieldGroupDescriptor(fieldGroup);
+        return fieldGroup;
+    }
+    addFieldDescriptor(field) {
+        this.createDefaultGroup();
+        this._fields.push(field);
+        this._currentGroup?.addField(field);
+        return this;
+    }
+    addField(property) {
+        const field = new FieldInputDescriptor(this, property);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    removeField(property) {
+        const fieldIdx = this._fields.findIndex(f => f.property === property);
+        if (fieldIdx < 0) {
+            throw new Error(`Field ${property} does not exist.`);
+        }
+        const field = this._fields[fieldIdx];
+        if (field.group) {
+            const groupFieldIdx = field.group.fields.findIndex(f => f instanceof AFieldDescriptor && f.property === property);
+            if (groupFieldIdx >= 0) {
+                field.group.fields.splice(groupFieldIdx, 1);
+            }
+        }
+        this._fields.splice(fieldIdx, 1);
+        return this;
+    }
+    getField(property) {
+        return this._fields.find(f => f.property === property) ?? null;
+    }
+    addFieldLookup(property, modelType) {
+        const field = new FieldLookupDescriptor(this, property, modelType);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    addFieldLookupEnum(property, options) {
+        const propDef = ObjectSerializer.get().findAttributeDefinitionByClassType(this.model.type, property);
+        if (!propDef) {
+            throw new Error(`Property (attribute) definition not found for property ${property} on class type ${this._model.typeName}`);
+        }
+        const enumDef = ObjectSerializer.get().findEnum(propDef.type);
+        if (!enumDef) {
+            throw new Error(`Enum definition ${propDef.type} not found for property ${property} on class type ${this._model.typeName}`);
+        }
+        const field = new FieldLookupEnumDescriptor(this, property, propDef.type, options);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    addFieldManyEditor(property, type, tableviewDescriptor) {
+        const field = new FieldManyEditorDescriptor(this, property, type, tableviewDescriptor);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    addFieldManyToManyEditor(property, type, mainTableDescriptor, lookupTableDescriptor) {
+        const field = new FieldManyToManyEditorDescriptor(this, property, type, mainTableDescriptor, lookupTableDescriptor);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    withDisabled(disabled = true) {
+        this._disabled = disabled;
+        return this;
+    }
+    addValidator(name, expression) {
+        if (this._currentGroup) {
+            this._currentGroup.withValidator(name, expression);
+        }
+    }
+    copy() {
+        const editor = new EditorDescriptor(this.model.type, this.model.idPropertyName, this.model.titlePropertyName);
+        for (const tabGroup of this._tabs) {
+            editor.createTabGroupDescriptor(tabGroup.copy());
+        }
+        for (const tabGroup of editor._tabs) {
+            for (const fieldGroup of tabGroup.fields) {
+                editor._fields.push(...fieldGroup.fields);
+            }
+            editor._groups.push(...tabGroup.fields);
+        }
+        editor._currentTabGroup = editor._tabs[editor._tabs.length - 1];
+        editor._currentGroup = editor._currentTabGroup.fields[editor._currentTabGroup.fields.length - 1];
+        editor._disabled = this._disabled;
+        return editor;
+    }
+    createTabGroupDescriptor(tabGroup) {
+        this._currentTabGroup = tabGroup;
+        this._tabs.push(tabGroup);
+        return this;
+    }
+    createFieldGroupDescriptor(fieldGroup) {
+        this.createDefaultTabGroup();
+        this._currentGroup = fieldGroup;
+        this._groups.push(fieldGroup);
+        this._currentTabGroup?.addField(fieldGroup);
+        return this;
+    }
+    createDefaultGroup() {
+        this.createDefaultTabGroup();
+        if (this._currentTabGroup?.fields.length === 0) {
+            this.createFieldGroup(EditorDescriptor.defaultGroupName);
+        }
+    }
+    createDefaultTabGroup() {
+        if (this._tabs.length === 0) {
+            this.createTabGroup(EditorDescriptor.defaultGroupName);
+        }
+    }
+}
+EditorDescriptor.defaultGroupName = '_default';
+export class AGenericFieldDescriptor {
+    constructor(editor) {
+        this._editor = editor;
+    }
+    get editor() {
+        return this._editor;
+    }
+}
+export class AFieldDescriptor extends AGenericFieldDescriptor {
+    constructor(editor, property) {
+        super(editor);
+        this._required = false;
+        this._disabled = false;
+        this._className = '';
+        this._validators = [];
+        this._property = property;
+        this._label = this._editor.model.typeName + '.properties.' + property;
+    }
+    get property() {
+        return this._property;
+    }
+    get group() {
+        return this._group;
+    }
+    get label() {
+        return this._label;
+    }
+    get placeholder() {
+        return this._placeholder;
+    }
+    get required() {
+        return this._required;
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    get className() {
+        return this._className;
+    }
+    get getter() {
+        return this._getter;
+    }
+    get setter() {
+        return this._setter;
+    }
+    get validators() {
+        return this._validators;
+    }
+    withLabel(label) {
+        this._label = label;
+        return this;
+    }
+    withPlaceholder(placeholder) {
+        this._placeholder = placeholder;
+        return this;
+    }
+    withRequired(required = true) {
+        this._required = required;
+        return this;
+    }
+    withDisabled(disabled = true) {
+        this._disabled = disabled;
+        return this;
+    }
+    withClassName(className) {
+        this._className = className;
+        return this;
+    }
+    withGetter(getter) {
+        this._getter = getter;
+        return this;
+    }
+    withSetter(setter) {
+        this._setter = setter;
+        return this;
+    }
+    withValidator(name, expression, message) {
+        this._validators.push(new FieldValidator(name, expression, message));
+        return this;
+    }
+    copyFieldsTo(obj) {
+        obj._label = this._label;
+        obj._placeholder = this._placeholder;
+        obj._required = this._required;
+        obj._disabled = this._disabled;
+        obj._className = this._className;
+        obj._getter = this._getter;
+        obj._setter = this._setter;
+        obj._validators = this._validators;
+    }
+}
+export class FieldInputDescriptor extends AFieldDescriptor {
+    constructor(editor, property) {
+        super(editor, property);
+        this._fieldType = FieldInputDescriptor.TypeEnum.Text;
+        // radio specific properties
+        this._radioOptions = [];
+        this._datePickerShowTime = false;
+    }
+    get fieldType() {
+        return this._fieldType;
+    }
+    get numberStep() {
+        return this._numberStep;
+    }
+    get numberMin() {
+        return this._numberMin;
+    }
+    get numberMax() {
+        return this._numberMax;
+    }
+    get rows() {
+        return this._rows;
+    }
+    get numberMinFractionDigits() {
+        return this._numberMinFractionDigits;
+    }
+    get numberMaxFractionDigits() {
+        return this._numberMaxFractionDigits;
+    }
+    get radioOptions() {
+        return this._radioOptions;
+    }
+    get datePickerFormat() {
+        return this._datePickerFormat;
+    }
+    get datePickerMin() {
+        return this._datePickerMin;
+    }
+    get datePickerMax() {
+        return this._datePickerMax;
+    }
+    get datePickerShowTime() {
+        return this._datePickerShowTime;
+    }
+    get maxLength() {
+        return this._maxLength;
+    }
+    get minLength() {
+        return this._minLength;
+    }
+    get pattern() {
+        return this._pattern;
+    }
+    asText(minLength, maxLength, pattern) {
+        this._fieldType = FieldInputDescriptor.TypeEnum.Text;
+        this._minLength = minLength;
+        this._maxLength = maxLength;
+        this._pattern = pattern;
+        return this;
+    }
+    asTextarea(rows = 3) {
+        this._fieldType = FieldInputDescriptor.TypeEnum.Textarea;
+        this._rows = rows;
+        return this;
+    }
+    asNumber(step, min, max, minFractionDigits, maxFractionDigits) {
+        this._fieldType = FieldInputDescriptor.TypeEnum.Number;
+        this._numberStep = step;
+        this._numberMinFractionDigits = minFractionDigits;
+        this._numberMaxFractionDigits = maxFractionDigits;
+        this._numberMin = min ?? Number.MIN_SAFE_INTEGER;
+        this._numberMax = max ?? Number.MAX_SAFE_INTEGER;
+        return this;
+    }
+    asSwitch() {
+        this._fieldType = FieldInputDescriptor.TypeEnum.Switch;
+        return this;
+    }
+    asRadio(options) {
+        this._fieldType = FieldInputDescriptor.TypeEnum.Radio;
+        this._radioOptions = options;
+        return this;
+    }
+    asDatePicker(format, min, max, showTime) {
+        this._fieldType = FieldInputDescriptor.TypeEnum.Datepicker;
+        this._datePickerFormat = format ? format : 'dd.mm.yy';
+        this._datePickerMin = min;
+        this._datePickerMax = max;
+        this._datePickerShowTime = showTime ?? false;
+        return this;
+    }
+    copy() {
+        const field = new FieldInputDescriptor(this._editor, this._property);
+        this.copyFieldsTo(field);
+        field._fieldType = this._fieldType;
+        field._rows = this._rows;
+        field._numberMin = this._numberMin;
+        field._numberMax = this._numberMax;
+        field._numberStep = this._numberStep;
+        field._numberMinFractionDigits = this._numberMinFractionDigits;
+        field._numberMaxFractionDigits = this._numberMaxFractionDigits;
+        field._radioOptions = this._radioOptions;
+        field._datePickerFormat = this._datePickerFormat;
+        field._datePickerMin = this._datePickerMin;
+        field._datePickerMax = this._datePickerMax;
+        field._datePickerShowTime = this._datePickerShowTime;
+        field._maxLength = this._maxLength;
+        field._minLength = this._minLength;
+        field._pattern = this._pattern;
+        return field;
+    }
+}
+(function (FieldInputDescriptor) {
+    let TypeEnum;
+    (function (TypeEnum) {
+        TypeEnum[TypeEnum["Text"] = 0] = "Text";
+        TypeEnum[TypeEnum["Textarea"] = 1] = "Textarea";
+        TypeEnum[TypeEnum["Number"] = 2] = "Number";
+        TypeEnum[TypeEnum["Switch"] = 3] = "Switch";
+        TypeEnum[TypeEnum["Radio"] = 4] = "Radio";
+        TypeEnum[TypeEnum["Datepicker"] = 5] = "Datepicker";
+    })(TypeEnum = FieldInputDescriptor.TypeEnum || (FieldInputDescriptor.TypeEnum = {}));
+})(FieldInputDescriptor || (FieldInputDescriptor = {}));
+export class FieldLookupDescriptor extends AFieldDescriptor {
+    constructor(editor, property, modelType) {
+        super(editor, property);
+        this._lookupType = FieldLookupDescriptor.LookupTypeEnum.Dropdown;
+        this._modelType = modelType;
+        ModelUtil.trySetLookupItemsProperties(this);
+    }
+    get modelType() {
+        return this._modelType;
+    }
+    get lookupType() {
+        return this._lookupType;
+    }
+    get itemsLabelProperty() {
+        return this._itemsLabelProperty;
+    }
+    get itemsValueProperty() {
+        return this._itemsValueProperty;
+    }
+    get dataKeyProperty() {
+        return this._dataKeyProperty;
+    }
+    get dataProvider() {
+        return this._dataProvider;
+    }
+    withItemsLabelProperty(itemsLabelProperty) {
+        this._itemsLabelProperty = itemsLabelProperty;
+        return this;
+    }
+    withItemsValueProperty(itemsValueProperty) {
+        this._itemsValueProperty = itemsValueProperty;
+        return this;
+    }
+    withDataKeyProperty(property) {
+        this._dataKeyProperty = property;
+        return this;
+    }
+    withLookup(lookup, serviceType) {
+        const dataProvider = new LookupDataProvider(this._modelType);
+        if (serviceType) {
+            dataProvider.withServiceType(serviceType);
+        }
+        dataProvider.withLookup(lookup);
+        this._dataProvider = dataProvider;
+        return this;
+    }
+    withLookupDataProvider(dataProvider) {
+        this._dataProvider = dataProvider;
+        return this;
+    }
+    asAutocomplete() {
+        this._lookupType = FieldLookupDescriptor.LookupTypeEnum.Autocomplete;
+        return this;
+    }
+    copy() {
+        const field = new FieldLookupDescriptor(this._editor, this._property, this._modelType);
+        this.copyFieldsTo(field);
+        field._lookupType = this._lookupType;
+        field._itemsLabelProperty = this._itemsLabelProperty;
+        field._itemsValueProperty = this._itemsValueProperty;
+        field._dataKeyProperty = this._dataKeyProperty;
+        field._dataProvider = this._dataProvider;
+        return field;
+    }
+}
+(function (FieldLookupDescriptor) {
+    let LookupTypeEnum;
+    (function (LookupTypeEnum) {
+        LookupTypeEnum[LookupTypeEnum["Dropdown"] = 0] = "Dropdown";
+        LookupTypeEnum[LookupTypeEnum["Autocomplete"] = 1] = "Autocomplete";
+    })(LookupTypeEnum = FieldLookupDescriptor.LookupTypeEnum || (FieldLookupDescriptor.LookupTypeEnum = {}));
+})(FieldLookupDescriptor || (FieldLookupDescriptor = {}));
+export class FieldLookupEnumDescriptor extends FieldLookupDescriptor {
+    constructor(editor, property, enumName, options) {
+        super(editor, property, null);
+        this._enumName = enumName;
+        const dataProvider = new LookupDataProvider(null)
+            .withEnumName(enumName)
+            .withLookup(() => of(options));
+        this.withLookupDataProvider(dataProvider);
+    }
+    get enumName() {
+        return this._enumName;
+    }
+    copy() {
+        const field = new FieldLookupEnumDescriptor(this._editor, this._property, this._enumName, []);
+        this.copyFieldsTo(field);
+        field._lookupType = this._lookupType;
+        field._itemsLabelProperty = this._itemsLabelProperty;
+        field._itemsValueProperty = this._itemsValueProperty;
+        field._dataKeyProperty = this._dataKeyProperty;
+        field._dataProvider = this._dataProvider;
+        return field;
+    }
+}
+export class FieldManyToManyEditorDescriptor extends AFieldDescriptor {
+    constructor(editor, property, modelType, mainTableDescriptor, lookupTableDescriptor) {
+        super(editor, property);
+        this._fieldType = FieldManyToManyEditorDescriptor.TypeEnum.DialogTableMultiselect;
+        this._lookupTableDataProvider = null;
+        this._actions = [];
+        this._hasLookupExcludeValues = false;
+        this._excludeFilterProperty = '';
+        this._excludeValueProperty = '';
+        this._model = new ModelDescriptor(modelType);
+        this._mainTableDescriptor = mainTableDescriptor;
+        this._lookupTableDescriptor = lookupTableDescriptor;
+        this._actions.push(FieldManyToManyEditorDescriptor.ActionEnum.Add, FieldManyToManyEditorDescriptor.ActionEnum.Delete);
+    }
+    get mainTableDescriptor() {
+        return this._mainTableDescriptor;
+    }
+    get lookupTableDescriptor() {
+        return this._lookupTableDescriptor;
+    }
+    get lookupTableDataProvider() {
+        return this._lookupTableDataProvider;
+    }
+    get actions() {
+        return this._actions;
+    }
+    get fieldType() {
+        return this._fieldType;
+    }
+    get hasLookupExcludeValues() {
+        return this._hasLookupExcludeValues;
+    }
+    get excludeFilterProperty() {
+        return this._excludeFilterProperty;
+    }
+    get excludeValueProperty() {
+        return this._excludeValueProperty;
+    }
+    withLookup(getAll, serviceType) {
+        const dataProvider = new TableviewDataProvider(this._model.type);
+        if (serviceType) {
+            dataProvider.withServiceType(serviceType);
+        }
+        dataProvider.withGetAll(getAll);
+        this._lookupTableDataProvider = dataProvider;
+        return this;
+    }
+    withLookupDataProvider(dataProvider) {
+        this._lookupTableDataProvider = dataProvider;
+        return this;
+    }
+    withActions(actions = []) {
+        this.actions.push(...actions);
+        return this;
+    }
+    withLookupExclude(filterProperty, valueProperty, hasLookupExclude = true) {
+        this._hasLookupExcludeValues = hasLookupExclude;
+        this._excludeFilterProperty = filterProperty;
+        this._excludeValueProperty = valueProperty;
+        return this;
+    }
+    copy() {
+        const field = new FieldManyToManyEditorDescriptor(this._editor, this._property, this._model.type, this._mainTableDescriptor.copy(), this._lookupTableDescriptor.copy());
+        this.copyFieldsTo(field);
+        field._fieldType = this._fieldType;
+        field._actions = this._actions.map(a => a);
+        field._lookupTableDataProvider = this._lookupTableDataProvider;
+        field._hasLookupExcludeValues = this._hasLookupExcludeValues;
+        field._excludeFilterProperty = this._excludeFilterProperty;
+        field._excludeValueProperty = this._excludeValueProperty;
+        return field;
+    }
+}
+(function (FieldManyToManyEditorDescriptor) {
+    let TypeEnum;
+    (function (TypeEnum) {
+        TypeEnum[TypeEnum["DialogTableMultiselect"] = 0] = "DialogTableMultiselect";
+    })(TypeEnum = FieldManyToManyEditorDescriptor.TypeEnum || (FieldManyToManyEditorDescriptor.TypeEnum = {}));
+    let ActionEnum;
+    (function (ActionEnum) {
+        ActionEnum[ActionEnum["Add"] = 0] = "Add";
+        ActionEnum[ActionEnum["Delete"] = 1] = "Delete";
+    })(ActionEnum = FieldManyToManyEditorDescriptor.ActionEnum || (FieldManyToManyEditorDescriptor.ActionEnum = {}));
+})(FieldManyToManyEditorDescriptor || (FieldManyToManyEditorDescriptor = {}));
+export class FieldManyEditorDescriptor extends AFieldDescriptor {
+    constructor(editor, property, modelType, tableviewDescriptor) {
+        super(editor, property);
+        this._fieldType = FieldManyEditorDescriptor.TypeEnum.DialogEditor;
+        this._actions = [];
+        this._modelType = modelType;
+        this._tableviewDescriptor = tableviewDescriptor;
+        this._actions.push(FieldManyEditorDescriptor.ActionEnum.Add, FieldManyEditorDescriptor.ActionEnum.Edit, FieldManyEditorDescriptor.ActionEnum.Delete);
+    }
+    get tableviewDescriptor() {
+        return this._tableviewDescriptor;
+    }
+    get tableDescriptor() {
+        return this._tableviewDescriptor.table;
+    }
+    get editorForCreate() {
+        return this._tableviewDescriptor.addEditor;
+    }
+    get editorForRead() {
+        return this._tableviewDescriptor.viewEditor;
+    }
+    get editorForUpdate() {
+        return this._tableviewDescriptor.editEditor;
+    }
+    get fieldType() {
+        return this._fieldType;
+    }
+    get actions() {
+        return this._actions;
+    }
+    withActions(actions = []) {
+        this.actions.push(...actions);
+        return this;
+    }
+    copy() {
+        const field = new FieldManyEditorDescriptor(this._editor, this._property, this._modelType, this._tableviewDescriptor.copy());
+        this.copyFieldsTo(field);
+        field._fieldType = this._fieldType;
+        field._actions = this._actions.map(a => a);
+        return field;
+    }
+}
+(function (FieldManyEditorDescriptor) {
+    let TypeEnum;
+    (function (TypeEnum) {
+        TypeEnum[TypeEnum["DialogEditor"] = 0] = "DialogEditor";
+    })(TypeEnum = FieldManyEditorDescriptor.TypeEnum || (FieldManyEditorDescriptor.TypeEnum = {}));
+    let ActionEnum;
+    (function (ActionEnum) {
+        ActionEnum[ActionEnum["Add"] = 0] = "Add";
+        ActionEnum[ActionEnum["Edit"] = 1] = "Edit";
+        ActionEnum[ActionEnum["Delete"] = 2] = "Delete";
+    })(ActionEnum = FieldManyEditorDescriptor.ActionEnum || (FieldManyEditorDescriptor.ActionEnum = {}));
+})(FieldManyEditorDescriptor || (FieldManyEditorDescriptor = {}));
+export class AFieldGroupDescriptor extends AGenericFieldDescriptor {
+    constructor(editor, name) {
+        super(editor);
+        this._fields = [];
+        this._validators = [];
+        this._name = `${this.baseName}${name}`;
+        this._default = name === EditorDescriptor.defaultGroupName;
+    }
+    get baseName() {
+        return `${this.groupName()}_`;
+    }
+    get name() {
+        return this._name;
+    }
+    get default() {
+        return this._default;
+    }
+    get title() {
+        return this._title;
+    }
+    get validators() {
+        return this._validators;
+    }
+    withTitle(title) {
+        this._title = title;
+        return this;
+    }
+    withValidator(name, expression) {
+        this._validators.push(new FieldValidator(name, expression, undefined));
+        return this;
+    }
+}
+export class FieldTabGroupDescriptor extends AFieldGroupDescriptor {
+    constructor(editor, name) {
+        super(editor, name);
+    }
+    get fields() {
+        return this._fields;
+    }
+    groupName() {
+        return 'tab';
+    }
+    addField(field) {
+        this._fields.push(field);
+        return this;
+    }
+    copy() {
+        const tab = new FieldTabGroupDescriptor(this._editor, this.name.substring(this.baseName.length));
+        tab._title = this._title;
+        tab._fields = this.fields.map(f => f.copy());
+        return tab;
+    }
+}
+export class FieldGroupDescriptor extends AFieldGroupDescriptor {
+    constructor(editor, name) {
+        super(editor, name);
+    }
+    get fields() {
+        return this._fields;
+    }
+    groupName() {
+        return 'group';
+    }
+    addField(field) {
+        this._fields.push(field);
+        return this;
+    }
+    copy() {
+        const group = new FieldGroupDescriptor(this._editor, this.name.substring(this.baseName.length));
+        group._title = this._title;
+        group._fields = this.fields.map(f => f.copy());
+        return group;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor.descriptor.js","sourceRoot":"","sources":["../../../../src/lib/descriptors/editor.descriptor.ts"],"names":[],"mappings":"AAIA,OAAO,EAAa,EAAE,EAAC,MAAM,MAAM,CAAC;AAGpC,OAAO,EAA0C,kBAAkB,EAAE,qBAAqB,EAAC,MAAM,mBAAmB,CAAC;AACrH,OAAO,EAAC,eAAe,EAAwC,cAAc,EAAoB,MAAM,IAAI,CAAC;AAG5G,OAAO,EAAC,gBAAgB,EAAC,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAC,SAAS,EAAC,MAAM,UAAU,CAAC;AAEnC,MAAM,OAAO,gBAAgB;IAazB,YAAY,SAAuB,EAAE,UAAmB,EAAE,aAAsB;QAR/D,UAAK,GAAsC,EAAE,CAAC;QAC9C,YAAO,GAAmC,EAAE,CAAC;QAC7C,YAAO,GAAoC,EAAE,CAAC;QAIvD,cAAS,GAAY,KAAK,CAAC;QAG/B,IAAI,CAAC,MAAM,GAAG,IAAI,eAAe,CAAI,SAAS,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC;IAC/E,CAAC;IAED,IAAW,KAAK;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,IAAW,IAAI;QACX,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAED,IAAW,QAAQ;QACf,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED,IAAW,MAAM;QACb,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAEM,cAAc,CAAC,IAAY,EAAE,KAAc;QAC9C,MAAM,QAAQ,GAAG,IAAI,uBAAuB,CAAI,IAAI,EAAE,IAAI,CAAC,CAAC;QAC5D,IAAI,KAAK,EAAE;YACP,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;SAC7B;QACD,IAAI,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC;QACxC,OAAO,QAAQ,CAAC;IACpB,CAAC;IAEM,gBAAgB,CAAC,IAAY,EAAE,KAAc;QAChD,MAAM,UAAU,GAAG,IAAI,oBAAoB,CAAI,IAAI,EAAE,IAAI,CAAC,CAAC;QAC3D,IAAI,KAAK,EAAE;YACP,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;SAC/B;QACD,IAAI,CAAC,0BAA0B,CAAC,UAAU,CAAC,CAAC;QAC5C,OAAO,UAAU,CAAC;IACtB,CAAC;IAEM,kBAAkB,CAAK,KAA8B;QACxD,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;QACpC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,QAAQ,CAAC,QAAgB;QAC5B,MAAM,KAAK,GAAG,IAAI,oBAAoB,CAAI,IAAI,EAAE,QAAQ,CAAC,CAAC;QAC1D,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAC/B,OAAO,KAAK,CAAC;IACjB,CAAC;IAEM,WAAW,CAAC,QAAgB;QAC/B,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;QACtE,IAAI,QAAQ,GAAG,CAAC,EAAE;YACd,MAAM,IAAI,KAAK,CAAC,SAAS,QAAQ,kBAAkB,CAAC,CAAC;SACxD;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACrC,IAAI,KAAK,CAAC,KAAK,EAAE;YACb,MAAM,aAAa,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,YAAY,gBAAgB,IAAI,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;YAClH,IAAI,aAAa,IAAI,CAAC,EAAE;gBACpB,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;aAC/C;SACJ;QACD,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QACjC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,QAAQ,CAAC,QAAgB;QAC5B,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,IAAI,IAAI,CAAC;IACnE,CAAC;IAEM,cAAc,CAAK,QAAgB,EAAE,SAAwB;QAChE,MAAM,KAAK,GAAG,IAAI,qBAAqB,CAAQ,IAAI,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;QAC1E,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAC/B,OAAO,KAAK,CAAC;IACjB,CAAC;IAEM,kBAAkB,CAAC,QAAgB,EAAE,OAA8B;QACtE,MAAM,OAAO,GAAG,gBAAgB,CAAC,GAAG,EAAE,CAAC,kCAAkC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACrG,IAAI,CAAC,OAAO,EAAE;YACV,MAAM,IAAI,KAAK,CAAC,0DAA0D,QAAQ,kBAAkB,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;SAC/H;QACD,MAAM,OAAO,GAAG,gBAAgB,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC9D,IAAI,CAAC,OAAO,EAAE;YACV,MAAM,IAAI,KAAK,CAAC,mBAAmB,OAAO,CAAC,IAAI,2BAA2B,QAAQ,kBAAkB,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;SAC/H;QACD,MAAM,KAAK,GAAG,IAAI,yBAAyB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QACnF,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAC/B,OAAO,KAAK,CAAC;IACjB,CAAC;IAEM,kBAAkB,CAAK,QAAgB,EAAE,IAAmB,EAAE,mBAA4C;QAC7G,MAAM,KAAK,GAAG,IAAI,yBAAyB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,mBAAmB,CAAC,CAAC;QACvF,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAC/B,OAAO,KAAK,CAAC;IACjB,CAAC;IAEM,wBAAwB,CAAK,QAAgB,EAAE,IAAmB,EAAE,mBAAwC,EAAE,qBAA0C;QAC3J,MAAM,KAAK,GAAG,IAAI,+BAA+B,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,mBAAmB,EAAE,qBAAqB,CAAC,CAAC;QACpH,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAC/B,OAAO,KAAK,CAAC;IACjB,CAAC;IAEM,YAAY,CAAC,WAAoB,IAAI;QACxC,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,YAAY,CAAC,IAAY,EAAE,UAAiD;QAC/E,IAAI,IAAI,CAAC,aAAa,EAAE;YACpB,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;SACtD;IACL,CAAC;IAEM,IAAI;QACP,MAAM,MAAM,GAAG,IAAI,gBAAgB,CAAI,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACjH,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,KAAK,EAAE;YAC/B,MAAM,CAAC,wBAAwB,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;SACpD;QACD,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,KAAK,EAAE;YACjC,KAAK,MAAM,UAAU,IAAI,QAAQ,CAAC,MAAM,EAAE;gBACtC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;aAC7C;YACD,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;SAC3C;QACD,MAAM,CAAC,gBAAgB,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAChE,MAAM,CAAC,aAAa,GAAG,MAAM,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACjG,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAClC,OAAO,MAAM,CAAC;IAClB,CAAC;IAEO,wBAAwB,CAAC,QAAoC;QACjE,IAAI,CAAC,gBAAgB,GAAG,QAAQ,CAAC;QACjC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC1B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,0BAA0B,CAAC,UAAmC;QACjE,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC7B,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC;QAChC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC9B,IAAI,CAAC,gBAAgB,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;QAC5C,OAAO,IAAI,CAAC;IAChB,CAAC;IAEO,kBAAkB;QACtB,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC7B,IAAI,IAAI,CAAC,gBAAgB,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;YAC5C,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;SAC5D;IACL,CAAC;IAEO,qBAAqB;QACzB,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YACzB,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;SAC1D;IACL,CAAC;;AAvKsB,iCAAgB,GAAG,UAAU,CAAC;AA0KzD,MAAM,OAAgB,uBAAuB;IAGzC,YAAsB,MAA4B;QAC9C,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IAC1B,CAAC;IAED,IAAW,MAAM;QACb,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;CACJ;AAED,MAAM,OAAgB,gBAAwB,SAAQ,uBAA2B;IAa7E,YAAsB,MAA4B,EAAE,QAAgB;QAChE,KAAK,CAAC,MAAM,CAAC,CAAC;QARR,cAAS,GAAY,KAAK,CAAC;QAC3B,cAAS,GAAY,KAAK,CAAC;QAC3B,eAAU,GAAW,EAAE,CAAC;QAGxB,gBAAW,GAA0B,EAAE,CAAC;QAI9C,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,GAAG,cAAc,GAAG,QAAQ,CAAC;IAC1E,CAAC;IAID,IAAW,QAAQ;QACf,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED,IAAW,KAAK;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,IAAW,KAAK;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,IAAW,WAAW;QAClB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAED,IAAW,QAAQ;QACf,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED,IAAW,QAAQ;QACf,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,IAAW,MAAM;QACb,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,IAAW,MAAM;QACb,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,IAAW,UAAU;QACjB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAEM,SAAS,CAAC,KAAa;QAC1B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,eAAe,CAAC,WAAmB;QACtC,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;QAChC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,YAAY,CAAC,WAAoB,IAAI;QACxC,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,YAAY,CAAC,WAAoB,IAAI;QACxC,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,aAAa,CAAC,SAAiB;QAClC,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,UAAU,CAAC,MAAuB;QACrC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,UAAU,CAAC,MAAoC;QAClD,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,aAAa,CAAC,IAAY,EAAE,UAAiD,EAC/D,OAAuD;QACxE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;QACrE,OAAO,IAAI,CAAC;IAChB,CAAC;IAES,YAAY,CAAC,GAA4B;QAC/C,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACzB,GAAG,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;QACrC,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAC/B,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAC/B,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACjC,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC3B,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC3B,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;IACvC,CAAC;CACJ;AAED,MAAM,OAAO,oBAAyB,SAAQ,gBAAgD;IA4B1F,YAAY,MAA4B,EAAE,QAAgB;QACtD,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QA3BpB,eAAU,GAAkC,oBAAoB,CAAC,QAAQ,CAAC,IAAI,CAAC;QAYvF,4BAA4B;QACpB,kBAAa,GAAkB,EAAE,CAAC;QAMlC,wBAAmB,GAAY,KAAK,CAAC;IAS7C,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,IAAW,UAAU;QACjB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,IAAW,IAAI;QACX,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAED,IAAW,uBAAuB;QAC9B,OAAO,IAAI,CAAC,wBAAwB,CAAC;IACzC,CAAC;IAED,IAAW,uBAAuB;QAC9B,OAAO,IAAI,CAAC,wBAAwB,CAAC;IACzC,CAAC;IAED,IAAW,YAAY;QACnB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IAED,IAAW,gBAAgB;QACvB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAClC,CAAC;IAED,IAAW,aAAa;QACpB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC/B,CAAC;IAED,IAAW,aAAa;QACpB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC/B,CAAC;IAED,IAAW,kBAAkB;QACzB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IACpC,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,IAAW,OAAO;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAEM,MAAM,CAAC,SAAkB,EAAE,SAAkB,EAAE,OAAyB;QAC3E,IAAI,CAAC,UAAU,GAAG,oBAAoB,CAAC,QAAQ,CAAC,IAAI,CAAC;QACrD,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,UAAU,CAAC,OAAe,CAAC;QAC9B,IAAI,CAAC,UAAU,GAAG,oBAAoB,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACzD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,QAAQ,CAAC,IAAa,EAAE,GAAY,EAAE,GAAY,EAAE,iBAA0B,EAAE,iBAA0B;QAC7G,IAAI,CAAC,UAAU,GAAG,oBAAoB,CAAC,QAAQ,CAAC,MAAM,CAAC;QACvD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,wBAAwB,GAAG,iBAAiB,CAAC;QAClD,IAAI,CAAC,wBAAwB,GAAG,iBAAiB,CAAC;QAClD,IAAI,CAAC,UAAU,GAAG,GAAG,IAAI,MAAM,CAAC,gBAAgB,CAAC;QACjD,IAAI,CAAC,UAAU,GAAG,GAAG,IAAI,MAAM,CAAC,gBAAgB,CAAC;QACjD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,QAAQ;QACX,IAAI,CAAC,UAAU,GAAG,oBAAoB,CAAC,QAAQ,CAAC,MAAM,CAAC;QACvD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,OAAO,CAAC,OAAsB;QACjC,IAAI,CAAC,UAAU,GAAG,oBAAoB,CAAC,QAAQ,CAAC,KAAK,CAAC;QACtD,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC;QAC7B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,YAAY,CAAC,MAAe,EAAE,GAAU,EAAE,GAAU,EAAE,QAAkB;QAC3E,IAAI,CAAC,UAAU,GAAG,oBAAoB,CAAC,QAAQ,CAAC,UAAU,CAAC;QAC3D,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC;QACtD,IAAI,CAAC,cAAc,GAAG,GAAG,CAAC;QAC1B,IAAI,CAAC,cAAc,GAAG,GAAG,CAAC;QAC1B,IAAI,CAAC,mBAAmB,GAAG,QAAQ,IAAI,KAAK,CAAC;QAC7C,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,IAAI;QACP,MAAM,KAAK,GAAG,IAAI,oBAAoB,CAAK,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QACzE,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QACzB,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACnC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACnC,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACnC,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACrC,KAAK,CAAC,wBAAwB,GAAG,IAAI,CAAC,wBAAwB,CAAC;QAC/D,KAAK,CAAC,wBAAwB,GAAG,IAAI,CAAC,wBAAwB,CAAC;QAC/D,KAAK,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QACzC,KAAK,CAAC,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC;QACjD,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;QAC3C,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;QAC3C,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC;QACrD,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACnC,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACnC,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC/B,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ;AACD,WAAiB,oBAAoB;IACjC,IAAY,QAOX;IAPD,WAAY,QAAQ;QAChB,uCAAI,CAAA;QACJ,+CAAQ,CAAA;QACR,2CAAM,CAAA;QACN,2CAAM,CAAA;QACN,yCAAK,CAAA;QACL,mDAAU,CAAA;IACd,CAAC,EAPW,QAAQ,GAAR,6BAAQ,KAAR,6BAAQ,QAOnB;AACL,CAAC,EATgB,oBAAoB,KAApB,oBAAoB,QASpC;AAED,MAAM,OAAO,qBAA6B,SAAQ,gBAAuB;IASrE,YAAY,MAA4B,EAAE,QAAgB,EAAE,SAA4B;QACpF,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAPlB,gBAAW,GAAyC,qBAAqB,CAAC,cAAc,CAAC,QAAQ,CAAC;QAQxG,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,SAAS,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC;IAChD,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,IAAW,UAAU;QACjB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAED,IAAW,kBAAkB;QACzB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IACpC,CAAC;IAED,IAAW,kBAAkB;QACzB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IACpC,CAAC;IAED,IAAW,eAAe;QACtB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IACjC,CAAC;IAED,IAAW,YAAY;QACnB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IAEM,sBAAsB,CAAC,kBAA0B;QACpD,IAAI,CAAC,mBAAmB,GAAG,kBAAkB,CAAC;QAC9C,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,sBAAsB,CAAC,kBAA0B;QACpD,IAAI,CAAC,mBAAmB,GAAG,kBAAkB,CAAC;QAC9C,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,mBAAmB,CAAC,QAAgB;QACvC,IAAI,CAAC,gBAAgB,GAAG,QAAQ,CAAC;QACjC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,UAAU,CAAI,MAA6F,EAAE,WAAqB;QACrI,MAAM,YAAY,GAAG,IAAI,kBAAkB,CAAO,IAAI,CAAC,UAAU,CAAC,CAAC;QACnE,IAAI,WAAW,EAAE;YACb,YAAY,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;SAC7C;QACD,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChC,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;QAClC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,sBAAsB,CAAC,YAAyC;QACnE,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;QAClC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,cAAc;QACjB,IAAI,CAAC,WAAW,GAAG,qBAAqB,CAAC,cAAc,CAAC,YAAY,CAAC;QACrE,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,IAAI;QACP,MAAM,KAAK,GAAG,IAAI,qBAAqB,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QACvF,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QACzB,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACrC,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC;QACrD,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC;QACrD,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC;QAC/C,KAAK,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QACzC,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ;AAED,WAAiB,qBAAqB;IAClC,IAAY,cAGX;IAHD,WAAY,cAAc;QACtB,2DAAQ,CAAA;QACR,mEAAY,CAAA;IAChB,CAAC,EAHW,cAAc,GAAd,oCAAc,KAAd,oCAAc,QAGzB;AACL,CAAC,EALgB,qBAAqB,KAArB,qBAAqB,QAKrC;AAED,MAAM,OAAO,yBAA8B,SAAQ,qBAAyC;IAIxF,YAAY,MAA4B,EAAE,QAAgB,EAAE,QAAgB,EAAE,OAA8B;QACxG,KAAK,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;QAE9B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,MAAM,YAAY,GAAG,IAAI,kBAAkB,CAAsB,IAAI,CAAC;aACjE,YAAY,CAAC,QAAQ,CAAC;aACtB,UAAU,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;QACnC,IAAI,CAAC,sBAAsB,CAAC,YAAY,CAAC,CAAC;IAC9C,CAAC;IAED,IAAW,QAAQ;QACf,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAEe,IAAI;QAChB,MAAM,KAAK,GAAG,IAAI,yBAAyB,CAAK,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;QAClG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QACzB,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACrC,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC;QACrD,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC;QACrD,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC;QAC/C,KAAK,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QACzC,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ;AAED,MAAM,OAAO,+BAAuC,SAAQ,gBAAuB;IAY/E,YAAY,MAA4B,EAAE,QAAgB,EAAE,SAAuB,EAAE,mBAAuC,EAAE,qBAAyC;QACnK,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QARpB,eAAU,GAA6C,+BAA+B,CAAC,QAAQ,CAAC,sBAAsB,CAAC;QACvH,6BAAwB,GAAoC,IAAI,CAAC;QACjE,aAAQ,GAAsD,EAAE,CAAC;QACjE,4BAAuB,GAAY,KAAK,CAAC;QACzC,2BAAsB,GAAW,EAAE,CAAC;QACpC,0BAAqB,GAAW,EAAE,CAAC;QAIvC,IAAI,CAAC,MAAM,GAAG,IAAI,eAAe,CAAI,SAAS,CAAC,CAAC;QAChD,IAAI,CAAC,oBAAoB,GAAG,mBAAmB,CAAC;QAChD,IAAI,CAAC,sBAAsB,GAAG,qBAAqB,CAAC;QACpD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,+BAA+B,CAAC,UAAU,CAAC,GAAG,EAAE,+BAA+B,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAC1H,CAAC;IAED,IAAW,mBAAmB;QAC1B,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACrC,CAAC;IAED,IAAW,qBAAqB;QAC5B,OAAO,IAAI,CAAC,sBAAsB,CAAC;IACvC,CAAC;IAED,IAAW,uBAAuB;QAC9B,OAAO,IAAI,CAAC,wBAAwB,CAAC;IACzC,CAAC;IAED,IAAW,OAAO;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,IAAW,sBAAsB;QAC7B,OAAO,IAAI,CAAC,uBAAuB,CAAC;IACxC,CAAC;IAED,IAAW,qBAAqB;QAC5B,OAAO,IAAI,CAAC,sBAAsB,CAAC;IACvC,CAAC;IAED,IAAW,oBAAoB;QAC3B,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACtC,CAAC;IAEM,UAAU,CAAI,MAAuF,EAAE,WAAqB;QAC/H,MAAM,YAAY,GAAG,IAAI,qBAAqB,CAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACvE,IAAI,WAAW,EAAE;YACb,YAAY,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;SAC7C;QACD,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChC,IAAI,CAAC,wBAAwB,GAAG,YAAY,CAAC;QAC7C,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,sBAAsB,CAAC,YAAwC;QAClE,IAAI,CAAC,wBAAwB,GAAG,YAAY,CAAC;QAC7C,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,WAAW,CAAC,UAA6D,EAAE;QAC9E,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,iBAAiB,CAAC,cAAsB,EAAE,aAAqB,EAAE,mBAA4B,IAAI;QACpG,IAAI,CAAC,uBAAuB,GAAG,gBAAgB,CAAC;QAChD,IAAI,CAAC,sBAAsB,GAAG,cAAc,CAAC;QAC7C,IAAI,CAAC,qBAAqB,GAAG,aAAa,CAAC;QAC3C,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,IAAI;QACP,MAAM,KAAK,GAAG,IAAI,+BAA+B,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,oBAAoB,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,sBAAsB,CAAC,IAAI,EAAE,CAAC,CAAC;QACxK,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QACzB,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACnC,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC3C,KAAK,CAAC,wBAAwB,GAAG,IAAI,CAAC,wBAAwB,CAAC;QAC/D,KAAK,CAAC,uBAAuB,GAAG,IAAI,CAAC,uBAAuB,CAAC;QAC7D,KAAK,CAAC,sBAAsB,GAAG,IAAI,CAAC,sBAAsB,CAAC;QAC3D,KAAK,CAAC,qBAAqB,GAAG,IAAI,CAAC,qBAAqB,CAAC;QACzD,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ;AAED,WAAiB,+BAA+B;IAC5C,IAAY,QAEX;IAFD,WAAY,QAAQ;QAChB,2EAAsB,CAAA;IAC1B,CAAC,EAFW,QAAQ,GAAR,wCAAQ,KAAR,wCAAQ,QAEnB;IAED,IAAY,UAGX;IAHD,WAAY,UAAU;QAClB,yCAAG,CAAA;QACH,+CAAM,CAAA;IACV,CAAC,EAHW,UAAU,GAAV,0CAAU,KAAV,0CAAU,QAGrB;AACL,CAAC,EATgB,+BAA+B,KAA/B,+BAA+B,QAS/C;AAED,MAAM,OAAO,yBAAiC,SAAQ,gBAAuB;IAOzE,YAAY,MAA4B,EAAE,QAAgB,EAAE,SAAuB,EAAE,mBAA2C;QAC5H,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAJpB,eAAU,GAAuC,yBAAyB,CAAC,QAAQ,CAAC,YAAY,CAAC;QACjG,aAAQ,GAAgD,EAAE,CAAC;QAI/D,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,IAAI,CAAC,oBAAoB,GAAG,mBAAmB,CAAC;QAChD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,yBAAyB,CAAC,UAAU,CAAC,GAAG,EAAE,yBAAyB,CAAC,UAAU,CAAC,IAAI,EAAE,yBAAyB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IACzJ,CAAC;IAED,IAAW,mBAAmB;QAC1B,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACrC,CAAC;IAED,IAAW,eAAe;QACtB,OAAO,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC;IAC3C,CAAC;IAED,IAAW,eAAe;QACtB,OAAO,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC;IAC/C,CAAC;IAED,IAAW,aAAa;QACpB,OAAO,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC;IAChD,CAAC;IAED,IAAW,eAAe;QACtB,OAAO,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC;IAChD,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,IAAW,OAAO;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAEM,WAAW,CAAC,UAA6D,EAAE;QAC9E,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,IAAI;QACP,MAAM,KAAK,GAAG,IAAI,yBAAyB,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,oBAAoB,CAAC,IAAI,EAAE,CAAC,CAAC;QAC7H,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QACzB,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACnC,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC3C,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ;AAED,WAAiB,yBAAyB;IACtC,IAAY,QAEX;IAFD,WAAY,QAAQ;QAChB,uDAAY,CAAA;IAChB,CAAC,EAFW,QAAQ,GAAR,kCAAQ,KAAR,kCAAQ,QAEnB;IAED,IAAY,UAIX;IAJD,WAAY,UAAU;QAClB,yCAAG,CAAA;QACH,2CAAI,CAAA;QACJ,+CAAM,CAAA;IACV,CAAC,EAJW,UAAU,GAAV,oCAAU,KAAV,oCAAU,QAIrB;AACL,CAAC,EAVgB,yBAAyB,KAAzB,yBAAyB,QAUzC;AAED,MAAM,OAAgB,qBAA0B,SAAQ,uBAA2B;IAQ/E,YAAsB,MAA4B,EAAE,IAAY;QAC5D,KAAK,CAAC,MAAM,CAAC,CAAC;QAJR,YAAO,GAAkC,EAAE,CAAC;QAC5C,gBAAW,GAA0B,EAAE,CAAC;QAI9C,IAAI,CAAC,KAAK,GAAG,GAAG,IAAI,CAAC,QAAQ,GAAG,IAAI,EAAE,CAAC;QACvC,IAAI,CAAC,QAAQ,GAAG,IAAI,KAAK,gBAAgB,CAAC,gBAAgB,CAAC;IAC/D,CAAC;IAUD,IAAW,QAAQ;QACf,OAAO,GAAG,IAAI,CAAC,SAAS,EAAE,GAAG,CAAC;IAClC,CAAC;IAED,IAAW,IAAI;QACX,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAED,IAAW,OAAO;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED,IAAW,KAAK;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,IAAW,UAAU;QACjB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAEM,SAAS,CAAC,KAAa;QAC1B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,aAAa,CAAC,IAAY,EAAE,UAAiD;QAChF,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC;QACvE,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ;AAED,MAAM,OAAO,uBAA4B,SAAQ,qBAAyB;IAEtE,YAAY,MAA4B,EAAE,IAAY;QAClD,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACxB,CAAC;IAED,IAAW,MAAM;QACb,OAAO,IAAI,CAAC,OAA0C,CAAC;IAC3D,CAAC;IAEM,SAAS;QACZ,OAAO,KAAK,CAAC;IACjB,CAAC;IAEM,QAAQ,CAAC,KAA+B;QAC3C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,IAAI;QACP,MAAM,GAAG,GAAG,IAAI,uBAAuB,CAAK,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;QACrG,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACzB,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAC7C,OAAO,GAAG,CAAC;IACf,CAAC;CACJ;AAED,MAAM,OAAO,oBAAyB,SAAQ,qBAAyB;IAEnE,YAAY,MAA4B,EAAE,IAAY;QAClD,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACxB,CAAC;IAED,IAAW,MAAM;QACb,OAAO,IAAI,CAAC,OAA2C,CAAC;IAC5D,CAAC;IAEM,SAAS;QACZ,OAAO,OAAO,CAAC;IACnB,CAAC;IAEM,QAAQ,CAAC,KAAgC;QAC5C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,IAAI;QACP,MAAM,KAAK,GAAG,IAAI,oBAAoB,CAAK,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;QACpG,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAC/C,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ","sourcesContent":["import {Type} from '@angular/core';\nimport {AbstractControl} from '@angular/forms';\nimport {FormlyFieldConfig} from '@ngx-formly/core';\n\nimport {Observable, of} from 'rxjs';\n\nimport {ClassType, EnumMemberType} from '../types';\nimport {ILookupDataProvider, ITableDataProvider, LookupDataProvider, TableviewDataProvider} from '../data-providers';\nimport {ModelDescriptor, TableDescriptor, TableviewDescriptor, FieldValidator, ILookupDescriptor} from './';\n\nimport {MediusQueryParam, MediusQueryResult} from '../api/models';\nimport {ObjectSerializer} from '../api/utils';\nimport {ModelUtil} from '../utils';\n\nexport class EditorDescriptor<T> {\n\n    public static readonly defaultGroupName = '_default';\n\n    private readonly _model: ModelDescriptor<T>;\n    private readonly _tabs: Array<FieldTabGroupDescriptor<T>> = [];\n    private readonly _groups: Array<FieldGroupDescriptor<T>> = [];\n    private readonly _fields: Array<AFieldDescriptor<any, T>> = [];\n    private _currentTabGroup?: FieldTabGroupDescriptor<T>;\n    private _currentGroup?: FieldGroupDescriptor<T>;\n\n    private _disabled: boolean = false;\n\n    constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string) {\n        this._model = new ModelDescriptor<T>(modelType, idProperty, titleProperty);\n    }\n\n    public get model() {\n        return this._model;\n    }\n\n    public get tabs() {\n        return this._tabs;\n    }\n\n    public get disabled() {\n        return this._disabled;\n    }\n\n    public get fields() {\n        return this._fields;\n    }\n\n    public createTabGroup(name: string, title?: string): FieldTabGroupDescriptor<T> {\n        const tabGroup = new FieldTabGroupDescriptor<T>(this, name);\n        if (title) {\n            tabGroup.withTitle(title);\n        }\n        this.createTabGroupDescriptor(tabGroup);\n        return tabGroup;\n    }\n\n    public createFieldGroup(name: string, title?: string): FieldGroupDescriptor<T> {\n        const fieldGroup = new FieldGroupDescriptor<T>(this, name);\n        if (title) {\n            fieldGroup.withTitle(title);\n        }\n        this.createFieldGroupDescriptor(fieldGroup);\n        return fieldGroup;\n    }\n\n    public addFieldDescriptor<FT>(field: AFieldDescriptor<FT, T>): this {\n        this.createDefaultGroup();\n        this._fields.push(field);\n        this._currentGroup?.addField(field);\n        return this;\n    }\n\n    public addField(property: string): FieldInputDescriptor<T> {\n        const field = new FieldInputDescriptor<T>(this, property);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    public removeField(property: string): this {\n        const fieldIdx = this._fields.findIndex(f => f.property === property);\n        if (fieldIdx < 0) {\n            throw new Error(`Field ${property} does not exist.`);\n        }\n        const field = this._fields[fieldIdx];\n        if (field.group) {\n            const groupFieldIdx = field.group.fields.findIndex(f => f instanceof AFieldDescriptor && f.property === property);\n            if (groupFieldIdx >= 0) {\n                field.group.fields.splice(groupFieldIdx, 1);\n            }\n        }\n        this._fields.splice(fieldIdx, 1);\n        return this;\n    }\n\n    public getField(property: string): AFieldDescriptor<any, T>|null {\n        return this._fields.find(f => f.property === property) ?? null;\n    }\n\n    public addFieldLookup<FT>(property: string, modelType: ClassType<FT>): FieldLookupDescriptor<FT, T> {\n        const field = new FieldLookupDescriptor<FT, T>(this, property, modelType);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    public addFieldLookupEnum(property: string, options: Array<EnumMemberType>): FieldLookupEnumDescriptor<T> {\n        const propDef = ObjectSerializer.get().findAttributeDefinitionByClassType(this.model.type, property);\n        if (!propDef) {\n            throw new Error(`Property (attribute) definition not found for property ${property} on class type ${this._model.typeName}`);\n        }\n        const enumDef = ObjectSerializer.get().findEnum(propDef.type);\n        if (!enumDef) {\n            throw new Error(`Enum definition ${propDef.type} not found for property ${property} on class type ${this._model.typeName}`);\n        }\n        const field = new FieldLookupEnumDescriptor(this, property, propDef.type, options);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    public addFieldManyEditor<FT>(property: string, type: ClassType<FT>, tableviewDescriptor: TableviewDescriptor<FT>): FieldManyEditorDescriptor<FT, T> {\n        const field = new FieldManyEditorDescriptor(this, property, type, tableviewDescriptor);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    public addFieldManyToManyEditor<FT>(property: string, type: ClassType<FT>, mainTableDescriptor: TableDescriptor<FT>, lookupTableDescriptor: TableDescriptor<FT>): FieldManyToManyEditorDescriptor<FT, T> {\n        const field = new FieldManyToManyEditorDescriptor(this, property, type, mainTableDescriptor, lookupTableDescriptor);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    public withDisabled(disabled: boolean = true): this {\n        this._disabled = disabled;\n        return this;\n    }\n\n    public addValidator(name: string, expression: (control: AbstractControl) => boolean) {\n        if (this._currentGroup) {\n            this._currentGroup.withValidator(name, expression);\n        }\n    }\n\n    public copy(): EditorDescriptor<T> {\n        const editor = new EditorDescriptor<T>(this.model.type, this.model.idPropertyName, this.model.titlePropertyName);\n        for (const tabGroup of this._tabs) {\n            editor.createTabGroupDescriptor(tabGroup.copy());\n        }\n        for (const tabGroup of editor._tabs) {\n            for (const fieldGroup of tabGroup.fields) {\n                editor._fields.push(...fieldGroup.fields);\n            }\n            editor._groups.push(...tabGroup.fields);\n        }\n        editor._currentTabGroup = editor._tabs[editor._tabs.length - 1];\n        editor._currentGroup = editor._currentTabGroup.fields[editor._currentTabGroup.fields.length - 1];\n        editor._disabled = this._disabled;\n        return editor;\n    }\n\n    private createTabGroupDescriptor(tabGroup: FieldTabGroupDescriptor<T>): this {\n        this._currentTabGroup = tabGroup;\n        this._tabs.push(tabGroup);\n        return this;\n    }\n\n    public createFieldGroupDescriptor(fieldGroup: FieldGroupDescriptor<T>): this {\n        this.createDefaultTabGroup();\n        this._currentGroup = fieldGroup;\n        this._groups.push(fieldGroup);\n        this._currentTabGroup?.addField(fieldGroup);\n        return this;\n    }\n\n    private createDefaultGroup() {\n        this.createDefaultTabGroup();\n        if (this._currentTabGroup?.fields.length === 0) {\n            this.createFieldGroup(EditorDescriptor.defaultGroupName);\n        }\n    }\n\n    private createDefaultTabGroup() {\n        if (this._tabs.length === 0) {\n            this.createTabGroup(EditorDescriptor.defaultGroupName);\n        }\n    }\n}\n\nexport abstract class AGenericFieldDescriptor<ET> {\n    protected readonly _editor: EditorDescriptor<ET>;\n\n    protected constructor(editor: EditorDescriptor<ET>) {\n        this._editor = editor;\n    }\n\n    public get editor() {\n        return this._editor;\n    }\n}\n\nexport abstract class AFieldDescriptor<T, ET> extends AGenericFieldDescriptor<ET> {\n\n    protected readonly _property: string;\n    protected _group?: AFieldGroupDescriptor<ET>;\n    protected _label?: string;\n    protected _placeholder?: string;\n    protected _required: boolean = false;\n    protected _disabled: boolean = false;\n    protected _className: string = '';\n    protected _getter?: (item: ET) => T;\n    protected _setter?: (item: ET, value: T) => void;\n    protected _validators: Array<FieldValidator> = [];\n\n    protected constructor(editor: EditorDescriptor<ET>, property: string) {\n        super(editor);\n        this._property = property;\n        this._label = this._editor.model.typeName + '.properties.' + property;\n    }\n\n    public abstract copy(): AFieldDescriptor<T, ET>;\n\n    public get property() {\n        return this._property;\n    }\n\n    public get group() {\n        return this._group;\n    }\n\n    public get label() {\n        return this._label;\n    }\n\n    public get placeholder() {\n        return this._placeholder;\n    }\n\n    public get required() {\n        return this._required;\n    }\n\n    public get disabled() {\n        return this._disabled;\n    }\n\n    public get className() {\n        return this._className;\n    }\n\n    public get getter() {\n        return this._getter;\n    }\n\n    public get setter() {\n        return this._setter;\n    }\n\n    public get validators() {\n        return this._validators;\n    }\n\n    public withLabel(label: string): this {\n        this._label = label;\n        return this;\n    }\n\n    public withPlaceholder(placeholder: string): this {\n        this._placeholder = placeholder;\n        return this;\n    }\n\n    public withRequired(required: boolean = true): this {\n        this._required = required;\n        return this;\n    }\n\n    public withDisabled(disabled: boolean = true): this {\n        this._disabled = disabled;\n        return this;\n    }\n\n    public withClassName(className: string): this {\n        this._className = className;\n        return this;\n    }\n\n    public withGetter(getter: (item: ET) => T): this {\n        this._getter = getter;\n        return this;\n    }\n\n    public withSetter(setter: (item: ET, value: T) => void): this {\n        this._setter = setter;\n        return this;\n    }\n\n    public withValidator(name: string, expression: (control: AbstractControl) => boolean,\n                         message: (err: any, field: FormlyFieldConfig) => string): this {\n        this._validators.push(new FieldValidator(name, expression, message));\n        return this;\n    }\n\n    protected copyFieldsTo(obj: AFieldDescriptor<T, ET>) {\n        obj._label = this._label;\n        obj._placeholder = this._placeholder;\n        obj._required = this._required;\n        obj._disabled = this._disabled;\n        obj._className = this._className;\n        obj._getter = this._getter;\n        obj._setter = this._setter;\n        obj._validators = this._validators;\n    }\n}\n\nexport class FieldInputDescriptor<ET> extends AFieldDescriptor<string|number|boolean|Date, ET> {\n\n    private _fieldType: FieldInputDescriptor.TypeEnum = FieldInputDescriptor.TypeEnum.Text;\n\n    // textarea specific properties\n    private _rows?: number;\n\n    // number specific properties\n    private _numberMin?: number;\n    private _numberMax?: number;\n    private _numberStep?: number;\n    private _numberMinFractionDigits?: number;\n    private _numberMaxFractionDigits?: number;\n\n    // radio specific properties\n    private _radioOptions: Array<string> = [];\n\n    // datepicker specific properties\n    private _datePickerFormat?: string;\n    private _datePickerMin?: Date;\n    private _datePickerMax?: Date;\n    private _datePickerShowTime: boolean = false;\n\n    // input specific\n    private _maxLength?: number;\n    private _minLength?: number;\n    private _pattern?: string | RegExp;\n\n    constructor(editor: EditorDescriptor<ET>, property: string) {\n        super(editor, property);\n    }\n\n    public get fieldType() {\n        return this._fieldType;\n    }\n\n    public get numberStep() {\n        return this._numberStep;\n    }\n\n    public get numberMin() {\n        return this._numberMin;\n    }\n\n    public get numberMax() {\n        return this._numberMax;\n    }\n\n    public get rows() {\n        return this._rows;\n    }\n\n    public get numberMinFractionDigits() {\n        return this._numberMinFractionDigits;\n    }\n\n    public get numberMaxFractionDigits() {\n        return this._numberMaxFractionDigits;\n    }\n\n    public get radioOptions() {\n        return this._radioOptions;\n    }\n\n    public get datePickerFormat() {\n        return this._datePickerFormat;\n    }\n\n    public get datePickerMin() {\n        return this._datePickerMin;\n    }\n\n    public get datePickerMax() {\n        return this._datePickerMax;\n    }\n\n    public get datePickerShowTime() {\n        return this._datePickerShowTime;\n    }\n\n    public get maxLength() {\n        return this._maxLength;\n    }\n\n    public get minLength() {\n        return this._minLength;\n    }\n\n    public get pattern() {\n        return this._pattern;\n    }\n\n    public asText(minLength?: number, maxLength?: number, pattern?: string | RegExp): this {\n        this._fieldType = FieldInputDescriptor.TypeEnum.Text;\n        this._minLength = minLength;\n        this._maxLength = maxLength;\n        this._pattern = pattern;\n        return this;\n    }\n\n    public asTextarea(rows: number = 3): this {\n        this._fieldType = FieldInputDescriptor.TypeEnum.Textarea;\n        this._rows = rows;\n        return this;\n    }\n\n    public asNumber(step?: number, min?: number, max?: number, minFractionDigits?: number, maxFractionDigits?: number): this {\n        this._fieldType = FieldInputDescriptor.TypeEnum.Number;\n        this._numberStep = step;\n        this._numberMinFractionDigits = minFractionDigits;\n        this._numberMaxFractionDigits = maxFractionDigits;\n        this._numberMin = min ?? Number.MIN_SAFE_INTEGER;\n        this._numberMax = max ?? Number.MAX_SAFE_INTEGER;\n        return this;\n    }\n\n    public asSwitch(): this {\n        this._fieldType = FieldInputDescriptor.TypeEnum.Switch;\n        return this;\n    }\n\n    public asRadio(options: Array<string>): this {\n        this._fieldType = FieldInputDescriptor.TypeEnum.Radio;\n        this._radioOptions = options;\n        return this;\n    }\n\n    public asDatePicker(format?: string, min?: Date, max?: Date, showTime?: boolean): this {\n        this._fieldType = FieldInputDescriptor.TypeEnum.Datepicker;\n        this._datePickerFormat = format ? format : 'dd.mm.yy';\n        this._datePickerMin = min;\n        this._datePickerMax = max;\n        this._datePickerShowTime = showTime ?? false;\n        return this;\n    }\n\n    public copy(): FieldInputDescriptor<ET> {\n        const field = new FieldInputDescriptor<ET>(this._editor, this._property);\n        this.copyFieldsTo(field);\n        field._fieldType = this._fieldType;\n        field._rows = this._rows;\n        field._numberMin = this._numberMin;\n        field._numberMax = this._numberMax;\n        field._numberStep = this._numberStep;\n        field._numberMinFractionDigits = this._numberMinFractionDigits;\n        field._numberMaxFractionDigits = this._numberMaxFractionDigits;\n        field._radioOptions = this._radioOptions;\n        field._datePickerFormat = this._datePickerFormat;\n        field._datePickerMin = this._datePickerMin;\n        field._datePickerMax = this._datePickerMax;\n        field._datePickerShowTime = this._datePickerShowTime;\n        field._maxLength = this._maxLength;\n        field._minLength = this._minLength;\n        field._pattern = this._pattern;\n        return field;\n    }\n}\nexport namespace FieldInputDescriptor {\n    export enum TypeEnum {\n        Text,\n        Textarea,\n        Number,\n        Switch,\n        Radio,\n        Datepicker\n    }\n}\n\nexport class FieldLookupDescriptor<T, ET> extends AFieldDescriptor<T, ET> implements ILookupDescriptor<T> {\n\n    protected readonly _modelType: ClassType<T>|null;\n    protected _lookupType: FieldLookupDescriptor.LookupTypeEnum = FieldLookupDescriptor.LookupTypeEnum.Dropdown;\n    protected _itemsLabelProperty?: string;\n    protected _itemsValueProperty?: string;\n    protected _dataKeyProperty?: string;\n    protected _dataProvider?: ILookupDataProvider<T, any>;\n\n    constructor(editor: EditorDescriptor<ET>, property: string, modelType: ClassType<T>|null) {\n        super(editor, property);\n        this._modelType = modelType;\n        ModelUtil.trySetLookupItemsProperties(this);\n    }\n\n    public get modelType() {\n        return this._modelType;\n    }\n\n    public get lookupType() {\n        return this._lookupType;\n    }\n\n    public get itemsLabelProperty() {\n        return this._itemsLabelProperty;\n    }\n\n    public get itemsValueProperty() {\n        return this._itemsValueProperty;\n    }\n\n    public get dataKeyProperty() {\n        return this._dataKeyProperty;\n    }\n\n    public get dataProvider() {\n        return this._dataProvider;\n    }\n\n    public withItemsLabelProperty(itemsLabelProperty: string): this {\n        this._itemsLabelProperty = itemsLabelProperty;\n        return this;\n    }\n\n    public withItemsValueProperty(itemsValueProperty: string): this {\n        this._itemsValueProperty = itemsValueProperty;\n        return this;\n    }\n\n    public withDataKeyProperty(property: string): this {\n        this._dataKeyProperty = property;\n        return this;\n    }\n\n    public withLookup<S>(lookup: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<T>>, serviceType?: Type<S>): this {\n        const dataProvider = new LookupDataProvider<T, S>(this._modelType);\n        if (serviceType) {\n            dataProvider.withServiceType(serviceType);\n        }\n        dataProvider.withLookup(lookup);\n        this._dataProvider = dataProvider;\n        return this;\n    }\n\n    public withLookupDataProvider(dataProvider: ILookupDataProvider<T, any>): this {\n        this._dataProvider = dataProvider;\n        return this;\n    }\n\n    public asAutocomplete(): this {\n        this._lookupType = FieldLookupDescriptor.LookupTypeEnum.Autocomplete;\n        return this;\n    }\n\n    public copy(): FieldLookupDescriptor<T, ET> {\n        const field = new FieldLookupDescriptor(this._editor, this._property, this._modelType);\n        this.copyFieldsTo(field);\n        field._lookupType = this._lookupType;\n        field._itemsLabelProperty = this._itemsLabelProperty;\n        field._itemsValueProperty = this._itemsValueProperty;\n        field._dataKeyProperty = this._dataKeyProperty;\n        field._dataProvider = this._dataProvider;\n        return field;\n    }\n}\n\nexport namespace FieldLookupDescriptor {\n    export enum LookupTypeEnum {\n        Dropdown,\n        Autocomplete\n    }\n}\n\nexport class FieldLookupEnumDescriptor<ET> extends FieldLookupDescriptor<EnumMemberType, ET> {\n\n    private readonly _enumName: string;\n\n    constructor(editor: EditorDescriptor<ET>, property: string, enumName: string, options: Array<EnumMemberType>) {\n        super(editor, property, null);\n\n        this._enumName = enumName;\n        const dataProvider = new LookupDataProvider<EnumMemberType, any>(null)\n            .withEnumName(enumName)\n            .withLookup(() => of(options));\n        this.withLookupDataProvider(dataProvider);\n    }\n\n    public get enumName() {\n        return this._enumName;\n    }\n\n    public override copy(): FieldLookupEnumDescriptor<ET> {\n        const field = new FieldLookupEnumDescriptor<ET>(this._editor, this._property, this._enumName, []);\n        this.copyFieldsTo(field);\n        field._lookupType = this._lookupType;\n        field._itemsLabelProperty = this._itemsLabelProperty;\n        field._itemsValueProperty = this._itemsValueProperty;\n        field._dataKeyProperty = this._dataKeyProperty;\n        field._dataProvider = this._dataProvider;\n        return field;\n    }\n}\n\nexport class FieldManyToManyEditorDescriptor<T, ET> extends AFieldDescriptor<T, ET> {\n\n    private readonly _model: ModelDescriptor<T>;\n    private readonly _mainTableDescriptor: TableDescriptor<T>; // table descriptor for main table component\n    private readonly _lookupTableDescriptor: TableDescriptor<T>; // table descriptor for where select will be applied\n    private _fieldType: FieldManyToManyEditorDescriptor.TypeEnum = FieldManyToManyEditorDescriptor.TypeEnum.DialogTableMultiselect;\n    private _lookupTableDataProvider: ITableDataProvider<T, any>|null = null;\n    private _actions: Array<FieldManyToManyEditorDescriptor.ActionEnum> = [];\n    private _hasLookupExcludeValues: boolean = false;\n    private _excludeFilterProperty: string = '';\n    private _excludeValueProperty: string = '';\n\n    constructor(editor: EditorDescriptor<ET>, property: string, modelType: ClassType<T>, mainTableDescriptor: TableDescriptor<T>, lookupTableDescriptor: TableDescriptor<T>) {\n        super(editor, property);\n        this._model = new ModelDescriptor<T>(modelType);\n        this._mainTableDescriptor = mainTableDescriptor;\n        this._lookupTableDescriptor = lookupTableDescriptor;\n        this._actions.push(FieldManyToManyEditorDescriptor.ActionEnum.Add, FieldManyToManyEditorDescriptor.ActionEnum.Delete);\n    }\n\n    public get mainTableDescriptor() {\n        return this._mainTableDescriptor;\n    }\n\n    public get lookupTableDescriptor() {\n        return this._lookupTableDescriptor;\n    }\n\n    public get lookupTableDataProvider() {\n        return this._lookupTableDataProvider;\n    }\n\n    public get actions() {\n        return this._actions;\n    }\n\n    public get fieldType() {\n        return this._fieldType;\n    }\n\n    public get hasLookupExcludeValues() {\n        return this._hasLookupExcludeValues;\n    }\n\n    public get excludeFilterProperty() {\n        return this._excludeFilterProperty;\n    }\n\n    public get excludeValueProperty() {\n        return this._excludeValueProperty;\n    }\n\n    public withLookup<S>(getAll: (queryParam: MediusQueryParam, service?: S) => Observable<MediusQueryResult<T>>, serviceType?: Type<S>): this {\n        const dataProvider = new TableviewDataProvider<T, S>(this._model.type);\n        if (serviceType) {\n            dataProvider.withServiceType(serviceType);\n        }\n        dataProvider.withGetAll(getAll);\n        this._lookupTableDataProvider = dataProvider;\n        return this;\n    }\n\n    public withLookupDataProvider(dataProvider: ITableDataProvider<T, any>): this {\n        this._lookupTableDataProvider = dataProvider;\n        return this;\n    }\n\n    public withActions(actions: Array<FieldManyToManyEditorDescriptor.ActionEnum> = []): this {\n        this.actions.push(...actions);\n        return this;\n    }\n\n    public withLookupExclude(filterProperty: string, valueProperty: string, hasLookupExclude: boolean = true): this {\n        this._hasLookupExcludeValues = hasLookupExclude;\n        this._excludeFilterProperty = filterProperty;\n        this._excludeValueProperty = valueProperty;\n        return this;\n    }\n\n    public copy(): FieldManyToManyEditorDescriptor<T, ET> {\n        const field = new FieldManyToManyEditorDescriptor(this._editor, this._property, this._model.type, this._mainTableDescriptor.copy(), this._lookupTableDescriptor.copy());\n        this.copyFieldsTo(field);\n        field._fieldType = this._fieldType;\n        field._actions = this._actions.map(a => a);\n        field._lookupTableDataProvider = this._lookupTableDataProvider;\n        field._hasLookupExcludeValues = this._hasLookupExcludeValues;\n        field._excludeFilterProperty = this._excludeFilterProperty;\n        field._excludeValueProperty = this._excludeValueProperty;\n        return field;\n    }\n}\n\nexport namespace FieldManyToManyEditorDescriptor {\n    export enum TypeEnum {\n        DialogTableMultiselect\n    }\n\n    export enum ActionEnum {\n        Add,\n        Delete\n    }\n}\n\nexport class FieldManyEditorDescriptor<T, ET> extends AFieldDescriptor<T, ET> {\n\n    private readonly _modelType: ClassType<T>;\n    private readonly _tableviewDescriptor: TableviewDescriptor<T>;\n    private _fieldType: FieldManyEditorDescriptor.TypeEnum = FieldManyEditorDescriptor.TypeEnum.DialogEditor;\n    private _actions: Array<FieldManyEditorDescriptor.ActionEnum> = [];\n\n    constructor(editor: EditorDescriptor<ET>, property: string, modelType: ClassType<T>, tableviewDescriptor: TableviewDescriptor<T>) {\n        super(editor, property);\n        this._modelType = modelType;\n        this._tableviewDescriptor = tableviewDescriptor;\n        this._actions.push(FieldManyEditorDescriptor.ActionEnum.Add, FieldManyEditorDescriptor.ActionEnum.Edit, FieldManyEditorDescriptor.ActionEnum.Delete);\n    }\n\n    public get tableviewDescriptor() {\n        return this._tableviewDescriptor;\n    }\n\n    public get tableDescriptor() {\n        return this._tableviewDescriptor.table;\n    }\n\n    public get editorForCreate() {\n        return this._tableviewDescriptor.addEditor;\n    }\n\n    public get editorForRead() {\n        return this._tableviewDescriptor.viewEditor;\n    }\n\n    public get editorForUpdate() {\n        return this._tableviewDescriptor.editEditor;\n    }\n\n    public get fieldType() {\n        return this._fieldType;\n    }\n\n    public get actions() {\n        return this._actions;\n    }\n\n    public withActions(actions: Array<FieldManyToManyEditorDescriptor.ActionEnum> = []): this {\n        this.actions.push(...actions);\n        return this;\n    }\n\n    public copy(): FieldManyEditorDescriptor<T, ET> {\n        const field = new FieldManyEditorDescriptor(this._editor, this._property, this._modelType, this._tableviewDescriptor.copy());\n        this.copyFieldsTo(field);\n        field._fieldType = this._fieldType;\n        field._actions = this._actions.map(a => a);\n        return field;\n    }\n}\n\nexport namespace FieldManyEditorDescriptor {\n    export enum TypeEnum {\n        DialogEditor\n    }\n\n    export enum ActionEnum {\n        Add,\n        Edit,\n        Delete\n    }\n}\n\nexport abstract class AFieldGroupDescriptor<ET> extends AGenericFieldDescriptor<ET> {\n\n    protected readonly _name: string;\n    protected readonly _default: boolean;\n    protected _title?: string;\n    protected _fields: AGenericFieldDescriptor<ET>[] = [];\n    protected _validators: Array<FieldValidator> = [];\n\n    protected constructor(editor: EditorDescriptor<ET>, name: string) {\n        super(editor);\n        this._name = `${this.baseName}${name}`;\n        this._default = name === EditorDescriptor.defaultGroupName;\n    }\n\n    abstract get fields(): AGenericFieldDescriptor<ET>[];\n\n    abstract groupName(): string;\n\n    abstract addField(field: AGenericFieldDescriptor<ET>): this;\n\n    abstract copy(): AFieldGroupDescriptor<ET>;\n\n    public get baseName() {\n        return `${this.groupName()}_`;\n    }\n\n    public get name() {\n        return this._name;\n    }\n\n    public get default() {\n        return this._default;\n    }\n\n    public get title() {\n        return this._title;\n    }\n\n    public get validators() {\n        return this._validators;\n    }\n\n    public withTitle(title: string): this {\n        this._title = title;\n        return this;\n    }\n\n    public withValidator(name: string, expression: (control: AbstractControl) => boolean) {\n        this._validators.push(new FieldValidator(name, expression, undefined));\n        return this;\n    }\n}\n\nexport class FieldTabGroupDescriptor<ET> extends AFieldGroupDescriptor<ET> {\n\n    constructor(editor: EditorDescriptor<ET>, name: string) {\n        super(editor, name);\n    }\n\n    public get fields(): Array<FieldGroupDescriptor<ET>> {\n        return this._fields as Array<FieldGroupDescriptor<ET>>;\n    }\n\n    public groupName(): string {\n        return 'tab';\n    }\n\n    public addField(field: FieldGroupDescriptor<ET>): this {\n        this._fields.push(field);\n        return this;\n    }\n\n    public copy(): FieldTabGroupDescriptor<ET> {\n        const tab = new FieldTabGroupDescriptor<ET>(this._editor, this.name.substring(this.baseName.length));\n        tab._title = this._title;\n        tab._fields = this.fields.map(f => f.copy());\n        return tab;\n    }\n}\n\nexport class FieldGroupDescriptor<ET> extends AFieldGroupDescriptor<ET> {\n\n    constructor(editor: EditorDescriptor<ET>, name: string) {\n        super(editor, name);\n    }\n\n    public get fields(): Array<AFieldDescriptor<any, ET>> {\n        return this._fields as Array<AFieldDescriptor<any, ET>>;\n    }\n\n    public groupName(): string {\n        return 'group';\n    }\n\n    public addField(field: AFieldDescriptor<any, ET>): this {\n        this._fields.push(field);\n        return this;\n    }\n\n    public copy(): FieldGroupDescriptor<ET> {\n        const group = new FieldGroupDescriptor<ET>(this._editor, this.name.substring(this.baseName.length));\n        group._title = this._title;\n        group._fields = this.fields.map(f => f.copy());\n        return group;\n    }\n}\n"]}