@sapui5/sap.fe.core 1.102.3 → 1.105.0

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

@@ -1,78 +1,62 @@
-import { EntityType, Property, TypeDefinition } from "@sap-ux/annotation-converter";
-import {
+import type { EntityType, EnumValue, PathAnnotationExpression, Property, PropertyPath, TypeDefinition } from "@sap-ux/vocabularies-types";
+import type { FilterFunctions } from "@sap-ux/vocabularies-types/vocabularies/Capabilities";
+import type { SemanticKey } from "@sap-ux/vocabularies-types/vocabularies/Common";
+import { CommonAnnotationTerms } from "@sap-ux/vocabularies-types/vocabularies/Common";
+import type {
 	CriticalityType,
 	DataField,
 	DataFieldAbstractTypes,
 	DataFieldForAction,
-	DataFieldForAnnotation,
 	DataFieldForIntentBasedNavigation,
 	DataFieldTypes,
 	DataPoint,
 	DataPointTypeTypes,
-	EnumValue,
 	FieldGroupType,
 	LineItem,
-	PathAnnotationExpression,
-	PresentationVariantTypeTypes,
-	PropertyPath,
+	PresentationVariantType,
 	SelectionVariantType,
-	SelectOptionType,
-	UIAnnotationTypes
-} from "@sap-ux/vocabularies-types";
-import { FilterFunctions } from "@sap-ux/vocabularies-types/dist/generated/Capabilities";
-import { CommonAnnotationTerms } from "@sap-ux/vocabularies-types/dist/generated/Common";
-import { SemanticKey } from "@sap-ux/vocabularies-types/types/generated/Common";
+	SelectOptionType
+} from "@sap-ux/vocabularies-types/vocabularies/UI";
+import { UIAnnotationTypes } from "@sap-ux/vocabularies-types/vocabularies/UI";
+import type { ComplexPropertyInfo } from "sap/fe/core/converters/annotations/DataField";
 import {
 	collectRelatedProperties,
 	collectRelatedPropertiesRecursively,
-	ComplexPropertyInfo,
 	getDataFieldDataType,
 	getSemanticObjectPath,
 	isDataFieldAlwaysHidden,
 	isDataFieldForActionAbstract,
 	isDataFieldTypes
 } from "sap/fe/core/converters/annotations/DataField";
-import {
-	AnnotationAction,
-	BaseAction,
-	CustomAction,
-	getActionsFromManifest,
-	isActionNavigable,
-	removeDuplicateActions
-} from "sap/fe/core/converters/controls/Common/Action";
-import { bindingContextPathVisitor, Entity, UI } from "sap/fe/core/converters/helpers/BindingHelper";
-import { ConfigurableObject, CustomElement, insertCustomElements, Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
+import type { AnnotationAction, BaseAction, CombinedAction, CustomAction } from "sap/fe/core/converters/controls/Common/Action";
+import { getActionsFromManifest, isActionNavigable, removeDuplicateActions } from "sap/fe/core/converters/controls/Common/Action";
+import { Entity, UI } from "sap/fe/core/converters/helpers/BindingHelper";
+import type { ConfigurableObject, CustomElement } from "sap/fe/core/converters/helpers/ConfigurableObject";
+import { insertCustomElements, Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
 import { IssueCategory, IssueCategoryType, IssueSeverity, IssueType } from "sap/fe/core/converters/helpers/IssueManager";
 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 } from "sap/fe/core/helpers/BindingToolkit";
 import {
 	and,
-	annotationExpression,
-	BindingExpression,
-	bindingExpression,
-	BindingExpressionExpression,
-	compileBinding,
+	compileExpression,
 	constant,
 	equal,
-	Expression,
-	ExpressionOrPrimitive,
 	formatResult,
+	getExpressionFromAnnotation,
 	ifElse,
 	isConstant,
 	not,
 	or,
+	pathInModel,
 	resolveBindingString
-} from "sap/fe/core/helpers/BindingExpression";
+} from "sap/fe/core/helpers/BindingToolkit";
 import { replaceSpecialChars } from "sap/fe/core/helpers/StableIdHelper";
-import {
-	DataModelObjectPath,
-	getTargetObjectPath,
-	isPathDeletable,
-	isPathSearchable,
-	isPathUpdatable
-} from "sap/fe/core/templating/DataModelPathHelper";
-import { DisplayMode, EDM_TYPE_MAPPING, getDisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
+import type { DataModelObjectPath } from "sap/fe/core/templating/DataModelPathHelper";
+import { getTargetObjectPath, isPathDeletable, isPathSearchable, isPathUpdatable } from "sap/fe/core/templating/DataModelPathHelper";
+import type { DisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
+import { EDM_TYPE_MAPPING, getDisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
 import { getNonSortablePropertiesRestrictions } from "sap/fe/core/templating/EntitySetHelper";
 import {
 	getAssociatedCurrencyProperty,
@@ -82,30 +66,35 @@ import {
 	isPathExpression,
 	isProperty
 } from "sap/fe/core/templating/PropertyHelper";
-import ConverterContext from "../../ConverterContext";
+import ActionHelper from "sap/fe/macros/internal/helpers/ActionHelper";
+import type ConverterContext from "../../ConverterContext";
 import { AggregationHelper } from "../../helpers/Aggregation";
-import { TableID } from "../../helpers/ID";
-import {
-	ActionType,
-	AvailabilityType,
-	CreationMode,
+import { isReferencePropertyStaticallyHidden } from "../../helpers/DataFieldHelper";
+import { getTableID } from "../../helpers/ID";
+import type {
 	FormatOptionsType,
-	HorizontalAlign,
-	Importance,
 	ManifestTableColumn,
 	NavigationSettingsConfiguration,
 	NavigationTargetConfiguration,
-	SelectionMode,
 	TableColumnSettings,
 	TableManifestConfiguration,
 	TableManifestSettingsConfiguration,
+	ViewPathConfiguration
+} from "../../ManifestSettings";
+import {
+	ActionType,
+	AvailabilityType,
+	CreationMode,
+	HorizontalAlign,
+	Importance,
+	SelectionMode,
 	TemplateType,
 	VariantManagementType,
-	ViewPathConfiguration,
 	VisualizationType
 } from "../../ManifestSettings";
-import ManifestWrapper from "../../ManifestWrapper";
+import type ManifestWrapper from "../../ManifestWrapper";
 import { getMessageTypeFromCriticalityType } from "./Criticality";
+import type { StandardActionConfigType } from "./table/StandardActions";
 import {
 	generateStandardActionsContext,
 	getCreateVisibility,
@@ -119,8 +108,7 @@ import {
 	getStandardActionMassEdit,
 	getStandardActionPaste,
 	isDraftOrStickySupported,
-	isInDisplayMode,
-	StandardActionConfigType
+	isInDisplayMode
 } from "./table/StandardActions";
 
 export type TableAnnotationConfiguration = {
@@ -134,9 +122,9 @@ export type TableAnnotationConfiguration = {
 	row?: {
 		action?: string;
 		press?: string;
-		rowHighlighting: BindingExpression<MessageType>;
-		rowNavigated: BindingExpression<boolean>;
-		visible?: BindingExpression<boolean>;
+		rowHighlighting: CompiledBindingToolkitExpression;
+		rowNavigated: CompiledBindingToolkitExpression;
+		visible?: CompiledBindingToolkitExpression;
 	};
 	selectionMode: string | undefined;
 	standardActions: {
@@ -217,6 +205,7 @@ export type TableControlConfiguration = {
 	enableMassEdit: boolean | undefined;
 	enableAutoColumnWidth: boolean;
 	dataStateIndicatorFilter: string | undefined;
+	isCompactType?: boolean;
 };
 
 export type TableType = "GridTable" | "ResponsiveTable" | "AnalyticalTable";
@@ -257,7 +246,7 @@ export type AnnotationTableColumn = BaseTableColumn & {
 	tooltip?: string;
 	groupLabel?: string;
 	group?: string;
-	FieldGroupHiddenExpressions?: BindingExpression<string>;
+	FieldGroupHiddenExpressions?: CompiledBindingToolkitExpression;
 	showDataFieldsLabel?: boolean;
 	isKey?: boolean;
 	unit?: string;
@@ -287,6 +276,7 @@ export type AnnotationTableColumn = BaseTableColumn & {
 	additionalPropertyInfos?: string[];
 	visualSettings?: VisualSettings;
 	typeConfig?: object;
+	isPartOfLineItem?: boolean; // temporary indicator to only allow filtering on navigation properties when they're part of a line item
 };
 
 export type VisualSettings = {
@@ -321,6 +311,7 @@ export type TableVisualization = {
 	control: TableControlConfiguration;
 	columns: TableColumn[];
 	actions: BaseAction[];
+	commandActions?: Record<string, CustomAction>;
 	aggregates?: Record<string, AggregateData>;
 	enableAnalytics?: boolean;
 	enableAnalyticsSearch?: boolean;
@@ -338,51 +329,53 @@ type SorterType = {
 /**
  * Returns an array of all annotation-based and manifest-based table actions.
  *
- * @param {LineItem} lineItemAnnotation
- * @param {string} visualizationPath
- * @param {ConverterContext} converterContext
- * @param {NavigationSettingsConfiguration} navigationSettings
- * @returns {BaseAction} The complete table actions
+ * @param lineItemAnnotation
+ * @param visualizationPath
+ * @param converterContext
+ * @param navigationSettings
+ * @returns The complete table actions
  */
 export function getTableActions(
 	lineItemAnnotation: LineItem,
 	visualizationPath: string,
 	converterContext: ConverterContext,
 	navigationSettings?: NavigationSettingsConfiguration
-): BaseAction[] {
+): CombinedAction {
 	const aTableActions = getTableAnnotationActions(lineItemAnnotation, visualizationPath, converterContext);
 	const aAnnotationActions = aTableActions.tableActions;
 	const aHiddenActions = aTableActions.hiddenTableActions;
-	return insertCustomElements(
+	const manifestActions = getActionsFromManifest(
+		converterContext.getManifestControlConfiguration(visualizationPath).actions,
+		converterContext,
 		aAnnotationActions,
-		getActionsFromManifest(
-			converterContext.getManifestControlConfiguration(visualizationPath).actions,
-			converterContext,
-			aAnnotationActions,
-			navigationSettings,
-			true,
-			aHiddenActions
-		),
-		{
-			isNavigable: "overwrite",
-			enableOnSelect: "overwrite",
-			enableAutoScroll: "overwrite",
-			enabled: "overwrite",
-			defaultValuesExtensionFunction: "overwrite",
-			command: "overwrite"
-		}
+		navigationSettings,
+		true,
+		aHiddenActions
 	);
+	const actions = insertCustomElements(aAnnotationActions, manifestActions.actions, {
+		isNavigable: "overwrite",
+		enableOnSelect: "overwrite",
+		enableAutoScroll: "overwrite",
+		enabled: "overwrite",
+		defaultValuesExtensionFunction: "overwrite",
+		command: "overwrite"
+	});
+
+	return {
+		"actions": actions,
+		"commandActions": manifestActions.commandActions
+	};
 }
 
 /**
  * Returns an array of all columns, annotation-based as well as manifest based.
  * They are sorted and some properties can be overwritten via the manifest (check out the keys that can be overwritten).
  *
- * @param {LineItem} lineItemAnnotation Collection of data fields for representation in a table or list
- * @param {string} visualizationPath
- * @param {ConverterContext} converterContext
- * @param {NavigationSettingsConfiguration} navigationSettings
- * @returns {TableColumn[]} Returns all table columns that should be available, regardless of templating or personalization or their origin
+ * @param lineItemAnnotation Collection of data fields for representation in a table or list
+ * @param visualizationPath
+ * @param converterContext
+ * @param navigationSettings
+ * @returns Returns all table columns that should be available, regardless of templating or personalization or their origin
  */
 export function getTableColumns(
 	lineItemAnnotation: LineItem,
@@ -482,9 +475,9 @@ export const getAggregateDefinitionsFromEntityType = function (
 				};
 				const aContextDefiningProperties: string[] = [];
 				aRawContextDefiningProperties.forEach((contextDefiningPropertyName) => {
-					const oColumn = findColumnFromPath(contextDefiningPropertyName);
-					if (oColumn) {
-						aContextDefiningProperties.push(oColumn.name);
+					const foundColumn = findColumnFromPath(contextDefiningPropertyName);
+					if (foundColumn) {
+						aContextDefiningProperties.push(foundColumn.name);
 					}
 				});
 
@@ -510,7 +503,7 @@ function updateTableVisualizationForAnalytics(
 	tableVisualization: TableVisualization,
 	entityType: EntityType,
 	converterContext: ConverterContext,
-	presentationVariantAnnotation?: PresentationVariantTypeTypes
+	presentationVariantAnnotation?: PresentationVariantType
 ) {
 	if (tableVisualization.control.type === "AnalyticalTable") {
 		const aggregatesDefinitions = getAggregateDefinitionsFromEntityType(entityType, tableVisualization.columns, converterContext),
@@ -630,7 +623,7 @@ function getSemanticKeysAndTitleInfo(converterContext: ConverterContext) {
 		?.path;
 	const semanticKeyAnnotations: any[] | undefined = converterContext.getAnnotationEntityType()?.annotations?.Common?.SemanticKey;
 
-	let semanticKeyColumns: string[] = [];
+	const semanticKeyColumns: string[] = [];
 	if (semanticKeyAnnotations) {
 		semanticKeyAnnotations.forEach(function (oColumn: any) {
 			semanticKeyColumns.push(oColumn.value);
@@ -644,7 +637,7 @@ export function createTableVisualization(
 	lineItemAnnotation: LineItem,
 	visualizationPath: string,
 	converterContext: ConverterContext,
-	presentationVariantAnnotation?: PresentationVariantTypeTypes,
+	presentationVariantAnnotation?: PresentationVariantType,
 	isCondensedTableLayoutCompliant?: boolean,
 	viewConfiguration?: ViewPathConfiguration
 ): TableVisualization {
@@ -660,6 +653,7 @@ export function createTableVisualization(
 	const columns = getTableColumns(lineItemAnnotation, visualizationPath, converterContext, navigationSettings);
 	const operationAvailableMap = getOperationAvailableMap(lineItemAnnotation, converterContext);
 	const semanticKeysAndHeaderInfoTitle = getSemanticKeysAndTitleInfo(converterContext);
+	const tableActions = getTableActions(lineItemAnnotation, visualizationPath, converterContext, navigationSettings);
 	const oVisualization: TableVisualization = {
 		type: VisualizationType.Table,
 		annotation: getTableAnnotationConfiguration(
@@ -672,7 +666,8 @@ export function createTableVisualization(
 			viewConfiguration
 		),
 		control: tableManifestConfig,
-		actions: removeDuplicateActions(getTableActions(lineItemAnnotation, visualizationPath, converterContext, navigationSettings)),
+		actions: removeDuplicateActions(tableActions.actions),
+		commandActions: tableActions.commandActions,
 		columns: columns,
 		operationAvailableMap: JSON.stringify(operationAvailableMap),
 		operationAvailableProperties: getOperationAvailableProperties(operationAvailableMap, converterContext),
@@ -719,53 +714,17 @@ export function createDefaultTableVisualization(converterContext: ConverterConte
  *
  * @param lineItemAnnotation The instance of the line item
  * @param converterContext The instance of the converter context
- * @returns {Record<string, any>} The record containing all action names and their corresponding Core.OperationAvailable property paths
+ * @returns The record containing all action names and their corresponding Core.OperationAvailable property paths
  */
 function getOperationAvailableMap(lineItemAnnotation: LineItem | undefined, converterContext: ConverterContext): Record<string, any> {
-	const operationAvailableMap: Record<string, any> = {};
-	const addToMap = function (key: string, value: any) {
-		if (key) {
-			operationAvailableMap[key] = value;
-		}
-	};
-
-	if (lineItemAnnotation) {
-		lineItemAnnotation.forEach((dataField) => {
-			if (dataField.$Type === UIAnnotationTypes.DataFieldForAction) {
-				const actionName = dataField.Action as string;
-				if (actionName?.indexOf("/") < 0 && !dataField.Determining) {
-					const actionTarget = dataField.ActionTarget;
-					if (actionTarget?.annotations?.Core?.OperationAvailable === null) {
-						// Annotation explicitly configured with null (action advertisement related)
-						addToMap(actionName, null);
-					} else if (actionTarget?.parameters?.length) {
-						const bindingParameterFullName = actionTarget.parameters[0].fullyQualifiedName,
-							targetExpression = annotationExpression(
-								actionTarget?.annotations?.Core?.OperationAvailable,
-								[],
-								undefined,
-								(path: string) => bindingContextPathVisitor(path, converterContext, bindingParameterFullName)
-							) as BindingExpressionExpression<string>;
-
-						if (targetExpression?.path) {
-							addToMap(actionName, targetExpression.path);
-						} else if (actionTarget?.annotations?.Core?.OperationAvailable !== undefined) {
-							addToMap(actionName, targetExpression);
-						}
-					}
-				}
-			}
-		});
-	}
-
-	return operationAvailableMap;
+	return ActionHelper.getOperationAvailableMap(lineItemAnnotation, "table", converterContext);
 }
 
 /**
  * Gets updatable propertyPath for the current entityset if valid.
  *
  * @param converterContext The instance of the converter context
- * @returns {string} The updatable property for the rows
+ * @returns The updatable property for the rows
  */
 function getCurrentEntitySetUpdatablePath(converterContext: ConverterContext): string {
 	const restrictions = getRestrictions(converterContext);
@@ -780,9 +739,9 @@ function getCurrentEntitySetUpdatablePath(converterContext: ConverterContext): s
 /**
  * Method to retrieve all property paths assigned to the Core.OperationAvailable annotation.
  *
- * @param {Record<string, any>} operationAvailableMap The record consisting of actions and their Core.OperationAvailable property paths
- * @param {ConverterContext} converterContext The instance of the converter context
- * @returns {string} The CSV string of all property paths associated with the Core.OperationAvailable annotation
+ * @param operationAvailableMap The record consisting of actions and their Core.OperationAvailable property paths
+ * @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 {
 	const properties = new Set();
@@ -826,8 +785,8 @@ function getUIHiddenExpForActionsRequiringContext(
 	currentEntityType: EntityType,
 	contextDataModelObjectPath: DataModelObjectPath,
 	isEntitySet: boolean
-): Expression<boolean>[] {
-	const aUiHiddenPathExpressions: Expression<boolean>[] = [];
+): BindingToolkitExpression<boolean>[] {
+	const aUiHiddenPathExpressions: BindingToolkitExpression<boolean>[] = [];
 	lineItemAnnotation.forEach((dataField) => {
 		// Check if the lineItem context is the same as that of the action:
 		if (
@@ -839,16 +798,7 @@ function getUIHiddenExpForActionsRequiringContext(
 				dataField?.Inline?.valueOf() !== true)
 		) {
 			if (typeof dataField.annotations?.UI?.Hidden?.valueOf() === "object") {
-				aUiHiddenPathExpressions.push(
-					equal(
-						getBindingExpFromContext(
-							dataField as DataFieldForAction | DataFieldForIntentBasedNavigation,
-							contextDataModelObjectPath,
-							isEntitySet
-						),
-						false
-					)
-				);
+				aUiHiddenPathExpressions.push(equal(getBindingExpFromContext(dataField, contextDataModelObjectPath, isEntitySet), false));
 			}
 		}
 	});
@@ -870,7 +820,7 @@ function getBindingExpFromContext(
 	source: DataFieldForAction | DataFieldForIntentBasedNavigation | CustomAction,
 	contextDataModelObjectPath: DataModelObjectPath,
 	isEntitySet: boolean
-): Expression<any> {
+): BindingToolkitExpression<any> {
 	let sExpression: any | undefined;
 	if (
 		(source as DataFieldForAction)?.$Type === UIAnnotationTypes.DataFieldForAction ||
@@ -898,13 +848,13 @@ function getBindingExpFromContext(
 				contextDataModelObjectPath?.targetObject?._type === "NavigationProperty" &&
 				contextDataModelObjectPath.targetObject.partner === sNavigationPath
 			) {
-				return bindingExpression(aSplitPath.slice(1).join("/"));
+				return pathInModel(aSplitPath.slice(1).join("/"));
 			} else {
 				return constant(true);
 			}
 			// In case there is no navigation property, if it's an entitySet, the expression binding has to be returned:
 		} else if (isEntitySet) {
-			return bindingExpression(sPath);
+			return pathInModel(sPath);
 			// otherwise the expression binding cannot be taken into account for the selection mode evaluation:
 		} else {
 			return constant(true);
@@ -919,7 +869,7 @@ function getBindingExpFromContext(
  *
  * @param lineItemAnnotation Collection of data fields for representation in a table or list
  * @param currentEntityType Current Entity Type
- * @returns {boolean} `true` if there is at least 1 action that meets the criteria
+ * @returns `true` if there is at least 1 action that meets the criteria
  */
 function hasBoundActionsAlwaysVisibleInToolBar(lineItemAnnotation: LineItem, currentEntityType: EntityType): boolean {
 	return lineItemAnnotation.some((dataField) => {
@@ -957,8 +907,8 @@ function hasCustomActionsAlwaysVisibleInToolBar(manifestActions: Record<string,
  * @param manifestActions The actions defined in the manifest
  * @returns Array<Expression<boolean>> All the visible path expressions of the actions that meet the criteria
  */
-function getVisibleExpForCustomActionsRequiringContext(manifestActions: Record<string, CustomAction>): Expression<boolean>[] {
-	const aVisiblePathExpressions: Expression<boolean>[] = [];
+function getVisibleExpForCustomActionsRequiringContext(manifestActions: Record<string, CustomAction>): BindingToolkitExpression<boolean>[] {
+	const aVisiblePathExpressions: BindingToolkitExpression<boolean>[] = [];
 	if (manifestActions) {
 		Object.keys(manifestActions).forEach((actionKey) => {
 			const action = manifestActions[actionKey];
@@ -982,7 +932,7 @@ function getVisibleExpForCustomActionsRequiringContext(manifestActions: Record<s
  * Evaluate if the path is statically deletable or updatable.
  *
  * @param converterContext
- * @returns {TableCapabilityRestriction} The table capabilities
+ * @returns The table capabilities
  */
 export function getCapabilityRestriction(converterContext: ConverterContext): TableCapabilityRestriction {
 	const isDeletable = isPathDeletable(converterContext.getDataModelObjectPath());
@@ -999,16 +949,16 @@ export function getSelectionMode(
 	converterContext: ConverterContext,
 	isEntitySet: boolean,
 	targetCapabilities: TableCapabilityRestriction,
-	deleteButtonVisibilityExpression?: Expression<boolean>,
-	massEditVisibilityExpression: Expression<boolean> = constant(false)
+	deleteButtonVisibilityExpression?: BindingToolkitExpression<boolean>,
+	massEditVisibilityExpression: BindingToolkitExpression<boolean> = constant(false)
 ): string | undefined {
 	if (!lineItemAnnotation) {
 		return SelectionMode.None;
 	}
 	const tableManifestSettings = converterContext.getManifestControlConfiguration(visualizationPath);
 	let selectionMode = tableManifestSettings.tableSettings?.selectionMode;
-	let aHiddenBindingExpressions: Expression<boolean>[] = [],
-		aVisibleBindingExpressions: Expression<boolean>[] = [];
+	let aHiddenBindingExpressions: BindingToolkitExpression<boolean>[] = [],
+		aVisibleBindingExpressions: BindingToolkitExpression<boolean>[] = [];
 	const manifestActions = getActionsFromManifest(
 		converterContext.getManifestControlConfiguration(visualizationPath).actions,
 		converterContext,
@@ -1019,14 +969,14 @@ export function getSelectionMode(
 	let isParentDeletable, parentEntitySetDeletable;
 	if (converterContext.getTemplateType() === TemplateType.ObjectPage) {
 		isParentDeletable = isPathDeletable(converterContext.getDataModelObjectPath());
-		parentEntitySetDeletable = isParentDeletable ? compileBinding(isParentDeletable, true) : isParentDeletable;
+		parentEntitySetDeletable = isParentDeletable ? compileExpression(isParentDeletable, true) : isParentDeletable;
 	}
 
 	const bMassEditEnabled: boolean = !isConstant(massEditVisibilityExpression) || massEditVisibilityExpression.value !== false;
 	if (selectionMode && selectionMode === SelectionMode.None && deleteButtonVisibilityExpression) {
 		if (converterContext.getTemplateType() === TemplateType.ObjectPage && bMassEditEnabled) {
 			// Mass Edit in OP is enabled only in edit mode.
-			return compileBinding(
+			return compileExpression(
 				ifElse(
 					and(UI.IsEditable, massEditVisibilityExpression),
 					constant("Multi"),
@@ -1037,7 +987,7 @@ export function getSelectionMode(
 			return SelectionMode.Multi;
 		}
 
-		return compileBinding(ifElse(deleteButtonVisibilityExpression, constant("Multi"), constant("None")));
+		return compileExpression(ifElse(deleteButtonVisibilityExpression, constant("Multi"), constant("None")));
 	}
 	if (!selectionMode || selectionMode === SelectionMode.Auto) {
 		selectionMode = SelectionMode.Multi;
@@ -1049,7 +999,7 @@ export function getSelectionMode(
 
 	if (
 		hasBoundActionsAlwaysVisibleInToolBar(lineItemAnnotation, converterContext.getEntityType()) ||
-		hasCustomActionsAlwaysVisibleInToolBar(manifestActions)
+		hasCustomActionsAlwaysVisibleInToolBar(manifestActions.actions)
 	) {
 		return selectionMode;
 	}
@@ -1059,7 +1009,7 @@ export function getSelectionMode(
 		converterContext.getDataModelObjectPath(),
 		isEntitySet
 	);
-	aVisibleBindingExpressions = getVisibleExpForCustomActionsRequiringContext(manifestActions);
+	aVisibleBindingExpressions = getVisibleExpForCustomActionsRequiringContext(manifestActions.actions);
 
 	// No action requiring a context:
 	if (
@@ -1075,7 +1025,7 @@ export function getSelectionMode(
 					deleteButtonVisibilityExpression || true, // default delete visibility as true
 					massEditVisibilityExpression
 				);
-				return compileBinding(
+				return compileExpression(
 					ifElse(and(UI.IsEditable, buttonVisibilityExpression), constant(selectionMode), constant(SelectionMode.None))
 				);
 			} else {
@@ -1086,7 +1036,7 @@ export function getSelectionMode(
 			// example: LR scenario
 			return selectionMode;
 		} else if (targetCapabilities.isDeletable && deleteButtonVisibilityExpression) {
-			return compileBinding(ifElse(deleteButtonVisibilityExpression, constant(selectionMode), constant("None")));
+			return compileExpression(ifElse(deleteButtonVisibilityExpression, constant(selectionMode), constant("None")));
 			// EntitySet not deletable:
 		} else {
 			return SelectionMode.None;
@@ -1101,7 +1051,7 @@ export function getSelectionMode(
 				massEditVisibilityExpression,
 				constant(true)
 			);
-			return compileBinding(
+			return compileExpression(
 				ifElse(
 					and(UI.IsEditable, editModebuttonVisibilityExpression),
 					constant(selectionMode),
@@ -1113,7 +1063,7 @@ export function getSelectionMode(
 				)
 			);
 		} else {
-			return compileBinding(
+			return compileExpression(
 				ifElse(
 					or(...aHiddenBindingExpressions.concat(aVisibleBindingExpressions)),
 					constant(selectionMode),
@@ -1127,7 +1077,7 @@ export function getSelectionMode(
 		return selectionMode;
 		//EntitySet not deletable:
 	} else {
-		return compileBinding(
+		return compileExpression(
 			ifElse(
 				or(...aHiddenBindingExpressions.concat(aVisibleBindingExpressions), massEditVisibilityExpression),
 				constant(selectionMode),
@@ -1143,7 +1093,7 @@ export function getSelectionMode(
  * @param lineItemAnnotation
  * @param visualizationPath
  * @param converterContext
- * @returns {Record<BaseAction, BaseAction>} The table annotation actions
+ * @returns The table annotation actions
  */
 function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPath: string, converterContext: ConverterContext) {
 	const tableActions: BaseAction[] = [];
@@ -1164,10 +1114,10 @@ function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPa
 							type: ActionType.DataFieldForAction,
 							annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
 							key: key,
-							visible: compileBinding(
+							visible: compileExpression(
 								not(
 									equal(
-										annotationExpression(
+										getExpressionFromAnnotation(
 											dataField.annotations?.UI?.Hidden,
 											[],
 											undefined,
@@ -1186,10 +1136,10 @@ function getTableAnnotationActions(lineItemAnnotation: LineItem, visualizationPa
 							type: ActionType.DataFieldForIntentBasedNavigation,
 							annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
 							key: key,
-							visible: compileBinding(
+							visible: compileExpression(
 								not(
 									equal(
-										annotationExpression(
+										getExpressionFromAnnotation(
 											dataField.annotations?.UI?.Hidden,
 											[],
 											undefined,
@@ -1225,11 +1175,11 @@ function getHighlightRowBinding(
 	criticalityAnnotation: PathAnnotationExpression<CriticalityType> | EnumValue<CriticalityType> | undefined,
 	isDraftRoot: boolean,
 	targetEntityType?: EntityType
-): Expression<MessageType> {
-	let defaultHighlightRowDefinition: MessageType | Expression<MessageType> = MessageType.None;
+): BindingToolkitExpression<MessageType> {
+	let defaultHighlightRowDefinition: MessageType | BindingToolkitExpression<MessageType> = MessageType.None;
 	if (criticalityAnnotation) {
 		if (typeof criticalityAnnotation === "object") {
-			defaultHighlightRowDefinition = annotationExpression(criticalityAnnotation) as Expression<MessageType>;
+			defaultHighlightRowDefinition = getExpressionFromAnnotation(criticalityAnnotation) as BindingToolkitExpression<MessageType>;
 		} else {
 			// Enum Value so we get the corresponding static part
 			defaultHighlightRowDefinition = getMessageTypeFromCriticalityType(criticalityAnnotation);
@@ -1239,14 +1189,14 @@ function getHighlightRowBinding(
 	const aMissingKeys: any[] = [];
 	targetEntityType?.keys.forEach((key: any) => {
 		if (key.name !== "IsActiveEntity") {
-			aMissingKeys.push(bindingExpression(key.name, undefined));
+			aMissingKeys.push(pathInModel(key.name, undefined));
 		}
 	});
 
 	return formatResult(
 		[
 			defaultHighlightRowDefinition,
-			bindingExpression(`filteredMessages`, "internal"),
+			pathInModel(`filteredMessages`, "internal"),
 			isDraftRoot && Entity.HasActive,
 			isDraftRoot && Entity.IsActive,
 			`${isDraftRoot}`,
@@ -1322,7 +1272,7 @@ const _getRowConfigurationProperty = function (
 	targetPath: string
 ) {
 	let pressProperty, navigationTarget;
-	let criticalityProperty: ExpressionOrPrimitive<MessageType> = MessageType.None;
+	let criticalityProperty: BindingToolkitExpression<MessageType> = constant(MessageType.None);
 	const targetEntityType = converterContext.getEntityType();
 	if (navigationSettings && lineItemAnnotation) {
 		navigationTarget = navigationSettings.display?.target || navigationSettings.detail?.outbound;
@@ -1351,17 +1301,17 @@ const _getRowConfigurationProperty = function (
 			}
 		}
 	}
-	const rowNavigatedExpression: Expression<boolean> = formatResult(
-		[bindingExpression("/deepestPath", "internal")],
+	const rowNavigatedExpression: BindingToolkitExpression<boolean> = formatResult(
+		[pathInModel("/deepestPath", "internal")],
 		tableFormatters.navigatedRow,
 		targetEntityType
 	);
 	return {
 		press: pressProperty,
 		action: pressProperty ? "Navigation" : undefined,
-		rowHighlighting: compileBinding(criticalityProperty),
-		rowNavigated: compileBinding(rowNavigatedExpression),
-		visible: compileBinding(not(UI.IsInactive))
+		rowHighlighting: compileExpression(criticalityProperty),
+		rowNavigated: compileExpression(rowNavigatedExpression),
+		visible: compileExpression(not(UI.IsInactive))
 	};
 };
 
@@ -1374,7 +1324,7 @@ const _getRowConfigurationProperty = function (
  * @param nonSortableColumns The array of all non sortable column names.
  * @param converterContext The converter context.
  * @param tableType The table type.
- * @returns {AnnotationTableColumn[]} The column from the entityType
+ * @returns The column from the entityType
  */
 export const getColumnsFromEntityType = function (
 	columnsToBeCreated: Record<string, Property>,
@@ -1384,7 +1334,7 @@ export const getColumnsFromEntityType = function (
 	converterContext: ConverterContext,
 	tableType: TableType
 ): AnnotationTableColumn[] {
-	const tableColumns: AnnotationTableColumn[] = [];
+	const tableColumns: AnnotationTableColumn[] = annotationColumns;
 	// Catch already existing columns - which were added before by LineItem Annotations
 	const aggregationHelper = new AggregationHelper(entityType, converterContext);
 
@@ -1395,7 +1345,12 @@ export const getColumnsFromEntityType = function (
 		});
 
 		// if target type exists, it is a complex property and should be ignored
-		if (!property.targetType && !exists) {
+		if (
+			!property.targetType &&
+			!exists &&
+			property.annotations.UI &&
+			!isReferencePropertyStaticallyHidden(property.annotations.UI.DataFieldDefault)
+		) {
 			const relatedPropertiesInfo: ComplexPropertyInfo = collectRelatedProperties(
 				property.name,
 				property,
@@ -1463,20 +1418,25 @@ export const getColumnsFromEntityType = function (
 			tableColumns.push(columnInfo);
 		}
 	});
-	return tableColumns;
+
+	// Create a propertyInfo for each related property.
+	const relatedColumns = _createRelatedColumns(columnsToBeCreated, tableColumns, nonSortableColumns, converterContext, entityType);
+
+	return tableColumns.concat(relatedColumns);
 };
 
 /**
  * Create a column definition from a property.
- * @param {Property} property Entity type property for which the column is created
- * @param {string} fullPropertyPath The full path to the target property
- * @param {string} relativePath The relative path to the target property based on the context
- * @param {boolean} useDataFieldPrefix Should be prefixed with "DataField::", else it will be prefixed with "Property::"
- * @param {boolean} availableForAdaptation Decides whether the column should be available for adaptation
- * @param {string[]} nonSortableColumns The array of all non-sortable column names
- * @param {AggregationHelper} aggregationHelper The aggregationHelper for the entity
- * @param {ConverterContext} converterContext The converter context
- * @returns {AnnotationTableColumn} The annotation column definition
+ *
+ * @param property Entity type property for which the column is created
+ * @param fullPropertyPath The full path to the target property
+ * @param relativePath The relative path to the target property based on the context
+ * @param useDataFieldPrefix Should be prefixed with "DataField::", else it will be prefixed with "Property::"
+ * @param availableForAdaptation Decides whether the column should be available for adaptation
+ * @param nonSortableColumns The array of all non-sortable column names
+ * @param aggregationHelper The aggregationHelper for the entity
+ * @param converterContext The converter context
+ * @returns The annotation column definition
  */
 const getColumnDefinitionFromProperty = function (
 	property: Property,
@@ -1488,7 +1448,7 @@ const getColumnDefinitionFromProperty = function (
 	aggregationHelper: AggregationHelper,
 	converterContext: ConverterContext
 ): AnnotationTableColumn {
-	const name = useDataFieldPrefix ? relativePath : "Property::" + relativePath;
+	const name = useDataFieldPrefix ? relativePath : `Property::${relativePath}`;
 	const key = (useDataFieldPrefix ? "DataField::" : "Property::") + replaceSpecialChars(relativePath);
 	const semanticObjectAnnotationPath = getSemanticObjectPath(converterContext, property);
 	const isHidden = property.annotations?.UI?.Hidden?.valueOf() === true;
@@ -1575,8 +1535,8 @@ const getColumnDefinitionFromProperty = function (
 /**
  * Returns Boolean true for valid columns, false for invalid columns.
  *
- * @param {DataFieldAbstractTypes} dataField Different DataField types defined in the annotations
- * @returns {boolean} True for valid columns, false for invalid columns
+ * @param dataField Different DataField types defined in the annotations
+ * @returns True for valid columns, false for invalid columns
  * @private
  */
 const _isValidColumn = function (dataField: DataFieldAbstractTypes) {
@@ -1596,23 +1556,20 @@ const _isValidColumn = function (dataField: DataFieldAbstractTypes) {
 		//  throw new Error("Unhandled DataField Abstract type: " + dataField.$Type);
 	}
 };
-
 /**
  * Returns the binding expression to evaluate the visibility of a DataField or DataPoint annotation.
  *
  * SAP Fiori elements will evaluate either the UI.Hidden annotation defined on the annotation itself or on the target property.
  *
- * @param {DataModelObjectPath} dataFieldModelPath The metapath referring to the annotation that is evaluated by SAP Fiori elements.
- * @param {object} [formatOptions] FormatOptions optional.
- * @param {boolean} formatOptions.isAnalytics This flag is used to check if the analytic table has GroupHeader expanded.
- * @param {boolean} [returnExpression] ReturnExpression optional.
- * @returns {BindingExpression<string>} An expression that you can bind to the UI.
+ * @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,
-	returnExpression: boolean = false
-): BindingExpression<string> {
+	formatOptions?: any
+): BindingToolkitExpression<any> {
 	const targetObject: DataFieldAbstractTypes | DataPointTypeTypes = dataFieldModelPath.targetObject;
 	let propertyValue;
 	if (targetObject) {
@@ -1644,41 +1601,43 @@ export const _getVisibleExpression = function (
 	// - the UI.Hidden expression in the original annotation does not evaluate to 'true'
 	// - the UI.Hidden expression in the target property does not evaluate to 'true'
 	// - in case of Analytics it's not visible for an expanded GroupHeader
-	const expression = and(
+	return and(
 		...[
-			not(equal(annotationExpression(targetObject?.annotations?.UI?.Hidden), true)),
-			ifElse(!!propertyValue, propertyValue && not(equal(annotationExpression(propertyValue.annotations?.UI?.Hidden), true)), true),
+			not(equal(getExpressionFromAnnotation(targetObject?.annotations?.UI?.Hidden), true)),
+			ifElse(
+				!!propertyValue,
+				propertyValue && not(equal(getExpressionFromAnnotation(propertyValue.annotations?.UI?.Hidden), true)),
+				true
+			),
 			or(not(isAnalyticalGroupHeaderExpanded), isAnalyticalLeaf)
 		]
 	);
-	return returnExpression ? (expression as any as BindingExpression<string>) : compileBinding(expression);
 };
 
 /**
  * Returns hidden binding expressions for a field group.
- * @param {DataFieldAbstractTypes} dataFieldGroup DataField defined in the annotations
- * @param {object} fieldFormatOptions FormatOptions optional.
- * @param {boolean} fieldFormatOptions.isAnalytics This flag is used to check if the analytic table has GroupHeader expanded.
- * @returns {BindingExpression<string>} Compile binding of field group expressions.
+ *
+ * @param dataFieldGroup DataField defined in the annotations
+ * @param fieldFormatOptions FormatOptions optional.
+ * @param fieldFormatOptions.isAnalytics This flag is used to check if the analytic table has GroupHeader expanded.
+ * @returns Compile binding of field group expressions.
  * @private
  */
 const _getFieldGroupHiddenExpressions = function (
 	dataFieldGroup: DataFieldAbstractTypes,
 	fieldFormatOptions: any
-): BindingExpression<string> | undefined {
-	const aFieldGroupHiddenExpressions: BindingExpression<string>[] = [];
+): CompiledBindingToolkitExpression | undefined {
+	const aFieldGroupHiddenExpressions: BindingToolkitExpression<any>[] = [];
 	if (
 		dataFieldGroup.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
 		dataFieldGroup.Target?.$target?.$Type === UIAnnotationTypes.FieldGroupType
 	) {
 		dataFieldGroup.Target.$target.Data?.forEach((innerDataField: DataFieldAbstractTypes | DataPointTypeTypes) => {
 			aFieldGroupHiddenExpressions.push(
-				_getVisibleExpression({ targetObject: innerDataField } as DataModelObjectPath, fieldFormatOptions, true)
+				_getVisibleExpression({ targetObject: innerDataField } as DataModelObjectPath, fieldFormatOptions)
 			);
 		});
-		return compileBinding(
-			ifElse(or(...(aFieldGroupHiddenExpressions as any as ExpressionOrPrimitive<boolean>[])), constant(true), constant(false))
-		);
+		return compileExpression(ifElse(or(...aFieldGroupHiddenExpressions), constant(true), constant(false)));
 	} else {
 		return undefined;
 	}
@@ -1686,9 +1645,10 @@ const _getFieldGroupHiddenExpressions = function (
 
 /**
  * Returns the label for the property and dataField.
- * @param {DataFieldAbstractTypes | Property} [property] Property or DataField defined in the annotations
+ *
+ * @param [property] Property or DataField defined in the annotations
  * @param isGroup
- * @returns {string} Label of the property or DataField
+ * @returns Label of the property or DataField
  * @private
  */
 const _getLabel = function (property: DataFieldAbstractTypes | Property, isGroup: boolean = false): string | undefined {
@@ -1698,26 +1658,26 @@ const _getLabel = function (property: DataFieldAbstractTypes | Property, isGroup
 	if (isProperty(property)) {
 		const dataFieldDefault = property.annotations?.UI?.DataFieldDefault;
 		if (dataFieldDefault && !dataFieldDefault.qualifier && dataFieldDefault.Label?.valueOf()) {
-			return compileBinding(annotationExpression(dataFieldDefault.Label?.valueOf()));
+			return compileExpression(getExpressionFromAnnotation(dataFieldDefault.Label?.valueOf()));
 		}
-		return compileBinding(annotationExpression(property.annotations.Common?.Label?.valueOf() || property.name));
+		return compileExpression(getExpressionFromAnnotation(property.annotations.Common?.Label?.valueOf() || property.name));
 	} else if (isDataFieldTypes(property)) {
 		if (!!isGroup && property.$Type === UIAnnotationTypes.DataFieldWithIntentBasedNavigation) {
-			return compileBinding(annotationExpression(property.Label?.valueOf()));
+			return compileExpression(getExpressionFromAnnotation(property.Label?.valueOf()));
 		}
-		return compileBinding(
-			annotationExpression(
+		return compileExpression(
+			getExpressionFromAnnotation(
 				property.Label?.valueOf() || property.Value?.$target?.annotations?.Common?.Label?.valueOf() || property.Value?.$target?.name
 			)
 		);
 	} else if (property.$Type === UIAnnotationTypes.DataFieldForAnnotation) {
-		return compileBinding(
-			annotationExpression(
+		return compileExpression(
+			getExpressionFromAnnotation(
 				property.Label?.valueOf() || (property.Target?.$target as DataPoint)?.Value?.$target?.annotations?.Common?.Label?.valueOf()
 			)
 		);
 	} else {
-		return compileBinding(annotationExpression(property.Label?.valueOf()));
+		return compileExpression(getExpressionFromAnnotation(property.Label?.valueOf()));
 	}
 };
 
@@ -1726,38 +1686,38 @@ const _getTooltip = function (source: DataFieldAbstractTypes | Property): string
 		return undefined;
 	}
 
-	if (isProperty(source)) {
-		return source.annotations.Common?.QuickInfo
-			? compileBinding(annotationExpression(source.annotations.Common.QuickInfo.valueOf()))
+	if (isProperty(source) || source.annotations?.Common?.QuickInfo) {
+		return source.annotations?.Common?.QuickInfo
+			? compileExpression(getExpressionFromAnnotation(source.annotations.Common.QuickInfo.valueOf()))
 			: undefined;
 	} else if (isDataFieldTypes(source)) {
 		return source.Value?.$target?.annotations?.Common?.QuickInfo
-			? compileBinding(annotationExpression(source.Value.$target.annotations.Common.QuickInfo.valueOf()))
+			? compileExpression(getExpressionFromAnnotation(source.Value.$target.annotations.Common.QuickInfo.valueOf()))
 			: undefined;
 	} else if (source.$Type === UIAnnotationTypes.DataFieldForAnnotation) {
 		const datapointTarget = source.Target?.$target as DataPoint;
 		return datapointTarget?.Value?.$target?.annotations?.Common?.QuickInfo
-			? compileBinding(annotationExpression(datapointTarget.Value.$target.annotations.Common.QuickInfo.valueOf()))
+			? compileExpression(getExpressionFromAnnotation(datapointTarget.Value.$target.annotations.Common.QuickInfo.valueOf()))
 			: undefined;
 	} else {
 		return undefined;
 	}
 };
-export function getRowStatusVisibility(): Expression<boolean> {
+export function getRowStatusVisibility(): BindingToolkitExpression<boolean> {
 	return formatResult(
-		[bindingExpression(`semanticKeyHasDraftIndicator`, "internal"), bindingExpression(`filteredMessages`, "internal")],
+		[pathInModel(`semanticKeyHasDraftIndicator`, "internal"), pathInModel(`filteredMessages`, "internal")],
 		tableFormatters.getErrorStatusTextVisibilityFormatter
 	);
 }
 /**
  * Creates a PropertyInfo for each identified property consumed by a LineItem.
  *
- * @param {Record<string, Property>} columnsToBeCreated Identified properties.
+ * @param columnsToBeCreated Identified properties.
  * @param existingColumns The list of columns created for LineItems and Properties of entityType.
  * @param nonSortableColumns The array of column names which cannot be sorted.
  * @param converterContext The converter context.
  * @param entityType The entity type for the LineItem
- * @returns {AnnotationTableColumn[]} The array of columns created.
+ * @returns The array of columns created.
  */
 const _createRelatedColumns = function (
 	columnsToBeCreated: Record<string, Property>,
@@ -1798,24 +1758,24 @@ const _createRelatedColumns = function (
 			// Case 3: This is a self reference from an existing column and
 			// both cases require a dummy PropertyInfo for setting correct export settings.
 
-			const newName = "Property::" + name;
+			const newName = `Property::${name}`;
 
 			// Checking whether the related property column has already been created in a previous iteration.
 			if (!existingColumns.some((column) => column.name === newName)) {
 				// Create a new property column with 'Property::' prefix,
 				// Set it to hidden as it is only consumed by Complex property infos.
-				relatedColumns.push(
-					getColumnDefinitionFromProperty(
-						property,
-						annotationPath,
-						name,
-						false,
-						false,
-						nonSortableColumns,
-						aggregationHelper,
-						converterContext
-					)
+				const column = getColumnDefinitionFromProperty(
+					property,
+					annotationPath,
+					name,
+					false,
+					false,
+					nonSortableColumns,
+					aggregationHelper,
+					converterContext
 				);
+				column.isPartOfLineItem = relatedColumn.isPartOfLineItem;
+				relatedColumns.push(column);
 				relatedPropertyNameMap[name] = newName;
 			}
 		}
@@ -1838,8 +1798,8 @@ const _createRelatedColumns = function (
  * If it points to a DataField with one property or DataPoint with one property, it will use the property name
  * here to be consistent with the existing flex changes.
  *
- * @param {DataFieldAbstractTypes} dataField Different DataField types defined in the annotations
- * @returns {string} The name of annotation columns
+ * @param dataField Different DataField types defined in the annotations
+ * @returns The name of annotation columns
  * @private
  */
 const _getAnnotationColumnName = function (dataField: DataFieldAbstractTypes) {
@@ -1856,10 +1816,11 @@ const _getAnnotationColumnName = function (dataField: DataFieldAbstractTypes) {
 
 /**
  * Determines if the data field labels have to be displayed in the table.
- * @param {string} fieldGroupName The `DataField` name being processed.
- * @param {string} visualizationPath
- * @param {ConverterContext} converterContext
- * @returns {boolean} `showDataFieldsLabel` value from the manifest
+ *
+ * @param fieldGroupName The `DataField` name being processed.
+ * @param visualizationPath
+ * @param converterContext
+ * @returns `showDataFieldsLabel` value from the manifest
  * @private
  */
 const _getShowDataFieldsLabel = function (fieldGroupName: string, visualizationPath: string, converterContext: ConverterContext): boolean {
@@ -1875,8 +1836,9 @@ const _getShowDataFieldsLabel = function (fieldGroupName: string, visualizationP
 
 /**
  * Determines the relative path of the property with respect to the root entity.
+ *
  * @param dataField The `DataField` being processed.
- * @returns {string} The relative path
+ * @returns The relative path
  */
 const _getRelativePath = function (dataField: DataFieldAbstractTypes): string {
 	let relativePath: string = "";
@@ -1891,11 +1853,13 @@ const _getRelativePath = function (dataField: DataFieldAbstractTypes): string {
 			break;
 
 		case UIAnnotationTypes.DataFieldForAnnotation:
-			relativePath = (dataField as DataFieldForAnnotation)?.Target?.value;
+			relativePath = dataField?.Target?.value;
 			break;
 
 		case UIAnnotationTypes.DataFieldForAction:
 		case UIAnnotationTypes.DataFieldForIntentBasedNavigation:
+		case UIAnnotationTypes.DataFieldForActionGroup:
+		case UIAnnotationTypes.DataFieldWithActionGroup:
 			relativePath = KeyHelper.generateKeyFromDataField(dataField);
 			break;
 	}
@@ -1918,33 +1882,23 @@ const _sliceAtSlash = function (path: string, isLastSlash: boolean, isLastPart:
  * @param dataField The data field being processed
  * @param propertyPath The property path
  * @param nonSortableColumns Collection of non-sortable column names as per annotation
- * @returns {boolean} True if the column is sortable
+ * @returns True if the column is sortable
  */
 const _isColumnSortable = function (dataField: DataFieldAbstractTypes, propertyPath: string, nonSortableColumns: string[]): boolean {
-	let isSortable: boolean = false;
-	if (nonSortableColumns.indexOf(propertyPath) === -1) {
-		// Column is not marked as non-sortable via annotation
-		switch (dataField.$Type) {
-			case UIAnnotationTypes.DataField:
-			case UIAnnotationTypes.DataFieldWithUrl:
-				isSortable = true;
-				break;
-
-			case UIAnnotationTypes.DataFieldForIntentBasedNavigation:
-			case UIAnnotationTypes.DataFieldForAction:
-				// Action columns are not sortable
-				isSortable = false;
-				break;
-		}
-	}
-	return isSortable;
+	return (
+		nonSortableColumns.indexOf(propertyPath) === -1 && // Column is not marked as non-sortable via annotation
+		(dataField.$Type === UIAnnotationTypes.DataField ||
+			dataField.$Type === UIAnnotationTypes.DataFieldWithUrl ||
+			dataField.$Type === UIAnnotationTypes.DataFieldWithIntentBasedNavigation ||
+			dataField.$Type === UIAnnotationTypes.DataFieldWithAction)
+	);
 };
 
 /**
  * Returns whether filtering on the table is case sensitive.
  *
- * @param {ConverterContext} converterContext The instance of the converter context
- * @returns {boolean} Returns 'false' if FilterFunctions annotation supports 'tolower', else 'true'
+ * @param converterContext The instance of the converter context
+ * @returns Returns 'false' if FilterFunctions annotation supports 'tolower', else 'true'
  */
 export const isFilteringCaseSensitive = function (converterContext: ConverterContext): boolean {
 	const filterFunctions: FilterFunctions | undefined =
@@ -1956,7 +1910,7 @@ export const isFilteringCaseSensitive = function (converterContext: ConverterCon
 /**
  * Returns default format options for text fields in a table.
  *
- * @returns {FormatOptionsType} Collection of format options with default values
+ * @returns Collection of format options with default values
  */
 function getDefaultFormatOptionsForTable(): FormatOptionsType {
 	return {
@@ -2026,11 +1980,12 @@ function _findSemanticKeyValuesInFieldGroup(dataFieldGroup: DataFieldAbstractTyp
 
 /**
  * Returns default format options with draftIndicator for a column.
+ *
  * @param name
  * @param semanticKeys
  * @param isFieldGroupColumn
  * @param dataFieldGroup
- * @returns {FormatOptionsType} Collection of format options with default values
+ * @returns Collection of format options with default values
  */
 function getDefaultDraftIndicatorForColumn(
 	name: string,
@@ -2047,18 +2002,16 @@ function getDefaultDraftIndicatorForColumn(
 		return {
 			hasDraftIndicator: true,
 			semantickeys: semanticKey.values,
-			objectStatusTextVisibility: compileBinding(getRowStatusVisibility())
+			objectStatusTextVisibility: compileExpression(getRowStatusVisibility())
 		};
+	} else if (!semanticKeyInFieldGroup.semanticKeyHasPropertyInFieldGroup) {
+		return {};
 	} else {
-		if (!semanticKeyInFieldGroup.semanticKeyHasPropertyInFieldGroup) {
-			return {};
-		} else {
-			// Semantic Key has a property in a FieldGroup
-			return {
-				FieldGroupDraftIndicatorPropertyPath: semanticKeyInFieldGroup.propertyPath,
-				FieldGroupName: name
-			};
-		}
+		// Semantic Key has a property in a FieldGroup
+		return {
+			FieldGroupDraftIndicatorPropertyPath: semanticKeyInFieldGroup.propertyPath,
+			FieldGroupName: name
+		};
 	}
 }
 
@@ -2104,7 +2057,7 @@ function _getMaxImportance(fields: DataFieldTypes[]): Importance {
  *
  * @param dataField
  * @param semanticKeys
- * @returns {Importance} The importance value
+ * @returns The importance value
  */
 export function getImportance(dataField: DataFieldAbstractTypes, semanticKeys: SemanticKey): Importance | undefined {
 	//Evaluate default Importance is not set explicitly
@@ -2158,10 +2111,10 @@ export function getImportance(dataField: DataFieldAbstractTypes, semanticKeys: S
 /**
  * Returns line items from metadata annotations.
  *
- * @param {LineItem} lineItemAnnotation Collection of data fields with their annotations
- * @param {string} visualizationPath The visualization path
- * @param {ConverterContext} converterContext The converter context
- * @returns {TableColumn[]} The columns from the annotations
+ * @param lineItemAnnotation Collection of data fields with their annotations
+ * @param visualizationPath The visualization path
+ * @param converterContext The converter context
+ * @returns The columns from the annotations
  */
 const getColumnsFromAnnotations = function (
 	lineItemAnnotation: LineItem,
@@ -2179,7 +2132,7 @@ const getColumnsFromAnnotations = function (
 	])[0];
 	if (lineItemAnnotation) {
 		lineItemAnnotation.forEach((lineItem) => {
-			if (!_isValidColumn(lineItem)) {
+			if (!_isValidColumn(lineItem) || isReferencePropertyStaticallyHidden(lineItem)) {
 				return;
 			}
 			const semanticObjectAnnotationPath =
@@ -2187,9 +2140,24 @@ const getColumnsFromAnnotations = function (
 					? getSemanticObjectPath(converterContext, lineItem)
 					: undefined;
 			const relativePath = _getRelativePath(lineItem);
+			let relatedPropertyNames: string[];
 			// Determine properties which are consumed by this LineItem.
 			const relatedPropertiesInfo: ComplexPropertyInfo = collectRelatedPropertiesRecursively(lineItem, converterContext, tableType);
-			const relatedPropertyNames: string[] = Object.keys(relatedPropertiesInfo.properties);
+			const relatedProperties: any = relatedPropertiesInfo.properties;
+			if (
+				lineItem.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
+				lineItem.Target?.$target?.$Type === UIAnnotationTypes.FieldGroupType
+			) {
+				relatedPropertyNames = Object.keys(relatedPropertiesInfo.properties).filter((key) => {
+					let isStaticallyHidden;
+					if (relatedProperties[key].annotations?.UI)
+						isStaticallyHidden = isReferencePropertyStaticallyHidden(relatedProperties[key].annotations?.UI?.DataFieldDefault);
+					else isStaticallyHidden = isReferencePropertyStaticallyHidden(relatedProperties[key]);
+					return !isStaticallyHidden;
+				});
+			} else {
+				relatedPropertyNames = Object.keys(relatedPropertiesInfo.properties);
+			}
 			const additionalPropertyNames: string[] = Object.keys(relatedPropertiesInfo.additionalProperties);
 			const groupPath: string = _sliceAtSlash(relativePath, true, false);
 			const isGroup: boolean = groupPath != relativePath;
@@ -2205,7 +2173,7 @@ const getColumnsFromAnnotations = function (
 				...getDefaultFormatOptionsForTable(),
 				...getDefaultDraftIndicatorForColumn(name, semanticKeys, isFieldGroupColumn, lineItem)
 			};
-			let fieldGroupHiddenExpressions: BindingExpression<string>;
+			let fieldGroupHiddenExpressions: CompiledBindingToolkitExpression;
 			if (
 				lineItem.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
 				lineItem.Target?.$target?.$Type === UIAnnotationTypes.FieldGroupType
@@ -2247,7 +2215,7 @@ const getColumnsFromAnnotations = function (
 				// In case of text arrangement annotation with display mode as text only, exclude text property from the width calculation
 				visualSettings = {
 					widthCalculation: {
-						excludeProperties: ["Property::" + relatedPropertiesInfo.visualSettingsToBeExcluded]
+						excludeProperties: [`Property::${relatedPropertiesInfo.visualSettingsToBeExcluded}`]
 					}
 				};
 			} else if (!dataType || !oTypeConfig) {
@@ -2269,7 +2237,7 @@ const getColumnsFromAnnotations = function (
 				showDataFieldsLabel: showDataFieldsLabel,
 				relativePath: relativePath,
 				sortable: _isColumnSortable(lineItem, relativePath, nonSortableColumns),
-				propertyInfos: relatedPropertyNames.length > 0 ? relatedPropertyNames : undefined,
+				propertyInfos: relatedPropertyNames.length ? relatedPropertyNames : undefined,
 				additionalPropertyInfos: additionalPropertyNames.length > 0 ? additionalPropertyNames : undefined,
 				exportSettings: exportSettings,
 				width: lineItem.annotations?.HTML5?.CssDefaults?.width || undefined,
@@ -2280,7 +2248,8 @@ const getColumnsFromAnnotations = function (
 				caseSensitive: isFilteringCaseSensitive(converterContext),
 				typeConfig: oTypeConfig,
 				visualSettings: visualSettings,
-				timezoneText: exportSettings.timezone
+				timezoneText: exportSettings.timezone,
+				isPartOfLineItem: true
 			};
 			const sTooltip = _getTooltip(lineItem);
 			if (sTooltip) {
@@ -2290,44 +2259,31 @@ const getColumnsFromAnnotations = function (
 			annotationColumns.push(oColumn as AnnotationTableColumn);
 
 			// Collect information of related columns to be created.
-			relatedPropertyNames.forEach((name) => {
-				columnsToBeCreated[name] = relatedPropertiesInfo.properties[name];
+			relatedPropertyNames.forEach((relatedPropertyName) => {
+				columnsToBeCreated[relatedPropertyName] = relatedPropertiesInfo.properties[relatedPropertyName];
 			});
 
 			// Create columns for additional properties identified for ALP use case.
-			additionalPropertyNames.forEach((name) => {
+			additionalPropertyNames.forEach((additionalPropertyName) => {
 				// Intentional overwrite as we require only one new PropertyInfo for a related Property.
-				columnsToBeCreated[name] = relatedPropertiesInfo.additionalProperties[name];
+				columnsToBeCreated[additionalPropertyName] = relatedPropertiesInfo.additionalProperties[additionalPropertyName];
 			});
 		});
 	}
 
 	// Get columns from the Properties of EntityType
-	let tableColumns = getColumnsFromEntityType(
-		columnsToBeCreated,
-		entityType,
-		annotationColumns,
-		nonSortableColumns,
-		converterContext,
-		tableType
-	);
-	tableColumns = tableColumns.concat(annotationColumns);
-
-	// Create a propertyInfo for each related property.
-	const relatedColumns = _createRelatedColumns(columnsToBeCreated, tableColumns, nonSortableColumns, converterContext, entityType);
-	tableColumns = tableColumns.concat(relatedColumns);
-
-	return tableColumns;
+	return getColumnsFromEntityType(columnsToBeCreated, entityType, annotationColumns, nonSortableColumns, converterContext, tableType);
 };
 
 /**
  * Gets the property names from the manifest and checks against existing properties already added by annotations.
  * If a not yet stored property is found it adds it for sorting and filtering only to the annotationColumns.
- * @param {string[] | undefined} properties
- * @param {AnnotationTableColumn[]} annotationColumns
- * @param {ConverterContext} converterContext
+ *
+ * @param properties
+ * @param annotationColumns
+ * @param converterContext
  * @param entityType
- * @returns {string[]} The columns from the annotations
+ * @returns The columns from the annotations
  */
 const _getPropertyNames = function (
 	properties: string[] | undefined,
@@ -2374,10 +2330,10 @@ const _appendCustomTemplate = function (properties: string[]): string {
  * Manifest defined property value for custom / annotation columns
  * Default property value for custom column if not overwritten in manifest.
  *
- * @param {any} property The column property defined in the manifest
- * @param {any} defaultValue The default value of the property
- * @param {boolean} isAnnotationColumn Whether the column, defined in manifest, corresponds to an existing annotation column.
- * @returns {any} Determined property value for the column
+ * @param property The column property defined in the manifest
+ * @param defaultValue The default value of the property
+ * @param isAnnotationColumn Whether the column, defined in manifest, corresponds to an existing annotation column.
+ * @returns Determined property value for the column
  */
 const _getManifestOrDefaultValue = function (property: any, defaultValue: any, isAnnotationColumn: boolean): any {
 	if (property === undefined) {
@@ -2391,12 +2347,13 @@ const _getManifestOrDefaultValue = function (property: any, defaultValue: any, i
 
 /**
  * Returns table column definitions from manifest.
+ *
  * @param columns
  * @param annotationColumns
  * @param converterContext
  * @param entityType
  * @param navigationSettings
- * @returns {Record<string, CustomColumn>} The columns from the manifest
+ * @returns The columns from the manifest
  */
 const getColumnsFromManifest = function (
 	columns: Record<string, ManifestTableColumn>,
@@ -2419,7 +2376,7 @@ const getColumnsFromManifest = function (
 			entityType
 		);
 		if (!manifestColumn?.template && manifestColumn?.type !== "Slot" && !isAnnotationColumn) {
-			const Message = "The annotation column '" + key + "' referenced in the manifest is not found";
+			const Message = `The annotation column '${key}' referenced in the manifest is not found`;
 			converterContext
 				.getDiagnostics()
 				.addIssue(
@@ -2432,8 +2389,8 @@ const getColumnsFromManifest = function (
 		} else {
 			internalColumns[key] = {
 				key: key,
-				id: "CustomColumn::" + key,
-				name: "CustomColumn::" + key,
+				id: `CustomColumn::${key}`,
+				name: `CustomColumn::${key}`,
 				header: manifestColumn.header,
 				width: manifestColumn.width || undefined,
 				importance: _getManifestOrDefaultValue(manifestColumn?.importance, Importance.None, isAnnotationColumn),
@@ -2458,6 +2415,7 @@ const getColumnsFromManifest = function (
 					},
 					isAnnotationColumn
 				),
+				visualSettings: { widthCalculation: null },
 				exportSettings: {
 					template: propertyInfos ? _appendCustomTemplate(propertyInfos) : undefined,
 					wrap: propertyInfos && propertyInfos.length > 1 ? true : false
@@ -2545,9 +2503,9 @@ export function getP13nMode(
  * Chart has a dependency to filter bar (issue with loading data). Once resolved, the check for chart should be removed here.
  * Until then, hiding filter bar is now allowed if a chart is being used on LR.
  *
- * @param {ManifestWrapper} manifestWrapper Manifest settings getter for the page
- * @param {ConverterContext} converterContext The instance of the converter context
- * @returns {boolean} Boolean suggesting if a filter bar is being used on the page.
+ * @param manifestWrapper Manifest settings getter for the page
+ * @param converterContext The instance of the converter context
+ * @returns Boolean suggesting if a filter bar is being used on the page.
  */
 function _isFilterBarHidden(manifestWrapper: ManifestWrapper, converterContext: ConverterContext): boolean {
 	return (
@@ -2561,13 +2519,13 @@ function _isFilterBarHidden(manifestWrapper: ManifestWrapper, converterContext:
  * Returns a JSON string containing the sort conditions for the presentation variant.
  *
  * @param converterContext The instance of the converter context
- * @param {PresentationVariantTypeTypes | undefined} presentationVariantAnnotation Presentation variant annotation
+ * @param presentationVariantAnnotation Presentation variant annotation
  * @param columns Table columns processed by the converter
- * @returns {string | undefined} Sort conditions for a presentation variant.
+ * @returns Sort conditions for a presentation variant.
  */
 function getSortConditions(
 	converterContext: ConverterContext,
-	presentationVariantAnnotation: PresentationVariantTypeTypes | undefined,
+	presentationVariantAnnotation: PresentationVariantType | undefined,
 	columns: TableColumn[]
 ): string | undefined {
 	// Currently navigation property is not supported as sorter
@@ -2623,18 +2581,19 @@ function convertPropertyPathsToInfoNames(paths: PropertyPath[], columns: TableCo
 /**
  * Returns a JSON string containing Presentation Variant group conditions.
  *
- * @param {PresentationVariantTypeTypes | undefined} presentationVariantAnnotation Presentation variant annotation
+ * @param presentationVariantAnnotation Presentation variant annotation
  * @param columns Converter processed table columns
- * @returns {string | undefined} Group conditions for a Presentation variant.
+ * @param tableType The table type.
+ * @returns Group conditions for a Presentation variant.
  */
 function getGroupConditions(
-	presentationVariantAnnotation: PresentationVariantTypeTypes | undefined,
+	presentationVariantAnnotation: PresentationVariantType | undefined,
 	columns: TableColumn[],
 	tableType: string
 ): string | undefined {
 	let groupConditions: string | undefined;
 	if (presentationVariantAnnotation?.GroupBy) {
-		let aGroupBy = presentationVariantAnnotation.GroupBy as PropertyPath[];
+		let aGroupBy = presentationVariantAnnotation.GroupBy;
 		if (tableType === "ResponsiveTable") {
 			aGroupBy = aGroupBy.slice(0, 1);
 		}
@@ -2650,17 +2609,17 @@ function getGroupConditions(
 /**
  * Returns a JSON string containing Presentation Variant aggregate conditions.
  *
- * @param {PresentationVariantTypeTypes | undefined} presentationVariantAnnotation Presentation variant annotation
+ * @param presentationVariantAnnotation Presentation variant annotation
  * @param columns Converter processed table columns
- * @returns {string | undefined} Group conditions for a Presentation variant.
+ * @returns Group conditions for a Presentation variant.
  */
 function getAggregateConditions(
-	presentationVariantAnnotation: PresentationVariantTypeTypes | undefined,
+	presentationVariantAnnotation: PresentationVariantType | undefined,
 	columns: TableColumn[]
 ): string | undefined {
 	let aggregateConditions: string | undefined;
 	if (presentationVariantAnnotation?.Total) {
-		const aTotals = presentationVariantAnnotation.Total as PropertyPath[];
+		const aTotals = presentationVariantAnnotation.Total;
 		const aggregates: Record<string, object> = {};
 		convertPropertyPathsToInfoNames(aTotals, columns).forEach((infoName) => {
 			aggregates[infoName] = {};
@@ -2678,7 +2637,7 @@ export function getTableAnnotationConfiguration(
 	converterContext: ConverterContext,
 	tableManifestConfiguration: TableControlConfiguration,
 	columns: TableColumn[],
-	presentationVariantAnnotation?: PresentationVariantTypeTypes,
+	presentationVariantAnnotation?: PresentationVariantType,
 	viewConfiguration?: ViewPathConfiguration
 ): TableAnnotationConfiguration {
 	// Need to get the target
@@ -2688,7 +2647,7 @@ export function getTableAnnotationConfiguration(
 	const pageManifestSettings: ManifestWrapper = converterContext.getManifestWrapper();
 	const hasAbsolutePath = navigationPropertyPath.length === 0,
 		p13nMode: string | undefined = getP13nMode(visualizationPath, converterContext, tableManifestConfiguration),
-		id = navigationPropertyPath ? TableID(visualizationPath) : TableID(converterContext.getContextPath(), "LineItem");
+		id = navigationPropertyPath ? getTableID(visualizationPath) : getTableID(converterContext.getContextPath(), "LineItem");
 	const targetCapabilities = getCapabilityRestriction(converterContext);
 	const navigationTargetPath = getNavigationTargetPath(converterContext, navigationPropertyPath);
 	const navigationSettings = pageManifestSettings.getNavigationConfiguration(navigationTargetPath);
@@ -2712,7 +2671,7 @@ export function getTableAnnotationConfiguration(
 	const isInsertUpdateTemplated = getInsertUpdateActionsTemplating(
 		standardActionsContext,
 		isDraftOrStickySupported(converterContext),
-		compileBinding(createButtonVisibilityExpression) === "false"
+		compileExpression(createButtonVisibilityExpression) === "false"
 	);
 
 	const selectionMode = getSelectionMode(
@@ -2813,7 +2772,7 @@ function _getExportDataType(dataType: string, isComplexProperty: boolean = false
  * Split the visualization path into the navigation property path and annotation.
  *
  * @param visualizationPath
- * @returns {object}
+ * @returns The split path
  */
 export function splitPath(visualizationPath: string) {
 	let [navigationPropertyPath, annotationPath] = visualizationPath.split("@");
@@ -2836,9 +2795,9 @@ export function getSelectionVariantConfiguration(
 		const propertyNames: string[] = [];
 		selection.SelectOptions?.forEach((selectOption: SelectOptionType) => {
 			const propertyName: any = selectOption.PropertyName;
-			const PropertyPath: string = propertyName.value;
-			if (propertyNames.indexOf(PropertyPath) === -1) {
-				propertyNames.push(PropertyPath);
+			const propertyPath: string = propertyName.value;
+			if (propertyNames.indexOf(propertyPath) === -1) {
+				propertyNames.push(propertyPath);
 			}
 		});
 		return {
@@ -2896,17 +2855,11 @@ function _getTableType(
 	converterContext: ConverterContext
 ): TableType {
 	let tableType = tableSettings?.type || "ResponsiveTable";
-	if (converterContext.getTemplateType() !== "ObjectPage") {
-		if (tableSettings?.type === "AnalyticalTable" && !aggregationHelper.isAnalyticsSupported()) {
-			tableType = "GridTable";
-		}
-		if (!tableSettings?.type) {
-			if (converterContext.getManifestWrapper().isDesktop() && aggregationHelper.isAnalyticsSupported()) {
-				tableType = "AnalyticalTable";
-			} else {
-				tableType = "ResponsiveTable";
-			}
-		}
+	/*  Now, we keep the configuration in the manifest, even if it leads to errors.
+		We only change if we're not on desktop from Analytical to Responsive.
+	 */
+	if (tableType === "AnalyticalTable" && !converterContext.getManifestWrapper().isDesktop()) {
+		tableType = "ResponsiveTable";
 	}
 	return tableType;
 }
@@ -2954,7 +2907,7 @@ function _getFilterConfiguration(
 	let quickSelectionVariant: any;
 	let filters;
 	tableSettings?.quickVariantSelection?.paths?.forEach((path: { annotationPath: string }) => {
-		quickSelectionVariant = targetEntityType.resolvePath("@" + path.annotationPath);
+		quickSelectionVariant = targetEntityType.resolvePath(`@${path.annotationPath}`);
 		filters = _getFilters(tableSettings, quickFilterPaths, quickSelectionVariant, path, converterContext);
 	});
 
@@ -3011,7 +2964,8 @@ export function getTableManifestConfiguration(
 		showRowCount:
 			!tableSettings?.quickVariantSelection?.showCounts && !converterContext.getManifestWrapper().getViewConfiguration()?.showCounts,
 		type: tableType,
-		useCondensedTableLayout: condensedTableLayout && isCondensedTableLayoutCompliant
+		useCondensedTableLayout: condensedTableLayout && isCondensedTableLayoutCompliant,
+		isCompactType: converterContext.getManifestWrapper().isCompactType()
 	};
 
 	return { ...oConfiguration, ...oFilterConfiguration };
@@ -3068,7 +3022,7 @@ export function getTypeConfig(oProperty: Property | DataFieldAbstractTypes, data
 			isDigitSequence:
 				propertyTypeConfig.type === "sap.ui.model.odata.type.String" &&
 				oTargetMapping.constraints?.["@com.sap.vocabularies.Common.v1.IsDigitSequence"] &&
-				(oProperty as Property).annotations?.Common?.IsDigitSequence
+				oProperty.annotations?.Common?.IsDigitSequence
 					? true
 					: undefined
 		};
@@ -3088,3 +3042,23 @@ export function getTypeConfig(oProperty: Property | DataFieldAbstractTypes, data
 	};
 	return propertyTypeConfig;
 }
+
+export default {
+	getTableActions,
+	getTableColumns,
+	getColumnsFromEntityType,
+	updateLinkedProperties,
+	createTableVisualization,
+	createDefaultTableVisualization,
+	getCapabilityRestriction,
+	getSelectionMode,
+	getRowStatusVisibility,
+	getImportance,
+	getP13nMode,
+	getTableAnnotationConfiguration,
+	isFilteringCaseSensitive,
+	splitPath,
+	getSelectionVariantConfiguration,
+	getTableManifestConfiguration,
+	getTypeConfig
+};