@mediusinc/mng-commons-data-api 5.2.0-rc.0 → 5.2.0-rc.2

package/esm2022/tableview/schema/fields-from-schema.mjs

@@ -0,0 +1,470 @@
+import { CommonsInternalError, fromAngularDateFormatToPrime } from '@mediusinc/mng-commons/core';
+import { EnumDescriptor } from '@mediusinc/mng-commons/model';
+import { FieldInputDescriptor, TableviewDescriptorInst } from '@mediusinc/mng-commons/tableview/api';
+import { enumModelFromSchema } from './enum-from-schema';
+import { fromSchemaCurrencyOptsToCurrency, fromSchemaFilterNonArrayProperties } from './internal/common-from-schema';
+/**
+ * <em>Experimental:</em> Builder for adding fields to editor.
+ *
+ * @experimental
+ */
+export class SchemaFieldsBuilder {
+    constructor(descriptor, schema, opts) {
+        this.descriptor = descriptor;
+        this.schema = schema;
+        this.opts = opts;
+    }
+    mergeFieldsInputOpts(property, opts) {
+        return {
+            ...this.opts,
+            fieldType: opts?.fieldTypes?.[property] ?? this.opts?.fieldTypes?.[property],
+            enumModel: opts?.enumModels?.[property] ?? this.opts?.enumModels?.[property],
+            enumSchema: opts?.enumSchemas?.[property] ?? this.opts?.enumSchemas?.[property],
+            ...opts
+        };
+    }
+    mergeFieldInputOpts(property, opts) {
+        return {
+            ...this.opts,
+            fieldType: this.opts?.fieldTypes?.[property],
+            enumModel: this.opts?.enumModels?.[property],
+            enumSchema: this.opts?.enumSchemas?.[property],
+            ...opts
+        };
+    }
+    /**
+     * <em>Experimental:</em> Adds a single input field via {addFieldInputFromSchema}.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to add the field for.
+     * @param {FieldInputFromSchemaOptsType<SchModel>} opts - Additional options.
+     *
+     * @return {FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>} The added field descriptor.
+     */
+    add(property, opts) {
+        return addFieldInputFromSchema(this.descriptor, property, this.schema.properties[property], this.mergeFieldInputOpts(property, opts));
+    }
+    /**
+     * <em>Experimental:</em> Adds all input fields for the non-array properties via {addFieldInputFromSchema}.
+     *
+     * @experimental
+     *
+     * @param {FieldsFromSchemaOptsType<SchModel>} opts - Additional options.
+     *
+     * @return {this} - The current instance of the builder.
+     */
+    withAddAll(opts) {
+        this.addFields(undefined, opts);
+        return this;
+    }
+    withAdd(propOrOpts, ...properties) {
+        if (typeof propOrOpts === 'object') {
+            this.addFields(properties.length === 0 ? undefined : properties, propOrOpts);
+        }
+        else {
+            this.addFields(propOrOpts === undefined ? properties : [propOrOpts, ...properties]);
+        }
+        return this;
+    }
+    addFields(properties, opts) {
+        const addProperties = properties ?? fromSchemaFilterNonArrayProperties(this.schema.properties);
+        addProperties.forEach(property => {
+            addFieldInputFromSchema(this.descriptor, property, this.schema.properties[property], this.mergeFieldsInputOpts(property, opts));
+        });
+    }
+    /**
+     * <em>Experimental:</em> Adds a single input field via {addFieldInputFromSchema} where property schema is manually provided.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to add the field for.
+     * @param {SchemaProperty} schemaProperty - Manually provided schema property.
+     * @param {FieldInputFromSchemaOptsType<Model>} opts - Additional options.
+     *
+     * @return {FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>} The added field descriptor.
+     */
+    addFromSchema(property, schemaProperty, opts) {
+        return addFieldInputFromSchema(this.descriptor, property, schemaProperty, this.mergeFieldInputOpts(property, opts));
+    }
+    /**
+     * <em>Experimental:</em> Adds an enum lookup field via {addFieldEnumLookupFromSchema}.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to add the enum lookup field for.
+     * @param {SchemaEnum<Enum> | EnumDescriptor<Enum>} [enumOpt] - The enum schema or the enum model descriptor. If non provided, builder opts will be checked.
+     *
+     * @returns {FieldLookupEnumDescriptor<Enum, Model, Parent>} - The added field descriptor.
+     *
+     * @throws {CommonsInternalError} - If no enum metadata is found for the property either from parameter or from builder's opts.
+     */
+    addEnum(property, enumOpt) {
+        if (!enumOpt) {
+            enumOpt = this.opts?.enumModels?.[property] ?? this.opts?.enumSchemas?.[property];
+        }
+        if (!enumOpt) {
+            throw new CommonsInternalError(`Enum lookup field for property ${property} cannot be added because enum metadata was not provided.`);
+        }
+        return addFieldEnumLookupFromSchema(this.descriptor, property, enumOpt, this.schema.properties[property]);
+    }
+    /**
+     * <em>Experimental:</em> Adds an enum lookup field via {addFieldEnumLookupFromSchema} where property schema is manually provided.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to add the enum lookup field for.
+     * @param {SchemaEnum<Enum> | EnumDescriptor<Enum>} [enumOpt] - The enum schema or the enum model descriptor. If non provided, builder opts will be checked.
+     * @param {SchemaProperty} schemaProperty - Manually provided schema property.
+     *
+     * @returns {FieldLookupEnumDescriptor<Enum, Model, Parent>} - The added field descriptor.
+     *
+     * @throws {CommonsInternalError} - If no enum metadata is found for the property either from parameter or from builder's opts.
+     */
+    addEnumFromSchema(property, enumOpt, schemaProperty) {
+        if (!enumOpt) {
+            enumOpt = this.opts?.enumModels?.[property] ?? this.opts?.enumSchemas?.[property];
+        }
+        if (!enumOpt) {
+            throw new CommonsInternalError(`Enum lookup field for property ${property} cannot be added because enum metadata was not provided.`);
+        }
+        return addFieldEnumLookupFromSchema(this.descriptor, property, enumOpt, schemaProperty);
+    }
+    /**
+     * <em>Experimental:</em> Adds a lookup field.
+     * {EditorDescriptorInt.addFieldLookup} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to create the lookup field for.
+     *
+     * @return The created lookup field.
+     */
+    addLookup(property) {
+        const field = this.descriptor.addFieldLookup(property);
+        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);
+        return field;
+    }
+    /**
+     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.
+     * {EditorDescriptorInt.addFieldLookup} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to create the lookup field for.
+     * @param {SchemaProperty} schemaProperty - Manually provided schema property.
+     *
+     * @return The created lookup field.
+     */
+    addLookupFromSchema(property, schemaProperty) {
+        const field = this.descriptor.addFieldLookup(property);
+        setFieldBasicOptionsFromSchema(field, schemaProperty);
+        return field;
+    }
+    /**
+     * <em>Experimental:</em> Adds a lookup field.
+     * {EditorDescriptorInt.addFieldLookupWithOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to create the lookup field for.
+     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.
+     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.
+     *
+     * @return The created lookup field.
+     */
+    addLookupWithOptionsValueProperty(property, type, lookupOptionsValueProperty) {
+        const field = this.descriptor.addFieldLookupWithOptionsValueProperty(property, type, lookupOptionsValueProperty);
+        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);
+        return field;
+    }
+    /**
+     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.
+     * {EditorDescriptorInt.addFieldLookupWithOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to create the lookup field for.
+     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.
+     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.
+     * @param {SchemaProperty} schemaProperty - Manually provided schema property.
+     *
+     * @return The created lookup field.
+     */
+    addLookupWithOptionsValuePropertyFromSchema(property, type, lookupOptionsValueProperty, schemaProperty) {
+        const field = this.descriptor.addFieldLookupWithOptionsValueProperty(property, type, lookupOptionsValueProperty);
+        setFieldBasicOptionsFromSchema(field, schemaProperty);
+        return field;
+    }
+    /**
+     * <em>Experimental:</em> Adds a lookup field.
+     * {EditorDescriptorInt.addFieldLookupWithProvider} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to create the lookup field for.
+     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.
+     *
+     * @return The created lookup field.
+     */
+    addLookupWithProvider(property, provider) {
+        const field = this.descriptor.addFieldLookupWithProvider(property, provider);
+        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);
+        return field;
+    }
+    /**
+     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.
+     * {EditorDescriptorInt.addFieldLookupWithProvider} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to create the lookup field for.
+     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.
+     * @param {SchemaProperty} schemaProperty - Manually provided schema property.
+     *
+     * @return The created lookup field.
+     */
+    addLookupWithProviderFromSchema(property, provider, schemaProperty) {
+        const field = this.descriptor.addFieldLookupWithProvider(property, provider);
+        setFieldBasicOptionsFromSchema(field, schemaProperty);
+        return field;
+    }
+    /**
+     * <em>Experimental:</em> Adds a lookup field.
+     * {EditorDescriptorInt.addFieldLookupWithProviderAndOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to create the lookup field for.
+     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.
+     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.
+     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.
+     *
+     * @return The created lookup field.
+     */
+    addLookupWithProviderAndOptionsValueProperty(property, provider, type, lookupOptionsValueProperty) {
+        const field = this.descriptor.addFieldLookupWithProviderAndOptionsValueProperty(property, provider, type, lookupOptionsValueProperty);
+        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);
+        return field;
+    }
+    /**
+     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.
+     * {EditorDescriptorInt.addFieldLookupWithProviderAndOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to create the lookup field for.
+     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.
+     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.
+     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.
+     * @param {SchemaProperty} schemaProperty - Manually provided schema property.
+     *
+     * @return The created lookup field.
+     */
+    addLookupWithProviderAndOptionsValuePropertyFromSchema(property, provider, type, lookupOptionsValueProperty, schemaProperty) {
+        const field = this.descriptor.addFieldLookupWithProviderAndOptionsValueProperty(property, provider, type, lookupOptionsValueProperty);
+        setFieldBasicOptionsFromSchema(field, schemaProperty);
+        return field;
+    }
+    /**
+     * <em>Experimental:</em> Adds a one-to-many editor field.
+     * {EditorDescriptorInt.addFieldManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to create the many editor field for.
+     * @param {TableviewDescriptorInst<FieldModel, any, any, Model>} tableviewDescriptor - Tableview descriptor.
+     *
+     * @return The created one-to-many editor field.
+     */
+    addManyEditor(property, tableviewDescriptor) {
+        const field = this.descriptor.addFieldManyEditor(property, tableviewDescriptor);
+        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);
+        return field;
+    }
+    /**
+     * <em>Experimental:</em> Adds an one-to-many editor field where property schema is manually provided.
+     * {EditorDescriptorInt.addFieldManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to create the many editor field for.
+     * @param {TableviewDescriptorInst<FieldModel, any, any, Model>} tableviewDescriptor - Tableview descriptor.
+     * @param {SchemaProperty} schemaProperty - Manually provided schema property.
+     *
+     * @return The created one-to-many editor field.
+     */
+    addManyEditorFromSchema(property, tableviewDescriptor, schemaProperty) {
+        const field = this.descriptor.addFieldManyEditor(property, tableviewDescriptor);
+        setFieldBasicOptionsFromSchema(field, schemaProperty);
+        return field;
+    }
+    /**
+     * <em>Experimental:</em> Adds a many-to-many editor field.
+     * {EditorDescriptorInt.addFieldManyToManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to create the many editor field for.
+     * @param {TableDescriptorInst<FieldModel>} mainTableDescriptor - Main table descriptor.
+     * @param {TableDescriptorInst<FieldModel>} lookupTableDescriptor - Lookup table descriptor.
+     * @param {ITableDataProvider<FieldModel, ServiceType>} lookupDataProvider - Lookup data provider.
+     *
+     * @return The created many-to-many editor field.
+     */
+    addManyToManyEditor(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider) {
+        const field = this.descriptor.addFieldManyToManyEditor(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider);
+        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);
+        return field;
+    }
+    /**
+     * <em>Experimental:</em> Adds a many-to-many editor field where property schema is manually provided.
+     * {EditorDescriptorInt.addFieldManyToManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to create the many editor field for.
+     * @param {TableDescriptorInst<FieldModel>} mainTableDescriptor - Main table descriptor.
+     * @param {TableDescriptorInst<FieldModel>} lookupTableDescriptor - Lookup table descriptor.
+     * @param {ITableDataProvider<FieldModel, ServiceType>} lookupDataProvider - Lookup data provider.
+     * @param {SchemaProperty} schemaProperty - Manually provided schema property.
+     *
+     * @return The created many-to-many editor field.
+     */
+    addManyToManyEditorFromSchema(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider, schemaProperty) {
+        const field = this.descriptor.addFieldManyToManyEditor(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider);
+        setFieldBasicOptionsFromSchema(field, schemaProperty);
+        return field;
+    }
+}
+/**
+ * <em>Experimental:</em> Creates builder for adding fields to descriptor based on provided model schema.
+ *
+ * @experimental
+ *
+ * @param {TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>} descriptor - Descriptor to add fields to.
+ * @param {SchemaModel<SchModel>} schema - The schema with metadata about properties for fields.
+ * @param {FieldsFromSchemaOptsType<SchModel>} [opts] - Additional options.
+ *
+ * @return {SchemaFieldsBuilder<Model, Parent, SchModel>} - The SchemaFieldsBuilder object containing the extracted fields.
+ */
+export function fieldsFromSchema(descriptor, schema, opts) {
+    return new SchemaFieldsBuilder(descriptor, schema, opts);
+}
+/**
+ * <em>Experimental:</em> Adds a field input to editor descriptor based on the given schema property and options.
+ *
+ * @experimental
+ *
+ * @param {TableviewDescriptorInst | EditorDescriptorInst} descriptor - Descriptor to add field to.
+ * @param {keyof Model} property - The property of the model.
+ * @param {SchemaProperty} propertySchema - The property's schema for the field.
+ * @param {FieldInputFromSchemaOptsType<Model>} [opts] - Additional options.
+ *
+ * @return {FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>} - The generated field input descriptor.
+ */
+export function addFieldInputFromSchema(descriptor, property, propertySchema, opts) {
+    const propertyType = opts?.fieldType ?? propertySchema.type;
+    const field = new FieldInputDescriptor(descriptor instanceof TableviewDescriptorInst ? descriptor.detailsEditor : descriptor, property);
+    if (descriptor instanceof TableviewDescriptorInst) {
+        descriptor.detailsEditor.addFieldDescriptor(field);
+        descriptor.editEditor.addFieldDescriptor(field);
+        descriptor.addEditor.addFieldDescriptor(field);
+    }
+    else {
+        descriptor.addFieldDescriptor(field);
+    }
+    // Handle different property types
+    switch (propertyType) {
+        case 'number':
+            if (opts?.currency) {
+                field.asCurrency(fromSchemaCurrencyOptsToCurrency(opts.currency));
+            }
+            else {
+                field.asNumber();
+            }
+            break;
+        case 'currency':
+            field.asCurrency(opts?.currency ? fromSchemaCurrencyOptsToCurrency(opts.currency) : undefined);
+            break;
+        case 'boolean':
+            field.asSwitch();
+            break;
+        case 'text':
+        case 'string':
+            field.asText();
+            break;
+        case 'textarea':
+            field.asTextarea();
+            break;
+        case 'date':
+            field.asDatePicker({ format: opts?.dateFormat ? fromAngularDateFormatToPrime(opts.dateFormat) : undefined });
+            break;
+        case 'date-time':
+            field.asDatePicker({ showTime: true, format: opts?.dateTimeFormat ? fromAngularDateFormatToPrime(opts.dateTimeFormat) : undefined });
+            break;
+        case 'enum':
+            // eslint-disable-next-line no-case-declarations
+            const enumModel = opts?.enumSchema ? enumModelFromSchema(opts.enumSchema) : opts?.enumModel;
+            if (enumModel) {
+                field.asRadioFromEnum(enumModel);
+            }
+            else {
+                field.asText();
+            }
+            break;
+        case 'hidden':
+            field.asHidden();
+            break;
+    }
+    // Handle different property validations
+    if (propertyType === 'number' || propertyType === 'currency') {
+        field.withNumberValidation({
+            min: propertySchema.exclusiveMinimum && propertySchema.minimum != undefined ? propertySchema.minimum + (propertySchema.isInteger ? 1 : 0.0001) : propertySchema.minimum,
+            max: propertySchema.exclusiveMaximum && propertySchema.maximum != undefined ? propertySchema.maximum - (propertySchema.isInteger ? 1 : 0.0001) : propertySchema.maximum
+        });
+    }
+    if (propertyType === 'string' || propertyType === 'textarea' || propertyType === 'text') {
+        field.withTextValidation({
+            minLength: propertySchema.minLength,
+            maxLength: propertySchema.maxLength,
+            pattern: propertySchema.pattern ? new RegExp(propertySchema.pattern.slice(1, -1)) : undefined
+        });
+        if (propertyType !== 'textarea' && propertySchema.isEmail) {
+            field.withTextValidationEmail();
+        }
+    }
+    setFieldBasicOptionsFromSchema(field, propertySchema);
+    return field;
+}
+/**
+ * <em>Experimental:</em> Adds a field enum lookup to editor descriptor based on the given schema property and options.
+ *
+ * @experimental
+ *
+ * @param {TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>} descriptor - Descriptor to add field to.
+ * @param {keyof Model} property - The property of the model.
+ * @param {SchemaEnum<Enum> | EnumDescriptor<Enum>} enumOpt - The enum schema or enum model descriptor.
+ * @param {SchemaProperty} propertySchema - The property's schema for the field.
+ *
+ * @returns {FieldLookupEnum<Enum>} - The field with enumeration values.
+ */
+export function addFieldEnumLookupFromSchema(descriptor, property, enumOpt, propertySchema) {
+    const enumDescriptor = enumOpt instanceof EnumDescriptor ? enumOpt : enumModelFromSchema(enumOpt);
+    const field = descriptor.addFieldLookupEnumUnsafe(property, enumDescriptor);
+    setFieldBasicOptionsFromSchema(field, propertySchema);
+    return field;
+}
+/**
+ * <em>Experimental:</em> Sets basic options for a field based on a given property schema.
+ *
+ * @param {AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>} field - The field to set options for.
+ * @param {SchemaProperty} propertySchema - The property schema to base the options on.
+ */
+export function setFieldBasicOptionsFromSchema(field, propertySchema) {
+    if (propertySchema.required)
+        field.withRequired();
+    if (propertySchema.isReadOnly)
+        field.withDisabled();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fields-from-schema.js","sourceRoot":"","sources":["../../../../tableview/src/schema/fields-from-schema.ts"],"names":[],"mappings":"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","sourcesContent":["import {SchemaEnum, SchemaModel, SchemaProperty} from '@mediusinc/mng-commons-data-api';\nimport {ArrayItemType, CommonsInternalError, KeyofAndOfType, fromAngularDateFormatToPrime} from '@mediusinc/mng-commons/core';\nimport {EnumDescriptor, TypeDescriptor} from '@mediusinc/mng-commons/model';\nimport {ITableDataProvider, TableDescriptorInst} from '@mediusinc/mng-commons/table/api';\nimport {\n    AFieldDescriptor,\n    EditorDescriptorInst,\n    FieldInputDescriptor,\n    FieldLookupDescriptor,\n    FieldLookupEnumDescriptor,\n    FieldLookupProviderType,\n    FieldManyEditorDescriptor,\n    FieldManyToManyEditorDescriptor,\n    TableviewDescriptorInst\n} from '@mediusinc/mng-commons/tableview/api';\n\nimport {enumModelFromSchema} from './enum-from-schema';\nimport {FromSchemaCurrencyOptsType, fromSchemaCurrencyOptsToCurrency, fromSchemaFilterNonArrayProperties} from './internal/common-from-schema';\n\ntype FieldInputType = 'number' | 'currency' | 'boolean' | 'string' | 'text' | 'textarea' | 'date' | 'date-time' | 'enum' | 'hidden';\n\ntype FieldsFromSchemaOptsType<Model = any> = {\n    fieldTypes?: Partial<Record<keyof Model, FieldInputType>>;\n    enumModels?: Partial<Record<keyof Model, EnumDescriptor<any>>>;\n    enumSchemas?: Partial<Record<keyof Model, SchemaEnum<any>>>;\n    dateFormat?: string;\n    dateTimeFormat?: string;\n};\n\ntype FieldInputFromSchemaOptsType<Model = any, Enum = any> = {\n    fieldType?: FieldInputType;\n    enumSchema?: SchemaEnum<Enum>;\n    enumModel?: EnumDescriptor<Enum>;\n    currency?: FromSchemaCurrencyOptsType<Model>;\n    dateFormat?: string;\n    dateTimeFormat?: string;\n};\n\n/**\n * <em>Experimental:</em> Builder for adding fields to editor.\n *\n * @experimental\n */\nexport class SchemaFieldsBuilder<Model, Parent = unknown, SchModel = Model> {\n    constructor(\n        private readonly descriptor: TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>,\n        private readonly schema: SchemaModel<SchModel>,\n        private opts?: FieldsFromSchemaOptsType<SchModel>\n    ) {}\n\n    private mergeFieldsInputOpts(property: keyof Model, opts?: FieldsFromSchemaOptsType) {\n        return <FieldInputFromSchemaOptsType>{\n            ...this.opts,\n            fieldType: opts?.fieldTypes?.[property] ?? this.opts?.fieldTypes?.[property],\n            enumModel: opts?.enumModels?.[property] ?? this.opts?.enumModels?.[property],\n            enumSchema: opts?.enumSchemas?.[property] ?? this.opts?.enumSchemas?.[property],\n            ...opts\n        };\n    }\n\n    private mergeFieldInputOpts(property: keyof Model, opts?: FieldInputFromSchemaOptsType) {\n        return <FieldInputFromSchemaOptsType>{\n            ...this.opts,\n            fieldType: this.opts?.fieldTypes?.[property],\n            enumModel: this.opts?.enumModels?.[property],\n            enumSchema: this.opts?.enumSchemas?.[property],\n            ...opts\n        };\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a single input field via {addFieldInputFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the field for.\n     * @param {FieldInputFromSchemaOptsType<SchModel>} opts - Additional options.\n     *\n     * @return {FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>} The added field descriptor.\n     */\n    public add<Property extends Extract<keyof Model, keyof SchModel>>(\n        property: Property,\n        opts?: FieldInputFromSchemaOptsType<SchModel>\n    ): FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent> {\n        return addFieldInputFromSchema(this.descriptor, property, this.schema.properties[property], this.mergeFieldInputOpts(property, opts));\n    }\n\n    /**\n     * <em>Experimental:</em> Adds all input fields for the non-array properties via {addFieldInputFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {FieldsFromSchemaOptsType<SchModel>} opts - Additional options.\n     *\n     * @return {this} - The current instance of the builder.\n     */\n    public withAddAll(opts?: FieldsFromSchemaOptsType<SchModel>): this {\n        this.addFields(undefined, opts);\n        return this;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds input fields for properties via {addFieldInputFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {FieldsFromSchemaOptsType<SchModel>} opts - Additional options.\n     * @param {...Property[]} properties - Properties to add fields for. If non provided, all non-array properties from schema will be added.\n     *\n     * @return {this} - The current instance of the builder.\n     */\n    public withAdd<PropertyKey extends Extract<keyof Model, keyof SchModel>>(opts: FieldsFromSchemaOptsType<SchModel>, ...properties: PropertyKey[]): this;\n    /**\n     * <em>Experimental:</em> Adds fields for properties via {addFieldInputFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {...Property[]} properties - Properties to add fields for. If non provided, all non-array properties from schema will be added.\n     *\n     * @return {this} - The current instance of the builder.\n     */\n    public withAdd<PropertyKey extends Extract<keyof Model, keyof SchModel>>(...properties: PropertyKey[]): this;\n    public withAdd<PropertyKey extends Extract<keyof Model, keyof SchModel>>(propOrOpts: FieldsFromSchemaOptsType<SchModel> | PropertyKey, ...properties: PropertyKey[]): this {\n        if (typeof propOrOpts === 'object') {\n            this.addFields(properties.length === 0 ? undefined : properties, propOrOpts);\n        } else {\n            this.addFields(propOrOpts === undefined ? properties : [propOrOpts, ...properties]);\n        }\n        return this;\n    }\n\n    private addFields<Property extends Extract<keyof Model, keyof SchModel>>(properties?: Property[], opts?: FieldsFromSchemaOptsType<SchModel>) {\n        const addProperties = properties ?? fromSchemaFilterNonArrayProperties(this.schema.properties);\n\n        addProperties.forEach(property => {\n            addFieldInputFromSchema(\n                this.descriptor,\n                property as unknown as keyof Model,\n                this.schema.properties[property],\n                this.mergeFieldsInputOpts(property as unknown as keyof Model, opts)\n            );\n        });\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a single input field via {addFieldInputFromSchema} where property schema is manually provided.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the field for.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     * @param {FieldInputFromSchemaOptsType<Model>} opts - Additional options.\n     *\n     * @return {FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>} The added field descriptor.\n     */\n    public addFromSchema<Property extends keyof Model>(\n        property: Property,\n        schemaProperty: SchemaProperty,\n        opts?: FieldInputFromSchemaOptsType<Model>\n    ): FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent> {\n        return addFieldInputFromSchema(this.descriptor, property, schemaProperty, this.mergeFieldInputOpts(property, opts));\n    }\n\n    /**\n     * <em>Experimental:</em> Adds an enum lookup field via {addFieldEnumLookupFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the enum lookup field for.\n     * @param {SchemaEnum<Enum> | EnumDescriptor<Enum>} [enumOpt] - The enum schema or the enum model descriptor. If non provided, builder opts will be checked.\n     *\n     * @returns {FieldLookupEnumDescriptor<Enum, Model, Parent>} - The added field descriptor.\n     *\n     * @throws {CommonsInternalError} - If no enum metadata is found for the property either from parameter or from builder's opts.\n     */\n    public addEnum<Property extends Extract<keyof Model, keyof SchModel>, Enum>(\n        property: Property,\n        enumOpt?: SchemaEnum<Enum> | EnumDescriptor<Enum>\n    ): FieldLookupEnumDescriptor<Enum, Model, Parent> {\n        if (!enumOpt) {\n            enumOpt = this.opts?.enumModels?.[property] ?? this.opts?.enumSchemas?.[property];\n        }\n        if (!enumOpt) {\n            throw new CommonsInternalError(`Enum lookup field for property ${property as string} cannot be added because enum metadata was not provided.`);\n        }\n        return addFieldEnumLookupFromSchema<Model, Parent, Enum>(this.descriptor, property, enumOpt, this.schema.properties[property]);\n    }\n\n    /**\n     * <em>Experimental:</em> Adds an enum lookup field via {addFieldEnumLookupFromSchema} where property schema is manually provided.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the enum lookup field for.\n     * @param {SchemaEnum<Enum> | EnumDescriptor<Enum>} [enumOpt] - The enum schema or the enum model descriptor. If non provided, builder opts will be checked.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @returns {FieldLookupEnumDescriptor<Enum, Model, Parent>} - The added field descriptor.\n     *\n     * @throws {CommonsInternalError} - If no enum metadata is found for the property either from parameter or from builder's opts.\n     */\n    public addEnumFromSchema<Property extends keyof Model, Enum>(\n        property: Property,\n        enumOpt: SchemaEnum<Enum> | EnumDescriptor<Enum> | undefined,\n        schemaProperty: SchemaProperty\n    ): FieldLookupEnumDescriptor<Enum, Model, Parent> {\n        if (!enumOpt) {\n            enumOpt = this.opts?.enumModels?.[property] ?? this.opts?.enumSchemas?.[property];\n        }\n        if (!enumOpt) {\n            throw new CommonsInternalError(`Enum lookup field for property ${property as string} cannot be added because enum metadata was not provided.`);\n        }\n        return addFieldEnumLookupFromSchema(this.descriptor, property, enumOpt, schemaProperty);\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field.\n     * {EditorDescriptorInt.addFieldLookup} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     *\n     * @return The created lookup field.\n     */\n    public addLookup<Property extends Extract<keyof Model, keyof SchModel>, LookupModel = NonNullable<Model[Property]>, FieldValue = Model[Property]>(property: Property) {\n        const field = this.descriptor.addFieldLookup<Property, LookupModel>(property);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldLookup} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupFromSchema<Property extends keyof Model, LookupModel = NonNullable<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        schemaProperty: SchemaProperty\n    ) {\n        const field = this.descriptor.addFieldLookup(property);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field.\n     * {EditorDescriptorInt.addFieldLookupWithOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.\n     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupWithOptionsValueProperty<\n        Property extends Extract<keyof Model, keyof SchModel>,\n        LookupModel,\n        LookupValueProperty extends KeyofAndOfType<LookupModel, Model[Property]>,\n        FieldValue = Model[Property]\n    >(property: Property, type: TypeDescriptor<LookupModel>, lookupOptionsValueProperty: LookupValueProperty) {\n        const field = this.descriptor.addFieldLookupWithOptionsValueProperty(property, type, lookupOptionsValueProperty);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldLookupWithOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.\n     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupWithOptionsValuePropertyFromSchema<\n        Property extends keyof Model,\n        LookupModel,\n        LookupValueProperty extends KeyofAndOfType<LookupModel, Model[Property]>,\n        FieldValue = Model[Property]\n    >(property: Property, type: TypeDescriptor<LookupModel>, lookupOptionsValueProperty: LookupValueProperty, schemaProperty: SchemaProperty) {\n        const field = this.descriptor.addFieldLookupWithOptionsValueProperty(property, type, lookupOptionsValueProperty);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field.\n     * {EditorDescriptorInt.addFieldLookupWithProvider} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupWithProvider<Property extends Extract<keyof Model, keyof SchModel>, Service, LookupModel = NonNullable<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        provider: FieldLookupProviderType<LookupModel, Service>\n    ) {\n        const field = this.descriptor.addFieldLookupWithProvider(property, provider);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldLookupWithProvider} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupWithProviderFromSchema<Property extends keyof Model, Service, LookupModel = NonNullable<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        provider: FieldLookupProviderType<LookupModel, Service>,\n        schemaProperty: SchemaProperty\n    ) {\n        const field = this.descriptor.addFieldLookupWithProvider(property, provider);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field.\n     * {EditorDescriptorInt.addFieldLookupWithProviderAndOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.\n     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.\n     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.\n     *\n     * @return The created lookup field.\n     */\n    addLookupWithProviderAndOptionsValueProperty<\n        Property extends Extract<keyof Model, keyof SchModel>,\n        Service,\n        LookupModel,\n        LookupValueProperty extends KeyofAndOfType<LookupModel, Model[Property]>,\n        FieldValue = Model[Property]\n    >(\n        property: Property,\n        provider: FieldLookupProviderType<LookupModel, Service>,\n        type: TypeDescriptor<LookupModel>,\n        lookupOptionsValueProperty: LookupValueProperty\n    ): FieldLookupDescriptor<LookupModel, Model, Service, FieldValue> {\n        const field = this.descriptor.addFieldLookupWithProviderAndOptionsValueProperty(property, provider, type, lookupOptionsValueProperty);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field as FieldLookupDescriptor<LookupModel, Model, Service, FieldValue>;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldLookupWithProviderAndOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.\n     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.\n     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created lookup field.\n     */\n    addLookupWithProviderAndOptionsValuePropertyFromSchema<\n        Property extends keyof Model,\n        Service,\n        LookupModel,\n        LookupValueProperty extends KeyofAndOfType<LookupModel, Model[Property]>,\n        FieldValue = Model[Property]\n    >(\n        property: Property,\n        provider: FieldLookupProviderType<LookupModel, Service>,\n        type: TypeDescriptor<LookupModel>,\n        lookupOptionsValueProperty: LookupValueProperty,\n        schemaProperty: SchemaProperty\n    ): FieldLookupDescriptor<LookupModel, Model, Service, FieldValue> {\n        const field = this.descriptor.addFieldLookupWithProviderAndOptionsValueProperty(property, provider, type, lookupOptionsValueProperty);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field as FieldLookupDescriptor<LookupModel, Model, Service, FieldValue>;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a one-to-many editor field.\n     * {EditorDescriptorInt.addFieldManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the many editor field for.\n     * @param {TableviewDescriptorInst<FieldModel, any, any, Model>} tableviewDescriptor - Tableview descriptor.\n     *\n     * @return The created one-to-many editor field.\n     */\n    addManyEditor<Property extends Extract<keyof Model, keyof SchModel>, FieldModel = ArrayItemType<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        tableviewDescriptor: TableviewDescriptorInst<FieldModel, any, any, Model>\n    ): FieldManyEditorDescriptor<FieldModel, Model, FieldValue> {\n        const field = this.descriptor.addFieldManyEditor<Property, FieldModel, FieldValue>(property, tableviewDescriptor);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds an one-to-many editor field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the many editor field for.\n     * @param {TableviewDescriptorInst<FieldModel, any, any, Model>} tableviewDescriptor - Tableview descriptor.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created one-to-many editor field.\n     */\n    addManyEditorFromSchema<Property extends keyof Model, FieldModel = ArrayItemType<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        tableviewDescriptor: TableviewDescriptorInst<FieldModel, any, any, Model>,\n        schemaProperty: SchemaProperty\n    ): FieldManyEditorDescriptor<FieldModel, Model, FieldValue> {\n        const field = this.descriptor.addFieldManyEditor<Property, FieldModel, FieldValue>(property, tableviewDescriptor);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a many-to-many editor field.\n     * {EditorDescriptorInt.addFieldManyToManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the many editor field for.\n     * @param {TableDescriptorInst<FieldModel>} mainTableDescriptor - Main table descriptor.\n     * @param {TableDescriptorInst<FieldModel>} lookupTableDescriptor - Lookup table descriptor.\n     * @param {ITableDataProvider<FieldModel, ServiceType>} lookupDataProvider - Lookup data provider.\n     *\n     * @return The created many-to-many editor field.\n     */\n    addManyToManyEditor<Property extends Extract<keyof Model, keyof SchModel>, ServiceType, FieldModel = ArrayItemType<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        mainTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupDataProvider: ITableDataProvider<FieldModel, ServiceType>\n    ): FieldManyToManyEditorDescriptor<FieldModel, Model, ServiceType, FieldValue> {\n        const field = this.descriptor.addFieldManyToManyEditor<Property, ServiceType, FieldModel, FieldValue>(\n            property,\n            mainTableDescriptor,\n            lookupTableDescriptor,\n            lookupDataProvider\n        );\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a many-to-many editor field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldManyToManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the many editor field for.\n     * @param {TableDescriptorInst<FieldModel>} mainTableDescriptor - Main table descriptor.\n     * @param {TableDescriptorInst<FieldModel>} lookupTableDescriptor - Lookup table descriptor.\n     * @param {ITableDataProvider<FieldModel, ServiceType>} lookupDataProvider - Lookup data provider.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created many-to-many editor field.\n     */\n    addManyToManyEditorFromSchema<Property extends keyof Model, ServiceType, FieldModel = ArrayItemType<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        mainTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupDataProvider: ITableDataProvider<FieldModel, ServiceType>,\n        schemaProperty: SchemaProperty\n    ): FieldManyToManyEditorDescriptor<FieldModel, Model, ServiceType, FieldValue> {\n        const field = this.descriptor.addFieldManyToManyEditor<Property, ServiceType, FieldModel, FieldValue>(\n            property,\n            mainTableDescriptor,\n            lookupTableDescriptor,\n            lookupDataProvider\n        );\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n}\n\n/**\n * <em>Experimental:</em> Creates builder for adding fields to descriptor based on provided model schema.\n *\n * @experimental\n *\n * @param {TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>} descriptor - Descriptor to add fields to.\n * @param {SchemaModel<SchModel>} schema - The schema with metadata about properties for fields.\n * @param {FieldsFromSchemaOptsType<SchModel>} [opts] - Additional options.\n *\n * @return {SchemaFieldsBuilder<Model, Parent, SchModel>} - The SchemaFieldsBuilder object containing the extracted fields.\n */\nexport function fieldsFromSchema<Model, Parent = unknown, SchModel = Model>(\n    descriptor: TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>,\n    schema: SchemaModel<SchModel>,\n    opts?: FieldsFromSchemaOptsType<SchModel>\n): SchemaFieldsBuilder<Model, Parent, SchModel> {\n    return new SchemaFieldsBuilder<Model, Parent, SchModel>(descriptor, schema, opts);\n}\n\n/**\n * <em>Experimental:</em> Adds a field input to editor descriptor based on the given schema property and options.\n *\n * @experimental\n *\n * @param {TableviewDescriptorInst | EditorDescriptorInst} descriptor - Descriptor to add field to.\n * @param {keyof Model} property - The property of the model.\n * @param {SchemaProperty} propertySchema - The property's schema for the field.\n * @param {FieldInputFromSchemaOptsType<Model>} [opts] - Additional options.\n *\n * @return {FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>} - The generated field input descriptor.\n */\nexport function addFieldInputFromSchema<Property extends keyof Model, Model, Parent = unknown>(\n    descriptor: TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>,\n    property: Property,\n    propertySchema: SchemaProperty,\n    opts?: FieldInputFromSchemaOptsType<Model>\n): FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent> {\n    const propertyType = opts?.fieldType ?? propertySchema.type;\n\n    const field = new FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>(\n        descriptor instanceof TableviewDescriptorInst ? descriptor.detailsEditor : descriptor,\n        property as string\n    );\n    if (descriptor instanceof TableviewDescriptorInst) {\n        descriptor.detailsEditor.addFieldDescriptor(field);\n        descriptor.editEditor.addFieldDescriptor(field);\n        descriptor.addEditor.addFieldDescriptor(field);\n    } else {\n        descriptor.addFieldDescriptor(field);\n    }\n\n    // Handle different property types\n    switch (propertyType as FieldInputType) {\n        case 'number':\n            if (opts?.currency) {\n                field.asCurrency(fromSchemaCurrencyOptsToCurrency(opts.currency));\n            } else {\n                field.asNumber();\n            }\n            break;\n        case 'currency':\n            field.asCurrency(opts?.currency ? fromSchemaCurrencyOptsToCurrency(opts.currency) : undefined);\n            break;\n        case 'boolean':\n            field.asSwitch();\n            break;\n        case 'text':\n        case 'string':\n            field.asText();\n            break;\n        case 'textarea':\n            field.asTextarea();\n            break;\n        case 'date':\n            field.asDatePicker({format: opts?.dateFormat ? fromAngularDateFormatToPrime(opts.dateFormat) : undefined});\n            break;\n        case 'date-time':\n            field.asDatePicker({showTime: true, format: opts?.dateTimeFormat ? fromAngularDateFormatToPrime(opts.dateTimeFormat) : undefined});\n            break;\n        case 'enum':\n            // eslint-disable-next-line no-case-declarations\n            const enumModel = opts?.enumSchema ? enumModelFromSchema(opts.enumSchema) : opts?.enumModel;\n            if (enumModel) {\n                field.asRadioFromEnum(enumModel);\n            } else {\n                field.asText();\n            }\n            break;\n        case 'hidden':\n            field.asHidden();\n            break;\n    }\n\n    // Handle different property validations\n    if (propertyType === 'number' || propertyType === 'currency') {\n        field.withNumberValidation({\n            min: propertySchema.exclusiveMinimum && propertySchema.minimum != undefined ? propertySchema.minimum + (propertySchema.isInteger ? 1 : 0.0001) : propertySchema.minimum,\n            max: propertySchema.exclusiveMaximum && propertySchema.maximum != undefined ? propertySchema.maximum - (propertySchema.isInteger ? 1 : 0.0001) : propertySchema.maximum\n        });\n    }\n\n    if (propertyType === 'string' || propertyType === 'textarea' || propertyType === 'text') {\n        field.withTextValidation({\n            minLength: propertySchema.minLength,\n            maxLength: propertySchema.maxLength,\n            pattern: propertySchema.pattern ? new RegExp(propertySchema.pattern.slice(1, -1)) : undefined\n        });\n\n        if (propertyType !== 'textarea' && propertySchema.isEmail) {\n            field.withTextValidationEmail();\n        }\n    }\n\n    setFieldBasicOptionsFromSchema(field, propertySchema);\n\n    return field;\n}\n\n/**\n * <em>Experimental:</em> Adds a field enum lookup to editor descriptor based on the given schema property and options.\n *\n * @experimental\n *\n * @param {TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>} descriptor - Descriptor to add field to.\n * @param {keyof Model} property - The property of the model.\n * @param {SchemaEnum<Enum> | EnumDescriptor<Enum>} enumOpt - The enum schema or enum model descriptor.\n * @param {SchemaProperty} propertySchema - The property's schema for the field.\n *\n * @returns {FieldLookupEnum<Enum>} - The field with enumeration values.\n */\nexport function addFieldEnumLookupFromSchema<Model, Parent = unknown, Enum = any>(\n    descriptor: TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>,\n    property: keyof Model,\n    enumOpt: SchemaEnum<Enum> | EnumDescriptor<Enum>,\n    propertySchema: SchemaProperty\n) {\n    const enumDescriptor = enumOpt instanceof EnumDescriptor ? enumOpt : enumModelFromSchema(enumOpt);\n    const field = descriptor.addFieldLookupEnumUnsafe<Enum>(property as string, enumDescriptor);\n    setFieldBasicOptionsFromSchema(field, propertySchema);\n    return field;\n}\n\n/**\n * <em>Experimental:</em> Sets basic options for a field based on a given property schema.\n *\n * @param {AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>} field - The field to set options for.\n * @param {SchemaProperty} propertySchema - The property schema to base the options on.\n */\nexport function setFieldBasicOptionsFromSchema<FieldModel = any, EditorModel = any, FieldValue = FieldModel, ParentEditorModel = undefined>(\n    field: AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>,\n    propertySchema: SchemaProperty\n): void {\n    if (propertySchema.required) field.withRequired();\n    if (propertySchema.isReadOnly) field.withDisabled();\n}\n"]}

package/esm2022/tableview/schema/internal/common-from-schema.mjs

@@ -0,0 +1,14 @@
+export function fromSchemaCurrencyOptsToCurrency(opts) {
+    return {
+        currency: typeof opts === 'string' ? opts : opts.currency,
+        currencyDisplay: typeof opts === 'object' ? opts.currencyDisplay : undefined,
+        currencyProperty: typeof opts === 'object' ? opts.currencyProperty : undefined
+    };
+}
+export function fromSchemaFilterNonArrayProperties(propertySchemas) {
+    return Object.keys(propertySchemas).filter(key => {
+        const propertySchema = propertySchemas[key];
+        return ['number', 'string', 'boolean', 'date', 'date-time', 'enum', 'object'].includes(propertySchema.type);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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