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

package/fesm2022/mediusinc-mng-commons-data-api-tableview.mjs

@@ -1,5 +1,7 @@
 import { inject, Injector } from '@angular/core';
-import { TableviewInputBuilder, TableviewDescriptorInst, TableviewDataProviderInst } from '@mediusinc/mng-commons/tableview/api';
+import { TableviewInputBuilder, TableviewDescriptorInst, TableviewDataProviderInst, FieldInputDescriptor } from '@mediusinc/mng-commons/tableview/api';
+import { enumModelGeneric, EnumDescriptor } from '@mediusinc/mng-commons/model';
+import { CommonsInternalError, fromAngularDateFormatToPrime } from '@mediusinc/mng-commons/core';
 
 /**
  * Creates a tableview with a given model, service and sorts and filters extracted from Data API Get All request params, service, and optional build function.
@@ -17,9 +19,681 @@ function tableviewWithGetAllParams(model, service, params, buildFn) {
     return builder.build();
 }
 
+/**
+ * <em>Experimental:</em> Emulates an enum model object from enum schema.
+ *
+ * @experimental
+ *
+ * @param {SchemaEnum<Enum>} enumSchema - The schema of the enum.
+ *
+ * @returns {EnumDescriptor<Enum>} - The generated enum model descriptor.
+ */
+function enumModelFromSchema(enumSchema) {
+    const enumObj = {};
+    enumSchema.values
+        .map((v, idx) => ({ value: v, constant: enumSchema.constants[idx] }))
+        .forEach(({ value, constant }) => {
+        const valueAsStrOrInt = value;
+        enumObj[constant] = valueAsStrOrInt;
+        if (typeof valueAsStrOrInt === 'number' && enumObj[valueAsStrOrInt] == null)
+            enumObj[valueAsStrOrInt] = constant;
+    });
+    return enumModelGeneric(enumObj, enumSchema.name.replace(/\d+$/, ''));
+}
+
+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
+    };
+}
+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);
+    });
+}
+
+const defaultGetter = value => {
+    if (typeof value === 'object') {
+        const valueObj = value;
+        return (valueObj['title'] ??
+            valueObj['name'] ??
+            valueObj['naziv'] ??
+            valueObj['code'] ??
+            valueObj['sifra'] ??
+            valueObj['id'] ??
+            valueObj['uuid'] ??
+            valueObj[Object.keys(valueObj)[0]]);
+    }
+    else {
+        return value;
+    }
+};
+/**
+ * <em>Experimental:</em> Builder for adding columns to table.
+ *
+ * @experimental
+ */
+class SchemaColumnsBuilder {
+    constructor(descriptor, schema, opts) {
+        this.descriptor = descriptor;
+        this.schema = schema;
+        this.opts = opts;
+    }
+    mergeColumnsOpts(property, opts) {
+        return {
+            ...this.opts,
+            columnType: this.opts?.columnTypes?.[property],
+            getter: opts?.getters?.[property] ?? this.opts?.getters?.[property],
+            enumModel: opts?.enumModels?.[property] ?? this.opts?.enumModels?.[property],
+            enumSchema: opts?.enumSchemas?.[property] ?? this.opts?.enumSchemas?.[property],
+            ...opts
+        };
+    }
+    mergeColumnOpts(property, opts) {
+        return {
+            ...this.opts,
+            columnType: this.opts?.columnTypes?.[property],
+            getter: this.opts?.getters?.[property],
+            enumModel: this.opts?.enumModels?.[property],
+            enumSchema: this.opts?.enumSchemas?.[property],
+            ...opts
+        };
+    }
+    /**
+     * <em>Experimental:</em> Adds a single column via {addColumnFromSchema}.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to add the column for.
+     * @param {ColumnFromSchemaOptsType<SchModel[Property], SchModel, any, Model>} opts - Additional options.
+     *
+     * @return {ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]>} The added column descriptor.
+     */
+    add(property, opts) {
+        return addColumnFromSchema(this.descriptor, property, this.schema.properties[property], this.mergeColumnOpts(property, opts));
+    }
+    /**
+     * <em>Experimental:</em> Adds all columns from the non-array schema properties via {addColumnFromSchema}.
+     *
+     * @experimental
+     *
+     * @param {ColumnsFromSchemaOptsType<SchModel>} opts - Additional options.
+     *
+     * @return {this} - The current instance of the builder.
+     */
+    withAddAll(opts) {
+        this.addColumns(undefined, opts);
+        return this;
+    }
+    withAdd(propOrOpts, ...properties) {
+        if (typeof propOrOpts === 'object') {
+            this.addColumns(properties.length === 0 ? undefined : properties, propOrOpts);
+        }
+        else {
+            this.addColumns([propOrOpts, ...properties]);
+        }
+        return this;
+    }
+    /**
+     * <em>Experimental:</em> Adds a single column via {addColumnFromSchema} where property schema is manually provided.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to add the column for.
+     * @param {SchemaProperty} schemaProperty - Manually provided schema property.
+     * @param {ColumnFromSchemaOptsType} opts - Additional options.
+     *
+     * @return {ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]>} The added column descriptor.
+     */
+    addFromSchema(property, schemaProperty, opts) {
+        return addColumnFromSchema(this.descriptor, property, schemaProperty, this.mergeColumnOpts(property, opts));
+    }
+    addColumns(properties, opts) {
+        const addProperties = properties ?? fromSchemaFilterNonArrayProperties(this.schema.properties);
+        if (addProperties) {
+            addProperties.forEach(property => {
+                addColumnFromSchema(this.descriptor, property, this.schema.properties[property], this.mergeColumnsOpts(property, opts));
+            });
+        }
+    }
+}
+/**
+ * <em>Experimental:</em> Creates builder for adding columns to descriptor based on provided model schema.
+ *
+ * @experimental
+ *
+ * @param {TableviewDescriptorInst<Model, any, any, any> | TableDescriptorInst<Model, any, any>} descriptor - Descriptor to add columns to.
+ * @param {SchemaModel<SchModel>} schema - The schema with metadata about properties for fields.
+ * @param {ColumnsFromSchemaOptsType<SchModel>} [opts] - Additional options.
+ *
+ * @return {SchemaColumnsBuilder<Model, SchModel>} - The column schema builder instance.
+ */
+function columnsFromSchema(descriptor, schema, opts) {
+    return new SchemaColumnsBuilder(descriptor, schema, opts);
+}
+/**
+ * <em>Experimental:</em> Adds a column to table descriptor based on the given schema property and options.
+ *
+ * @param {TableviewDescriptorInst<Model, any, any, any> | TableDescriptorInst<Model, any, any>} descriptor - The table view descriptor or table descriptor to add the column to.
+ * @param {Property} property - The property key of the model to create the column for.
+ * @param {SchemaProperty} propertySchema - The schema property for the property.
+ * @param {ColumnFromSchemaOptsType<Model[Property], Model, any, Model>} [opts] - The options for the column.
+ *
+ * @return {ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]>} - The added column descriptor.
+ */
+function addColumnFromSchema(descriptor, property, propertySchema, opts) {
+    const propertyType = opts?.columnType ?? propertySchema?.type;
+    const column = descriptor.addColumn(property);
+    // Handle different property types
+    switch (propertyType) {
+        case 'number':
+            if (opts?.currency) {
+                column.asCurrency(fromSchemaCurrencyOptsToCurrency(opts.currency));
+            }
+            else {
+                column.asNumber();
+            }
+            break;
+        case 'boolean':
+            column.asBoolean(undefined, undefined, true);
+            break;
+        case 'date':
+            column.asDate(opts?.dateFormat ?? 'dd.MM.YYYY');
+            break;
+        case 'enum':
+            // eslint-disable-next-line no-case-declarations
+            const enumModel = opts?.enumSchema ? enumModelFromSchema(opts.enumSchema) : opts?.enumModel;
+            if (enumModel) {
+                column.asEnumUnsafe(enumModel);
+            }
+            break;
+        case 'date-time':
+            column.asDate(opts?.dateTimeFormat ?? 'dd.MM.YYYY HH:mm');
+            break;
+        case 'currency':
+            column.asCurrency(opts?.currency ? fromSchemaCurrencyOptsToCurrency(opts?.currency) : undefined);
+            break;
+        case 'object':
+            column.withGetter(defaultGetter);
+            break;
+    }
+    // Add optional filter, sort and getters
+    if (opts?.getter)
+        column.withGetter(opts?.getter);
+    return column;
+}
+
+/**
+ * <em>Experimental:</em> Builder for adding fields to editor.
+ *
+ * @experimental
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+function setFieldBasicOptionsFromSchema(field, propertySchema) {
+    if (propertySchema.required)
+        field.withRequired();
+    if (propertySchema.isReadOnly)
+        field.withDisabled();
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { tableviewWithGetAllParams };
+export { SchemaColumnsBuilder, SchemaFieldsBuilder, addColumnFromSchema, addFieldEnumLookupFromSchema, addFieldInputFromSchema, columnsFromSchema, enumModelFromSchema, fieldsFromSchema, setFieldBasicOptionsFromSchema, tableviewWithGetAllParams };
 //# sourceMappingURL=mediusinc-mng-commons-data-api-tableview.mjs.map