@sapui5/sap.fe.core 1.111.1 → 1.113.0

package/src/sap/fe/core/converters/controls/Common/Table.ts

@@ -5,16 +5,14 @@ import type {
 	PathAnnotationExpression,
 	Property,
 	PropertyAnnotationValue,
-	PropertyPath,
-	TypeDefinition
+	PropertyPath
 } from "@sap-ux/vocabularies-types";
 import type { FilterFunctions } from "@sap-ux/vocabularies-types/vocabularies/Capabilities";
-import type { EntitySetAnnotations_Capabilities } from "@sap-ux/vocabularies-types/vocabularies/Capabilities_Edm";
 import type { SemanticKey } from "@sap-ux/vocabularies-types/vocabularies/Common";
 import { CommonAnnotationTerms } from "@sap-ux/vocabularies-types/vocabularies/Common";
 import type { EntitySetAnnotations_Common } from "@sap-ux/vocabularies-types/vocabularies/Common_Edm";
 import type { EntitySetAnnotations_Session } from "@sap-ux/vocabularies-types/vocabularies/Session_Edm";
-import {
+import type {
 	CriticalityType,
 	DataField,
 	DataFieldAbstractTypes,
@@ -25,18 +23,17 @@ import {
 	DataFieldTypes,
 	DataPoint,
 	DataPointTypeTypes,
-	FieldGroupType,
+	FieldGroup,
 	LineItem,
 	PresentationVariantType,
 	SelectionVariantType,
-	SelectOptionType,
-	UIAnnotationTerms,
-	UIAnnotationTypes
+	SelectOptionType
 } from "@sap-ux/vocabularies-types/vocabularies/UI";
+import { UIAnnotationTerms, UIAnnotationTypes } from "@sap-ux/vocabularies-types/vocabularies/UI";
+import type { ComplexPropertyInfo } from "sap/fe/core/converters/annotations/DataField";
 import {
 	collectRelatedProperties,
 	collectRelatedPropertiesRecursively,
-	ComplexPropertyInfo,
 	getDataFieldDataType,
 	getSemanticObjectPath,
 	getTargetValueOnDataPoint,
@@ -44,15 +41,12 @@ import {
 	isDataFieldTypes,
 	isDataPointFromDataFieldDefault
 } from "sap/fe/core/converters/annotations/DataField";
+import type { BaseAction, CombinedAction, CustomAction, OverrideTypeAction } from "sap/fe/core/converters/controls/Common/Action";
 import {
-	BaseAction,
-	CombinedAction,
-	CustomAction,
 	dataFieldIsCopyAction,
 	getActionsFromManifest,
 	getCopyAction,
 	isActionNavigable,
-	OverrideTypeAction,
 	removeDuplicateActions
 } from "sap/fe/core/converters/controls/Common/Action";
 import { Entity, UI } from "sap/fe/core/converters/helpers/BindingHelper";
@@ -62,10 +56,9 @@ import { IssueCategory, IssueCategoryType, IssueSeverity, IssueType } from "sap/
 import { KeyHelper } from "sap/fe/core/converters/helpers/Key";
 import tableFormatters from "sap/fe/core/formatters/TableFormatter";
 import { MessageType } from "sap/fe/core/formatters/TableFormatterTypes";
+import type { BindingToolkitExpression, CompiledBindingToolkitExpression, PathInModelExpression } from "sap/fe/core/helpers/BindingToolkit";
 import {
 	and,
-	BindingToolkitExpression,
-	CompiledBindingToolkitExpression,
 	compileExpression,
 	constant,
 	EDM_TYPE_MAPPING,
@@ -81,6 +74,14 @@ import {
 } from "sap/fe/core/helpers/BindingToolkit";
 import ModelHelper from "sap/fe/core/helpers/ModelHelper";
 import { generate, replaceSpecialChars } from "sap/fe/core/helpers/StableIdHelper";
+import * as TypeGuards from "sap/fe/core/helpers/TypeGuards";
+import {
+	isAnnotationOfType,
+	isNavigationProperty,
+	isPathAnnotationExpression,
+	isProperty,
+	isTypeDefinition
+} from "sap/fe/core/helpers/TypeGuards";
 import type { DataModelObjectPath } from "sap/fe/core/templating/DataModelPathHelper";
 import {
 	enhanceDataModelPath,
@@ -94,13 +95,10 @@ import { getNonSortablePropertiesRestrictions } from "sap/fe/core/templating/Ent
 import {
 	getAssociatedCurrencyProperty,
 	getAssociatedTimezoneProperty,
-	getAssociatedUnitProperty,
-	isNavigationProperty,
-	isPathExpression,
-	isProperty
+	getAssociatedUnitProperty
 } from "sap/fe/core/templating/PropertyHelper";
 import { isMultiValueField } from "sap/fe/core/templating/UIFormatters";
-import { DefaultTypeForEdmType } from "sap/fe/core/type/EDM";
+import type { DefaultTypeForEdmType } from "sap/fe/core/type/EDM";
 import ActionHelper from "sap/fe/macros/internal/helpers/ActionHelper";
 import Core from "sap/ui/core/Core";
 import type ConverterContext from "../../ConverterContext";
@@ -108,6 +106,7 @@ import { AggregationHelper } from "../../helpers/Aggregation";
 import { isReferencePropertyStaticallyHidden } from "../../helpers/DataFieldHelper";
 import { getTableID } from "../../helpers/ID";
 import type {
+	AvailabilityType,
 	CustomDefinedTableColumn,
 	CustomDefinedTableColumnForOverride,
 	FormatOptionsType,
@@ -120,7 +119,6 @@ import type {
 } from "../../ManifestSettings";
 import {
 	ActionType,
-	AvailabilityType,
 	CreationMode,
 	HorizontalAlign,
 	Importance,
@@ -134,7 +132,6 @@ import { getMessageTypeFromCriticalityType } from "./Criticality";
 import type { StandardActionConfigType } from "./table/StandardActions";
 import {
 	generateStandardActionsContext,
-	getCreateVisibility,
 	getCreationRow,
 	getDeleteVisibility,
 	getInsertUpdateActionsTemplating,
@@ -148,6 +145,8 @@ import {
 	isInDisplayMode
 } from "./table/StandardActions";
 
+import { getEnabledForAnnotationAction } from "sap/fe/core/converters/controls/Common/Action";
+
 export type TableAnnotationConfiguration = {
 	autoBindOnInit: boolean;
 	collection: string;
@@ -179,7 +178,7 @@ export type TableAnnotationConfiguration = {
 
 	/** Create new entries */
 	create: CreateBehavior | CreateBehaviorExternal;
-	title: string;
+	title: string | undefined;
 	searchable: boolean;
 
 	inlineCreationRowsHiddenInEditMode?: boolean;
@@ -188,7 +187,7 @@ export type TableAnnotationConfiguration = {
 /**
  * New entries are created within the app (default case)
  */
-type CreateBehavior = {
+export type CreateBehavior = {
 	mode: CreationMode;
 	append: boolean;
 	newAction?: string;
@@ -198,7 +197,7 @@ type CreateBehavior = {
 /**
  * New entries are created by navigating to some target
  */
-type CreateBehaviorExternal = {
+export type CreateBehaviorExternal = {
 	mode: "External";
 	outbound: string;
 	outboundDetail: NavigationTargetConfiguration["outboundDetail"];
@@ -235,8 +234,8 @@ export type TableControlConfiguration = {
 	headerVisible: boolean;
 	filters?: Record<string, TableFiltersConfiguration>;
 	type: TableType;
-	rowCountMode: GridTableRowCountMode;
-	rowCount: number;
+	rowCountMode?: GridTableRowCountMode;
+	rowCount?: number;
 	selectAll?: boolean;
 	selectionLimit: number;
 	multiSelectMode: string | undefined;
@@ -307,7 +306,7 @@ export type AnnotationTableColumnForOverride = BaseTableColumn & {
 	formatOptions?: FormatOptionsType;
 };
 
-export type configTypeConstraints = Partial<{
+export type PropertyTypeConstraints = Partial<{
 	scale: number;
 	precision: number;
 	maxLength: number;
@@ -317,22 +316,22 @@ export type configTypeConstraints = Partial<{
 	isDigitSequence: boolean;
 }>;
 
-export type configTypeformatOptions = Partial<{
+export type PropertyTypeFormatOptions = Partial<{
 	parseAsString: boolean;
 	emptyString: string;
 	parseKeepsEmptyString: boolean;
 }>;
 
-export type configType = {
+export type PropertyTypeConfig = {
 	type?: string;
-	constraints: configTypeConstraints;
-	formatOptions: configTypeformatOptions;
-	typeInstance?: InstanceType<any>;
+	constraints: PropertyTypeConstraints;
+	formatOptions: PropertyTypeFormatOptions;
+	typeInstance?: unknown;
 	baseType?: string;
 	className?: keyof typeof DefaultTypeForEdmType;
 };
 
-export type exportSettings = Partial<{
+export type columnExportSettings = Partial<{
 	template: string;
 	label: string;
 	wrap: boolean;
@@ -368,14 +367,14 @@ export type AnnotationTableColumn = AnnotationTableColumnForOverride & {
 	timezone?: string;
 	semanticObjectPath?: string;
 	sortable: boolean;
-	exportSettings?: exportSettings | null;
+	exportSettings?: columnExportSettings | null;
 	textArrangement?: {
 		textProperty: string;
 		mode: DisplayMode;
 	};
 	additionalPropertyInfos?: string[];
 	visualSettings?: VisualSettings;
-	typeConfig?: configType;
+	typeConfig?: PropertyTypeConfig;
 	isPartOfLineItem?: boolean; // temporary indicator to only allow filtering on navigation properties when they're part of a line item
 	additionalLabels?: string[];
 	exportDataPointTargetValue?: string;
@@ -430,7 +429,7 @@ export type TableVisualization = {
 	commandActions?: Record<string, CustomAction>;
 	aggregates?: Record<string, AggregateData>;
 	enableAnalytics?: boolean;
-	enableAnalyticsSearch?: boolean;
+	enableBasicSearch?: boolean;
 	operationAvailableMap: string;
 	operationAvailableProperties: string;
 	headerInfoTitle: string;
@@ -634,7 +633,7 @@ export function updateTableVisualizationForType(
 			_updatePropertyInfosWithAggregatesDefinitions(tableVisualization);
 
 			const allowedTransformations = aggregationHelper.getAllowedTransformations();
-			tableVisualization.enableAnalyticsSearch = allowedTransformations ? allowedTransformations.indexOf("search") >= 0 : true;
+			tableVisualization.enableBasicSearch = allowedTransformations ? allowedTransformations.indexOf("search") >= 0 : true;
 
 			// Add group and sort conditions from the presentation variant
 			tableVisualization.annotation.groupConditions = getGroupConditions(
@@ -656,6 +655,9 @@ export function updateTableVisualizationForType(
 			tableVisualization.control.type
 		);
 	} else if (tableVisualization.control.type === "TreeTable") {
+		const aggregationHelper = new AggregationHelper(entityType, converterContext);
+		const allowedTransformations = aggregationHelper.getAllowedTransformations();
+		tableVisualization.enableBasicSearch = allowedTransformations ? allowedTransformations.includes("search") : true;
 		tableVisualization.enable$$getKeepAliveContext = false;
 	}
 }
@@ -726,7 +728,7 @@ export function updateLinkedProperties(entityType: EntityType, tableColumns: Tab
 
 				const displayMode = getDisplayMode(oProperty),
 					textAnnotation = oProperty.annotations.Common?.Text;
-				if (isPathExpression(textAnnotation) && displayMode !== "Value") {
+				if (isPathAnnotationExpression(textAnnotation) && displayMode !== "Value") {
 					const oTextColumn = findColumnByPath(textAnnotation.path);
 					if (oTextColumn && oTextColumn.name !== oTableColumn.name) {
 						oTableColumn.textArrangement = {
@@ -743,11 +745,11 @@ export function updateLinkedProperties(entityType: EntityType, tableColumns: Tab
 function getSemanticKeysAndTitleInfo(converterContext: ConverterContext) {
 	const headerInfoTitlePath = (converterContext.getAnnotationEntityType()?.annotations?.UI?.HeaderInfo?.Title as DataFieldTypes)?.Value
 		?.path;
-	const semanticKeyAnnotations: any[] | undefined = converterContext.getAnnotationEntityType()?.annotations?.Common?.SemanticKey;
+	const semanticKeyAnnotations = converterContext.getAnnotationEntityType()?.annotations?.Common?.SemanticKey;
 	const headerInfoTypeName = converterContext?.getAnnotationEntityType()?.annotations?.UI?.HeaderInfo?.TypeName;
 	const semanticKeyColumns: string[] = [];
 	if (semanticKeyAnnotations) {
-		semanticKeyAnnotations.forEach(function (oColumn: any) {
+		semanticKeyAnnotations.forEach(function (oColumn) {
 			semanticKeyColumns.push(oColumn.value);
 		});
 	}
@@ -845,7 +847,7 @@ export function createDefaultTableVisualization(converterContext: ConverterConte
  * @param converterContext The instance of the converter context
  * @returns The record containing all action names and their corresponding Core.OperationAvailable property paths
  */
-function getOperationAvailableMap(lineItemAnnotation: LineItem | undefined, converterContext: ConverterContext): Record<string, any> {
+function getOperationAvailableMap(lineItemAnnotation: LineItem | undefined, converterContext: ConverterContext): Record<string, unknown> {
 	return ActionHelper.getOperationAvailableMap(lineItemAnnotation, "table", converterContext);
 }
 
@@ -859,8 +861,9 @@ function getCurrentEntitySetUpdatablePath(converterContext: ConverterContext): s
 	const restrictions = getRestrictions(converterContext);
 	const entitySet = converterContext.getEntitySet();
 	const updatable = restrictions.isUpdatable;
-	const isOnlyDynamicOnCurrentEntity: any = !isConstant(updatable.expression) && updatable.navigationExpression._type === "Unresolvable";
-	const updatablePropertyPath = (entitySet?.annotations.Capabilities?.UpdateRestrictions?.Updatable as any)?.path;
+	const isOnlyDynamicOnCurrentEntity = !isConstant(updatable.expression) && updatable.navigationExpression._type === "Unresolvable";
+	const updatableExpression = entitySet?.annotations.Capabilities?.UpdateRestrictions?.Updatable;
+	const updatablePropertyPath = isPathAnnotationExpression(updatableExpression) && updatableExpression.path;
 
 	return isOnlyDynamicOnCurrentEntity ? (updatablePropertyPath as string) : "";
 }
@@ -872,7 +875,7 @@ function getCurrentEntitySetUpdatablePath(converterContext: ConverterContext): s
  * @param converterContext The instance of the converter context
  * @returns The CSV string of all property paths associated with the Core.OperationAvailable annotation
  */
-function getOperationAvailableProperties(operationAvailableMap: Record<string, any>, converterContext: ConverterContext): string {
+function getOperationAvailableProperties(operationAvailableMap: Record<string, unknown>, converterContext: ConverterContext): string {
 	const properties = new Set();
 
 	for (const actionName in operationAvailableMap) {
@@ -949,8 +952,8 @@ function getBindingExpFromContext(
 	source: DataFieldForAction | DataFieldForIntentBasedNavigation | CustomAction,
 	contextDataModelObjectPath: DataModelObjectPath,
 	isEntitySet: boolean
-): BindingToolkitExpression<any> {
-	let sExpression: any | undefined;
+): BindingToolkitExpression<unknown> {
+	let sExpression;
 	if (
 		(source as DataFieldForAction)?.$Type === UIAnnotationTypes.DataFieldForAction ||
 		(source as DataFieldForIntentBasedNavigation)?.$Type === UIAnnotationTypes.DataFieldForIntentBasedNavigation
@@ -960,10 +963,10 @@ function getBindingExpFromContext(
 		sExpression = (source as CustomAction)?.visible;
 	}
 	let sPath: string;
-	if (sExpression?.path) {
+	if (isPathAnnotationExpression(sExpression)) {
 		sPath = sExpression.path;
 	} else {
-		sPath = sExpression;
+		sPath = sExpression as string;
 	}
 	if (sPath) {
 		if ((source as CustomAction)?.visible) {
@@ -974,7 +977,7 @@ function getBindingExpFromContext(
 			const aSplitPath = sPath.split("/");
 			const sNavigationPath = aSplitPath[0];
 			if (
-				contextDataModelObjectPath?.targetObject?._type === "NavigationProperty" &&
+				isNavigationProperty(contextDataModelObjectPath?.targetObject) &&
 				contextDataModelObjectPath.targetObject.partner === sNavigationPath
 			) {
 				return pathInModel(aSplitPath.slice(1).join("/"));
@@ -1289,6 +1292,8 @@ function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPa
 		}) as DataFieldForActionTypes[]
 	);
 
+	const sEntityType = converterContext.getEntityType().fullyQualifiedName;
+
 	if (copyDataField) {
 		tableActions.push({
 			type: ActionType.Copy,
@@ -1330,7 +1335,26 @@ function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPa
 			) {
 				switch (dataField.$Type) {
 					case UIAnnotationTypes.DataFieldForAction:
-						tableActions.push({
+						// There are three cases when a table action has an OperationAvailable that leads to an enablement expression
+						// and is not dependent upon the table entries.
+						// 1. An action with an overload, that is executed against a parent entity.
+						// 2. An unbound action
+						// 3. A static action (that is, bound to a collection)
+						let useEnabledExpression = false;
+						if (dataField.ActionTarget?.annotations?.Core?.OperationAvailable !== undefined) {
+							if (!dataField.ActionTarget?.isBound) {
+								// Unbound action. Is recognised, but getExpressionFromAnnotation checks for isBound = true, so not generated.
+								useEnabledExpression = true;
+							} else if (dataField.ActionTarget?.isBound && dataField.ActionTarget?.sourceType !== sEntityType) {
+								// Overload action
+								useEnabledExpression = true;
+							} else if (dataField.ActionTarget?.parameters[0].isCollection) {
+								// Static action
+								useEnabledExpression = true;
+							}
+						}
+
+						const tableAction: BaseAction = {
 							type: ActionType.DataFieldForAction,
 							annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
 							key: KeyHelper.generateKeyFromDataField(dataField),
@@ -1348,7 +1372,12 @@ function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPa
 								)
 							),
 							isNavigable: true
-						});
+						};
+
+						if (useEnabledExpression) {
+							tableAction.enabled = getEnabledForAnnotationAction(converterContext, dataField.ActionTarget);
+						}
+						tableActions.push(tableAction);
 						break;
 
 					case UIAnnotationTypes.DataFieldForIntentBasedNavigation:
@@ -1383,9 +1412,18 @@ function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPa
 	};
 }
 
+/**
+ * Generate the bindingExpression for the highlight rowSetting parameter.
+ *
+ * @param criticalityAnnotation Path or value of the criticality
+ * @param isDraftRootOrNode  Is the current entitySet an Draft root or a node
+ * @param targetEntityType The targeted entityType
+ * @returns An expressionBinding
+ * @private
+ */
 function getHighlightRowBinding(
 	criticalityAnnotation: PathAnnotationExpression<CriticalityType> | EnumValue<CriticalityType> | undefined,
-	isDraftRoot: boolean,
+	isDraftRootOrNode: boolean,
 	targetEntityType?: EntityType
 ): BindingToolkitExpression<MessageType> {
 	let defaultHighlightRowDefinition: MessageType | BindingToolkitExpression<MessageType> = MessageType.None;
@@ -1398,8 +1436,8 @@ function getHighlightRowBinding(
 		}
 	}
 
-	const aMissingKeys: any[] = [];
-	targetEntityType?.keys.forEach((key: any) => {
+	const aMissingKeys: PathInModelExpression<string>[] = [];
+	targetEntityType?.keys.forEach((key) => {
 		if (key.name !== "IsActiveEntity") {
 			aMissingKeys.push(pathInModel(key.name, undefined));
 		}
@@ -1409,9 +1447,9 @@ function getHighlightRowBinding(
 		[
 			defaultHighlightRowDefinition,
 			pathInModel(`filteredMessages`, "internal"),
-			isDraftRoot && Entity.HasActive,
-			isDraftRoot && Entity.IsActive,
-			`${isDraftRoot}`,
+			isDraftRootOrNode && Entity.HasActive,
+			isDraftRootOrNode && Entity.IsActive,
+			`${isDraftRootOrNode}`,
 			...aMissingKeys
 		],
 		tableFormatters.rowHighlighting,
@@ -1496,12 +1534,12 @@ const _getRowConfigurationProperty = function (
 		} else if (targetEntityType) {
 			const targetEntitySet = converterContext.getEntitySet();
 			navigationTarget = navigationSettings.detail?.route;
-			if (navigationTarget && !ModelHelper.isSingleton(targetEntitySet)) {
-				criticalityProperty = getHighlightRowBinding(
-					lineItemAnnotation.annotations?.UI?.Criticality,
-					!!ModelHelper.getDraftRoot(targetEntitySet) || !!ModelHelper.getDraftNode(targetEntitySet),
-					targetEntityType
-				);
+			criticalityProperty = getHighlightRowBinding(
+				lineItemAnnotation.annotations?.UI?.Criticality,
+				!!ModelHelper.getDraftRoot(targetEntitySet) || !!ModelHelper.getDraftNode(targetEntitySet),
+				targetEntityType
+			);
+			if (navigationTarget && TypeGuards.isEntitySet(targetEntitySet)) {
 				pressProperty =
 					"API.onTableRowPress($event, $controller, ${$parameters>bindingContext}, { callExtension: true, targetPath: '" +
 					targetPath +
@@ -1511,8 +1549,6 @@ const _getRowConfigurationProperty = function (
 						: "undefined") +
 					(tableType === "AnalyticalTable" || tableType === "TreeTable" ? ", bRecreateContext: true" : "") +
 					"})"; //Need to access to DraftRoot and DraftNode !!!!!!!
-			} else {
-				criticalityProperty = getHighlightRowBinding(lineItemAnnotation.annotations?.UI?.Criticality, false, targetEntityType);
 			}
 		}
 	}
@@ -1719,7 +1755,7 @@ const getColumnDefinitionFromProperty = function (
 		formatOptions: propertyTypeConfig.formatOptions,
 		constraints: propertyTypeConfig.constraints
 	};
-	let exportSettings: exportSettings | null = null;
+	let exportSettings: columnExportSettings | null = null;
 	if (_isExportableColumn(property)) {
 		const unitProperty = getAssociatedCurrencyProperty(property) || getAssociatedUnitProperty(property);
 		const timezoneProperty = getAssociatedTimezoneProperty(property);
@@ -1757,7 +1793,7 @@ const getColumnDefinitionFromProperty = function (
 		group: isGroup ? groupPath : undefined,
 		annotationPath: fullPropertyPath,
 		semanticObjectPath: semanticObjectAnnotationPath,
-		availability: !availableForAdaptation || isHidden ? AvailabilityType.Hidden : AvailabilityType.Adaptation,
+		availability: !availableForAdaptation || isHidden ? "Hidden" : "Adaptation",
 		name: name,
 		relativePath: relativePath,
 		sortable: sortable,
@@ -1765,8 +1801,8 @@ const getColumnDefinitionFromProperty = function (
 		isKey: property.isKey,
 		exportSettings: exportSettings,
 		caseSensitive: isFilteringCaseSensitive(converterContext),
-		typeConfig: typeConfig as configType,
-		importance: getImportance((property as any).annotations?.UI?.DataFieldDefault, semanticKeys),
+		typeConfig: typeConfig as PropertyTypeConfig,
+		importance: getImportance(property.annotations?.UI?.DataFieldDefault, semanticKeys),
 		additionalLabels: collectedNavigationPropertyLabels
 	};
 	const sTooltip = _getTooltip(property);
@@ -1853,14 +1889,9 @@ const _isValidColumn = function (dataField: DataFieldAbstractTypes) {
  * SAP Fiori elements will evaluate either the UI.Hidden annotation defined on the annotation itself or on the target property.
  *
  * @param dataFieldModelPath The metapath referring to the annotation that is evaluated by SAP Fiori elements.
- * @param [formatOptions] FormatOptions optional.
- * @param formatOptions.isAnalytics This flag is used to check if the analytic table has GroupHeader expanded.
  * @returns An expression that you can bind to the UI.
  */
-export const _getVisibleExpression = function (
-	dataFieldModelPath: DataModelObjectPath,
-	formatOptions?: any
-): BindingToolkitExpression<any> {
+export const _getVisibleExpression = function (dataFieldModelPath: DataModelObjectPath): BindingToolkitExpression<boolean> {
 	const targetObject: DataFieldAbstractTypes | DataPointTypeTypes = dataFieldModelPath.targetObject;
 	let propertyValue;
 	if (targetObject) {
@@ -1885,8 +1916,9 @@ export const _getVisibleExpression = function (
 				propertyValue = undefined;
 		}
 	}
-	const isAnalyticalGroupHeaderExpanded = formatOptions?.isAnalytics ? UI.IsExpanded : constant(false);
-	const isAnalyticalLeaf = formatOptions?.isAnalytics ? equal(UI.NodeLevel, 0) : constant(false);
+	// FIXME Prove me wrong that this is useless
+	const isAnalyticalGroupHeaderExpanded = /*formatOptions?.isAnalytics ? UI.IsExpanded :*/ constant(false);
+	const isAnalyticalLeaf = /*formatOptions?.isAnalytics ? equal(UI.NodeLevel, 0) :*/ constant(false);
 
 	// A data field is visible if:
 	// - the UI.Hidden expression in the original annotation does not evaluate to 'true'
@@ -1909,15 +1941,11 @@ export const _getVisibleExpression = function (
  * Returns hidden binding expressions for a field group.
  *
  * @param dataFieldGroup DataField defined in the annotations
- * @param fieldFormatOptions FormatOptions optional.
  * @returns Compile binding of field group expressions.
  * @private
  */
-const _getFieldGroupHiddenExpressions = function (
-	dataFieldGroup: DataFieldAbstractTypes,
-	fieldFormatOptions: any
-): CompiledBindingToolkitExpression | undefined {
-	const fieldGroupHiddenExpressions: BindingToolkitExpression<any>[] = [];
+const _getFieldGroupHiddenExpressions = function (dataFieldGroup: DataFieldAbstractTypes): CompiledBindingToolkitExpression | undefined {
+	const fieldGroupHiddenExpressions: BindingToolkitExpression<boolean>[] = [];
 	if (
 		dataFieldGroup.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
 		dataFieldGroup.Target?.$target?.$Type === UIAnnotationTypes.FieldGroupType
@@ -1926,9 +1954,7 @@ const _getFieldGroupHiddenExpressions = function (
 			return compileExpression(not(equal(getExpressionFromAnnotation(dataFieldGroup.annotations.UI.Hidden), true)));
 		} else {
 			dataFieldGroup.Target.$target.Data?.forEach((innerDataField: DataFieldAbstractTypes | DataPointTypeTypes) => {
-				fieldGroupHiddenExpressions.push(
-					_getVisibleExpression({ targetObject: innerDataField } as DataModelObjectPath, fieldFormatOptions)
-				);
+				fieldGroupHiddenExpressions.push(_getVisibleExpression({ targetObject: innerDataField } as DataModelObjectPath));
 			});
 			return compileExpression(ifElse(or(...fieldGroupHiddenExpressions), constant(true), constant(false)));
 		}
@@ -2041,19 +2067,21 @@ const _createRelatedColumns = function (
 		if (relatedColumn === undefined) {
 			// Case 1: Key contains DataField prefix to ensure all property columns have the same key format.
 			// New created property column is set to hidden.
-			relatedColumns.push(
-				getColumnDefinitionFromProperty(
-					property,
-					annotationPath,
-					name,
-					true,
-					false,
-					nonSortableColumns,
-					aggregationHelper,
-					converterContext,
-					textOnlyColumnsFromTextAnnotation
-				)
+			const column = getColumnDefinitionFromProperty(
+				property,
+				annotationPath,
+				name,
+				true,
+				false,
+				nonSortableColumns,
+				aggregationHelper,
+				converterContext,
+				textOnlyColumnsFromTextAnnotation
+			);
+			column.isPartOfLineItem = existingColumns.some(
+				(existingColumn) => existingColumn.propertyInfos?.includes(name) && existingColumn.isPartOfLineItem
 			);
+			relatedColumns.push(column);
 		} else if (relatedColumn.annotationPath !== annotationPath || relatedColumn.propertyInfos) {
 			// Case 2: The existing column points to a LineItem (or)
 			// Case 3: This is a self reference from an existing column
@@ -2144,7 +2172,7 @@ const createTechnicalProperty = function (name: string, columns: TableColumn[],
 			type: ColumnType.Annotation,
 			label: additionalProperty.label,
 			annotationPath: additionalProperty.annotationPath,
-			availability: AvailabilityType.Hidden,
+			availability: "Hidden",
 			name: key,
 			relativePath: additionalProperty.relativePath,
 			sortable: false,
@@ -2190,7 +2218,7 @@ const _getShowDataFieldsLabel = function (fieldGroupName: string, visualizationP
  * @returns The relative path
  */
 const _getRelativePath = function (dataField: DataFieldAbstractTypes): string {
-	let relativePath: string = "";
+	let relativePath = "";
 
 	switch (dataField.$Type) {
 		case UIAnnotationTypes.DataField:
@@ -2233,7 +2261,7 @@ const _sliceAtSlash = function (path: string, isLastSlash: boolean, isLastPart:
  * @returns True if the DataField corresponds to a multi-value field.
  */
 const _isColumnMultiValued = function (dataField: DataFieldAbstractTypes, converterContext: ConverterContext): boolean {
-	if (isDataFieldTypes(dataField) && isPathExpression(dataField.Value)) {
+	if (isDataFieldTypes(dataField) && isPathAnnotationExpression(dataField.Value)) {
 		const propertyObjectPath = enhanceDataModelPath(converterContext.getDataModelObjectPath(), dataField.Value.path);
 		return isMultiValueField(propertyObjectPath);
 	} else {
@@ -2271,11 +2299,14 @@ export const isFilteringCaseSensitive = function (converterContext: ConverterCon
 };
 
 function _getFilterFunctions(ConverterContext: ConverterContext): FilterFunctions | undefined {
-	if (ModelHelper.isSingleton(ConverterContext.getEntitySet())) {
-		return undefined;
+	const entitySet = ConverterContext.getEntitySet();
+	if (TypeGuards.isEntitySet(entitySet)) {
+		return (
+			entitySet.annotations.Capabilities?.FilterFunctions ??
+			ConverterContext.getEntityContainer().annotations.Capabilities?.FilterFunctions
+		);
 	}
-	const capabilities = ConverterContext.getEntitySet()?.annotations?.Capabilities as EntitySetAnnotations_Capabilities;
-	return capabilities?.FilterFunctions || ConverterContext.getEntityContainer()?.annotations?.Capabilities?.FilterFunctions;
+	return undefined;
 }
 
 /**
@@ -2293,7 +2324,7 @@ function _getDefaultFormatOptionsForTable(formatOptions: FormatOptionsType | und
 		  };
 }
 
-function _findSemanticKeyValues(semanticKeys: any[], name: string): any {
+function _findSemanticKeyValues(semanticKeys: SemanticKey, name: string) {
 	const aSemanticKeyValues: string[] = [];
 	let bSemanticKeyFound = false;
 	for (let i = 0; i < semanticKeys.length; i++) {
@@ -2308,7 +2339,7 @@ function _findSemanticKeyValues(semanticKeys: any[], name: string): any {
 	};
 }
 
-function _findProperties(semanticKeyValues: any[], fieldGroupProperties: any[]) {
+function _findProperties(semanticKeyValues: string[], fieldGroupProperties: string[]) {
 	let semanticKeyHasPropertyInFieldGroup = false;
 	let sPropertyPath;
 	if (semanticKeyValues && semanticKeyValues.length >= 1 && fieldGroupProperties && fieldGroupProperties.length >= 1) {
@@ -2326,9 +2357,9 @@ function _findProperties(semanticKeyValues: any[], fieldGroupProperties: any[])
 	};
 }
 
-function _findSemanticKeyValuesInFieldGroup(dataFieldGroup: DataFieldAbstractTypes | null, semanticKeyValues: []): any {
-	const aProperties: any[] = [];
-	let _propertiesFound: { semanticKeyHasPropertyInFieldGroup: boolean; fieldGroupPropertyPath: any } = {
+function _findSemanticKeyValuesInFieldGroup(dataFieldGroup: DataFieldAbstractTypes | null, semanticKeyValues: string[]) {
+	const aProperties: string[] = [];
+	let _propertiesFound: { semanticKeyHasPropertyInFieldGroup: boolean; fieldGroupPropertyPath?: string } = {
 		semanticKeyHasPropertyInFieldGroup: false,
 		fieldGroupPropertyPath: undefined
 	};
@@ -2364,7 +2395,7 @@ function _findSemanticKeyValuesInFieldGroup(dataFieldGroup: DataFieldAbstractTyp
  */
 function getDefaultDraftIndicatorForColumn(
 	name: string,
-	semanticKeys: any[],
+	semanticKeys: SemanticKey,
 	isFieldGroupColumn: boolean,
 	dataFieldGroup: DataFieldAbstractTypes | null
 ) {
@@ -2374,14 +2405,14 @@ function getDefaultDraftIndicatorForColumn(
 	const semanticKey = _findSemanticKeyValues(semanticKeys, name);
 	const semanticKeyInFieldGroup = _findSemanticKeyValuesInFieldGroup(dataFieldGroup, semanticKey.values);
 	if (semanticKey.semanticKeyFound) {
-		const formatOptionsObj: any = {
+		const formatOptionsObj: FormatOptionsType = {
 			hasDraftIndicator: true,
 			semantickeys: semanticKey.values,
-			objectStatusTextVisibility: compileExpression(getRowStatusVisibility(name, false))
+			showErrorObjectStatus: compileExpression(getRowStatusVisibility(name, false))
 		};
 		if (isFieldGroupColumn && semanticKeyInFieldGroup.semanticKeyHasPropertyInFieldGroup) {
-			formatOptionsObj["objectStatusTextVisibility"] = compileExpression(getRowStatusVisibility(name, true));
-			formatOptionsObj["fieldGroupDraftIndicatorPropertyPath"] = semanticKeyInFieldGroup.propertyPath;
+			formatOptionsObj.showErrorObjectStatus = compileExpression(getRowStatusVisibility(name, true));
+			formatOptionsObj.fieldGroupDraftIndicatorPropertyPath = semanticKeyInFieldGroup.propertyPath;
 		}
 		return formatOptionsObj;
 	} else if (!semanticKeyInFieldGroup.semanticKeyHasPropertyInFieldGroup) {
@@ -2391,7 +2422,7 @@ function getDefaultDraftIndicatorForColumn(
 		return {
 			fieldGroupDraftIndicatorPropertyPath: semanticKeyInFieldGroup.propertyPath,
 			fieldGroupName: name,
-			objectStatusTextVisibility: compileExpression(getRowStatusVisibility(name, true))
+			showErrorObjectStatus: compileExpression(getRowStatusVisibility(name, true))
 		};
 	}
 }
@@ -2440,9 +2471,10 @@ function _getMaxImportance(fields: DataFieldTypes[]): Importance {
  * @param semanticKeys
  * @returns The importance value
  */
-export function getImportance(dataField: DataFieldAbstractTypes, semanticKeys: SemanticKey): Importance | undefined {
+export function getImportance(dataField: DataFieldAbstractTypes | undefined, semanticKeys: SemanticKey): Importance | undefined {
 	//Evaluate default Importance is not set explicitly
-	let fieldsWithImportance, mapSemanticKeys: any;
+	let fieldsWithImportance,
+		mapSemanticKeys: string[] = [];
 	//Check if semanticKeys are defined at the EntitySet level
 	if (semanticKeys && semanticKeys.length > 0) {
 		mapSemanticKeys = semanticKeys.map(function (key) {
@@ -2452,39 +2484,42 @@ export function getImportance(dataField: DataFieldAbstractTypes, semanticKeys: S
 	if (!dataField) {
 		return undefined;
 	}
-	if (dataField.$Type === UIAnnotationTypes.DataFieldForAnnotation) {
-		const fieldGroupData = (dataField as any).Target["$target"]["Data"] as FieldGroupType,
-			fieldGroupHasSemanticKey =
+
+	if (isAnnotationOfType<DataFieldForAnnotation>(dataField, UIAnnotationTypes.DataFieldForAnnotation)) {
+		const dataFieldTarget = dataField.Target.$target;
+		if (isAnnotationOfType<FieldGroup>(dataFieldTarget, UIAnnotationTypes.FieldGroupType)) {
+			const fieldGroupData = dataFieldTarget.Data;
+			const fieldGroupHasSemanticKey =
 				fieldGroupData &&
-				(fieldGroupData as any).some(function (fieldGroupDataField: DataFieldAbstractTypes) {
+				fieldGroupData.some(function (fieldGroupDataField: DataFieldAbstractTypes) {
 					return (
 						(fieldGroupDataField as unknown as DataFieldTypes)?.Value?.path &&
 						fieldGroupDataField.$Type !== UIAnnotationTypes.DataFieldForAnnotation &&
-						mapSemanticKeys &&
 						mapSemanticKeys.includes((fieldGroupDataField as unknown as DataFieldTypes)?.Value?.path)
 					);
 				});
-		//If a FieldGroup contains a semanticKey, importance set to High
-		if (fieldGroupHasSemanticKey) {
-			return Importance.High;
-		} else {
-			//If the DataFieldForAnnotation has an Importance we take it
-			if (dataField?.annotations?.UI?.Importance) {
-				return _getDataFieldImportance(dataField as unknown as DataFieldTypes);
+			//If a FieldGroup contains a semanticKey, importance set to High
+			if (fieldGroupHasSemanticKey) {
+				return Importance.High;
+			} else {
+				//If the DataFieldForAnnotation has an Importance we take it
+				if (dataField?.annotations?.UI?.Importance) {
+					return _getDataFieldImportance(dataField as unknown as DataFieldTypes);
+				}
+				// else the highest importance (if any) is returned
+				fieldsWithImportance =
+					fieldGroupData &&
+					fieldGroupData.filter(function (item) {
+						return item?.annotations?.UI?.Importance;
+					});
+				return _getMaxImportance(fieldsWithImportance as DataFieldTypes[]);
 			}
-			// else the highest importance (if any) is returned
-			fieldsWithImportance =
-				fieldGroupData &&
-				(fieldGroupData as any).filter(function (item: DataFieldTypes) {
-					return item?.annotations?.UI?.Importance;
-				});
-			return _getMaxImportance(fieldsWithImportance as DataFieldTypes[]);
+			//If the current field is a semanticKey, importance set to High
 		}
-		//If the current field is a semanticKey, importance set to High
 	}
+
 	return (dataField as DataFieldTypes).Value &&
 		(dataField as DataFieldTypes)?.Value?.path &&
-		mapSemanticKeys &&
 		mapSemanticKeys.includes((dataField as DataFieldTypes).Value.path)
 		? Importance.High
 		: _getDataFieldImportance(dataField as unknown as DataFieldTypes);
@@ -2522,7 +2557,7 @@ const getColumnsFromAnnotations = function (
 			if (!_isValidColumn(lineItem)) {
 				return;
 			}
-			let exportSettings: exportSettings | null = null;
+			let exportSettings: columnExportSettings | null = null;
 			const semanticObjectAnnotationPath =
 				isDataFieldTypes(lineItem) && lineItem.Value?.$target?.fullyQualifiedName
 					? getSemanticObjectPath(converterContext, lineItem)
@@ -2551,7 +2586,7 @@ const getColumnsFromAnnotations = function (
 				lineItem.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
 				lineItem.Target?.$target?.$Type === UIAnnotationTypes.FieldGroupType
 			) {
-				fieldGroupHiddenExpressions = _getFieldGroupHiddenExpressions(lineItem, formatOptions);
+				fieldGroupHiddenExpressions = _getFieldGroupHiddenExpressions(lineItem);
 			}
 			if (_isExportableColumn(lineItem)) {
 				//exclude the types listed above for the Export (generates error on Export as PDF)
@@ -2576,14 +2611,17 @@ const getColumnsFromAnnotations = function (
 				}
 			}
 
-			const propertyTypeConfig = dataType && getTypeConfig(lineItem, dataType);
-			const typeConfig: configType = {
+			let propertyTypeConfig: PropertyTypeConfig | undefined;
+			if (dataType) {
+				propertyTypeConfig = getTypeConfig(lineItem, dataType);
+			}
+			const typeConfig: PropertyTypeConfig = {
 				className: dataType as keyof typeof DefaultTypeForEdmType,
 				formatOptions: {
 					...formatOptions,
 					...propertyTypeConfig?.formatOptions
 				},
-				constraints: propertyTypeConfig?.constraints
+				constraints: { ...propertyTypeConfig?.constraints }
 			};
 			const visualSettings: VisualSettings = {};
 			if (!dataType || !typeConfig) {
@@ -2601,7 +2639,7 @@ const getColumnsFromAnnotations = function (
 				FieldGroupHiddenExpressions: fieldGroupHiddenExpressions,
 				annotationPath: converterContext.getEntitySetBasedAnnotationPath(lineItem.fullyQualifiedName),
 				semanticObjectPath: semanticObjectAnnotationPath,
-				availability: isReferencePropertyStaticallyHidden(lineItem) ? AvailabilityType.Hidden : AvailabilityType.Default,
+				availability: isReferencePropertyStaticallyHidden(lineItem) ? "Hidden" : "Default",
 				name: name,
 				showDataFieldsLabel: showDataFieldsLabel,
 				relativePath: relativePath,
@@ -2742,11 +2780,11 @@ const getColumnsFromManifest = function (
 		return annotationColumns.some((annotationColumn) => annotationColumn.key === key);
 	}
 
-	function isSlotColumn(manifestColumn: any): manifestColumn is FragmentDefinedSlotColumn {
+	function isSlotColumn(manifestColumn: CustomDefinedTableColumn): manifestColumn is FragmentDefinedSlotColumn {
 		return manifestColumn.type === ColumnType.Slot;
 	}
 
-	function isCustomColumn(manifestColumn: any): manifestColumn is ManifestDefinedCustomColumn {
+	function isCustomColumn(manifestColumn: CustomDefinedTableColumn): manifestColumn is ManifestDefinedCustomColumn {
 		return manifestColumn.type === undefined && !!manifestColumn.template;
 	}
 
@@ -2803,7 +2841,7 @@ const getColumnsFromManifest = function (
 				header: manifestColumn.header,
 				importance: manifestColumn?.importance || Importance.None,
 				horizontalAlign: manifestColumn?.horizontalAlign || HorizontalAlign.Begin,
-				availability: manifestColumn?.availability || AvailabilityType.Default,
+				availability: manifestColumn?.availability || "Default",
 				template: manifestColumn.template,
 				propertyInfos: propertyInfos,
 				exportSettings: propertyInfos
@@ -2868,7 +2906,7 @@ export function getP13nMode(
 	const isResponsiveTable = tableManifestConfiguration.type === "ResponsiveTable";
 	if (tableManifestSettings?.tableSettings?.personalization !== undefined) {
 		// Personalization configured in manifest.
-		const personalization: any = tableManifestSettings.tableSettings.personalization;
+		const personalization = tableManifestSettings.tableSettings.personalization;
 		if (personalization === true) {
 			// Table personalization fully enabled.
 			switch (tableManifestConfiguration.type) {
@@ -3117,7 +3155,8 @@ export function getTableAnnotationConfiguration(
 ): TableAnnotationConfiguration {
 	// Need to get the target
 	const { navigationPropertyPath } = splitPath(visualizationPath);
-	const title: any = converterContext.getDataModelObjectPath().targetEntityType.annotations?.UI?.HeaderInfo?.TypeNamePlural;
+	const typeNamePlural = converterContext.getDataModelObjectPath().targetEntityType.annotations?.UI?.HeaderInfo?.TypeNamePlural;
+	const title = typeNamePlural && compileExpression(getExpressionFromAnnotation(typeNamePlural));
 	const entitySet = converterContext.getDataModelObjectPath().targetEntitySet;
 	const pageManifestSettings: ManifestWrapper = converterContext.getManifestWrapper();
 	const hasAbsolutePath = navigationPropertyPath.length === 0,
@@ -3141,13 +3180,8 @@ export function getTableAnnotationConfiguration(
 	);
 
 	const deleteButtonVisibilityExpression = getDeleteVisibility(converterContext, standardActionsContext);
-	const createButtonVisibilityExpression = getCreateVisibility(converterContext, standardActionsContext);
 	const massEditButtonVisibilityExpression = getMassEditVisibility(converterContext, standardActionsContext);
-	const isInsertUpdateTemplated = getInsertUpdateActionsTemplating(
-		standardActionsContext,
-		isDraftOrStickySupported(converterContext),
-		compileExpression(createButtonVisibilityExpression) === "false"
-	);
+	const isInsertUpdateTemplated = getInsertUpdateActionsTemplating(standardActionsContext, isDraftOrStickySupported(converterContext));
 
 	const selectionMode = getSelectionMode(
 		lineItemAnnotation,
@@ -3208,8 +3242,8 @@ export function getTableAnnotationConfiguration(
 	};
 }
 
-function _getExportDataType(dataType: string, isComplexProperty: boolean = false): string {
-	let exportDataType: string = "String";
+function _getExportDataType(dataType: string, isComplexProperty = false): string {
+	let exportDataType = "String";
 	if (isComplexProperty) {
 		if (dataType === "Edm.DateTimeOffset") {
 			exportDataType = "DateTime";
@@ -3251,8 +3285,8 @@ function _getExportDataType(dataType: string, isComplexProperty: boolean = false
  * @returns The split path
  */
 export function splitPath(visualizationPath: string) {
-	let [navigationPropertyPath, annotationPath] = visualizationPath.split("@");
-
+	const [targetNavigationPropertyPath, annotationPath] = visualizationPath.split("@");
+	let navigationPropertyPath = targetNavigationPropertyPath;
 	if (navigationPropertyPath.lastIndexOf("/") === navigationPropertyPath.length - 1) {
 		// Drop trailing slash
 		navigationPropertyPath = navigationPropertyPath.substr(0, navigationPropertyPath.length - 1);
@@ -3270,8 +3304,8 @@ export function getSelectionVariantConfiguration(
 	if (selection) {
 		const propertyNames: string[] = [];
 		selection.SelectOptions?.forEach((selectOption: SelectOptionType) => {
-			const propertyName: any = selectOption.PropertyName;
-			const propertyPath: string = propertyName.value;
+			const propertyName = selectOption.PropertyName;
+			const propertyPath: string = propertyName?.value ?? "";
 			if (propertyNames.indexOf(propertyPath) === -1) {
 				propertyNames.push(propertyPath);
 			}
@@ -3340,16 +3374,20 @@ function _getTableType(
 	return tableType;
 }
 
-function _getGridTableMode(tableType: TableType, tableSettings: TableManifestSettingsConfiguration, isTemplateListReport: boolean): any {
+function _getGridTableMode(
+	tableType: TableType,
+	tableSettings: TableManifestSettingsConfiguration,
+	isTemplateListReport: boolean
+): { rowCountMode?: GridTableRowCountMode; rowCount?: number } {
 	if (tableType === "GridTable") {
 		if (isTemplateListReport) {
 			return {
 				rowCountMode: "Auto",
-				rowCount: "3"
+				rowCount: 3
 			};
 		} else {
 			return {
-				rowCountMode: tableSettings.rowCountMode ? tableSettings.rowCountMode : "Fixed",
+				rowCountMode: tableSettings.rowCountMode ?? "Fixed",
 				rowCount: tableSettings.rowCount ? tableSettings.rowCount : 5
 			};
 		}
@@ -3375,10 +3413,10 @@ function _getTableInlineCreationRowCount(_tableSettings: TableManifestSettingsCo
 function _getFilters(
 	tableSettings: TableManifestSettingsConfiguration,
 	quickFilterPaths: { annotationPath: string }[],
-	quickSelectionVariant: any,
+	quickSelectionVariant: unknown,
 	path: { annotationPath: string },
 	converterContext: ConverterContext
-): any {
+) {
 	if (quickSelectionVariant) {
 		quickFilterPaths.push({ annotationPath: path.annotationPath });
 	}
@@ -3405,13 +3443,13 @@ function _getFilterConfiguration(
 	tableSettings: TableManifestSettingsConfiguration,
 	lineItemAnnotation: LineItem | undefined,
 	converterContext: ConverterContext
-): any {
+) {
 	if (!lineItemAnnotation) {
 		return {};
 	}
 	const quickFilterPaths: { annotationPath: string }[] = [];
 	const targetEntityType = converterContext.getAnnotationEntityType(lineItemAnnotation);
-	let quickSelectionVariant: any;
+	let quickSelectionVariant;
 	let filters;
 	tableSettings?.quickVariantSelection?.paths?.forEach((path: { annotationPath: string }) => {
 		quickSelectionVariant = targetEntityType.resolvePath(path.annotationPath);
@@ -3430,7 +3468,7 @@ function _getCollectedNavigationPropertyLabels(relativePath: string, converterCo
 	const navigationProperties = enhanceDataModelPath(converterContext.getDataModelObjectPath(), relativePath).navigationProperties;
 	if (navigationProperties?.length > 0) {
 		const collectedNavigationPropertyLabels: string[] = [];
-		navigationProperties.forEach((navProperty: any) => {
+		navigationProperties.forEach((navProperty) => {
 			collectedNavigationPropertyLabels.push(getLabel(navProperty) || navProperty.name);
 		});
 		return collectedNavigationPropertyLabels;
@@ -3496,17 +3534,23 @@ export function getTableManifestConfiguration(
 	return tableConfiguration;
 }
 
-export function getTypeConfig(oProperty: Property | DataFieldAbstractTypes, dataType: string | undefined): any {
-	let oTargetMapping = EDM_TYPE_MAPPING[(oProperty as Property)?.type] || (dataType ? EDM_TYPE_MAPPING[dataType] : undefined);
-	if (!oTargetMapping && (oProperty as Property)?.targetType && (oProperty as Property).targetType?._type === "TypeDefinition") {
-		oTargetMapping = EDM_TYPE_MAPPING[((oProperty as Property).targetType as TypeDefinition).underlyingType];
+export function getTypeConfig(oProperty: Property | DataFieldAbstractTypes, dataType: string | undefined): PropertyTypeConfig {
+	let oTargetMapping;
+	if (isProperty(oProperty)) {
+		oTargetMapping = isTypeDefinition(oProperty.targetType)
+			? EDM_TYPE_MAPPING[oProperty.targetType.underlyingType]
+			: EDM_TYPE_MAPPING[oProperty.type];
 	}
-	const propertyTypeConfig: configType = {
+	if (oTargetMapping === undefined && dataType !== undefined) {
+		oTargetMapping = EDM_TYPE_MAPPING[dataType];
+	}
+
+	const propertyTypeConfig: PropertyTypeConfig = {
 		type: oTargetMapping?.type,
 		constraints: {},
 		formatOptions: {}
 	};
-	if (isProperty(oProperty)) {
+	if (isProperty(oProperty) && oTargetMapping !== undefined) {
 		propertyTypeConfig.constraints = {
 			scale: oTargetMapping.constraints?.$Scale ? oProperty.scale : undefined,
 			precision: oTargetMapping.constraints?.$Precision ? oProperty.precision : undefined,