@sapui5/sap.fe.core 1.100.0 → 1.102.0

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

@@ -1,3 +1,4 @@
+import { EntityType, Property, TypeDefinition } from "@sap-ux/annotation-converter";
 import {
 	CriticalityType,
 	DataField,
@@ -9,45 +10,18 @@ import {
 	DataPoint,
 	DataPointTypeTypes,
 	EnumValue,
+	FieldGroupType,
 	LineItem,
 	PathAnnotationExpression,
 	PresentationVariantTypeTypes,
 	PropertyPath,
 	SelectionVariantType,
 	SelectOptionType,
-	UIAnnotationTypes,
-	FieldGroupType
+	UIAnnotationTypes
 } from "@sap-ux/vocabularies-types";
-import {
-	ActionType,
-	AvailabilityType,
-	CreationMode,
-	FormatOptionsType,
-	HorizontalAlign,
-	Importance,
-	ManifestTableColumn,
-	NavigationSettingsConfiguration,
-	NavigationTargetConfiguration,
-	SelectionMode,
-	TableColumnSettings,
-	TableManifestConfiguration,
-	TableManifestSettingsConfiguration,
-	TemplateType,
-	VariantManagementType,
-	ViewPathConfiguration,
-	VisualizationType
-} from "../../ManifestSettings";
-import { EntityType, Property, TypeDefinition } from "@sap-ux/annotation-converter";
-import { TableID } from "../../helpers/ID";
-import {
-	AnnotationAction,
-	BaseAction,
-	CustomAction,
-	getActionsFromManifest,
-	isActionNavigable,
-	removeDuplicateActions
-} from "sap/fe/core/converters/controls/Common/Action";
-import { ConfigurableObject, CustomElement, insertCustomElements, Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
+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";
 import {
 	collectRelatedProperties,
 	collectRelatedPropertiesRecursively,
@@ -58,6 +32,20 @@ import {
 	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 { 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 {
 	and,
 	annotationExpression,
@@ -76,10 +64,7 @@ import {
 	or,
 	resolveBindingString
 } from "sap/fe/core/helpers/BindingExpression";
-import { Entity, bindingContextPathVisitor, UI } from "sap/fe/core/converters/helpers/BindingHelper";
-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 { replaceSpecialChars } from "sap/fe/core/helpers/StableIdHelper";
 import {
 	DataModelObjectPath,
 	getTargetObjectPath,
@@ -87,39 +72,55 @@ import {
 	isPathSearchable,
 	isPathUpdatable
 } from "sap/fe/core/templating/DataModelPathHelper";
-import { replaceSpecialChars } from "sap/fe/core/helpers/StableIdHelper";
-import { IssueCategory, IssueSeverity, IssueType, IssueCategoryType } from "sap/fe/core/converters/helpers/IssueManager";
-
-import ManifestWrapper from "../../ManifestWrapper";
-import ConverterContext from "../../ConverterContext";
+import { DisplayMode, EDM_TYPE_MAPPING, getDisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
+import { getNonSortablePropertiesRestrictions } from "sap/fe/core/templating/EntitySetHelper";
 import {
-	isProperty,
-	getAssociatedUnitProperty,
 	getAssociatedCurrencyProperty,
+	getAssociatedTimezoneProperty,
+	getAssociatedUnitProperty,
+	getTargetValueOnDataPoint,
 	isPathExpression,
-	getTargetValueOnDataPoint
+	isProperty
 } from "sap/fe/core/templating/PropertyHelper";
+import ConverterContext from "../../ConverterContext";
 import { AggregationHelper } from "../../helpers/Aggregation";
-import { DisplayMode, EDM_TYPE_MAPPING, getDisplayMode } from "sap/fe/core/templating/DisplayModeFormatter";
+import { TableID } from "../../helpers/ID";
+import {
+	ActionType,
+	AvailabilityType,
+	CreationMode,
+	FormatOptionsType,
+	HorizontalAlign,
+	Importance,
+	ManifestTableColumn,
+	NavigationSettingsConfiguration,
+	NavigationTargetConfiguration,
+	SelectionMode,
+	TableColumnSettings,
+	TableManifestConfiguration,
+	TableManifestSettingsConfiguration,
+	TemplateType,
+	VariantManagementType,
+	ViewPathConfiguration,
+	VisualizationType
+} from "../../ManifestSettings";
+import ManifestWrapper from "../../ManifestWrapper";
 import { getMessageTypeFromCriticalityType } from "./Criticality";
-import { FilterFunctions } from "@sap-ux/vocabularies-types/dist/generated/Capabilities";
-import { SemanticKey } from "@sap-ux/vocabularies-types/types/generated/Common";
-import { getNonSortablePropertiesRestrictions } from "sap/fe/core/templating/EntitySetHelper";
 import {
 	generateStandardActionsContext,
-	StandardActionConfigType,
+	getCreateVisibility,
+	getCreationRow,
 	getDeleteVisibility,
+	getInsertUpdateActionsTemplating,
+	getMassEditVisibility,
+	getRestrictions,
 	getStandardActionCreate,
 	getStandardActionDelete,
-	getStandardActionPaste,
 	getStandardActionMassEdit,
+	getStandardActionPaste,
 	isDraftOrStickySupported,
-	getInsertUpdateActionsTemplating,
-	getCreateVisibility,
 	isInDisplayMode,
-	getMassEditVisibility,
-	getRestrictions,
-	getCreationRow
+	StandardActionConfigType
 } from "./table/StandardActions";
 
 export type TableAnnotationConfiguration = {
@@ -135,6 +136,7 @@ export type TableAnnotationConfiguration = {
 		press?: string;
 		rowHighlighting: BindingExpression<MessageType>;
 		rowNavigated: BindingExpression<boolean>;
+		visible?: BindingExpression<boolean>;
 	};
 	selectionMode: string | undefined;
 	standardActions: {
@@ -211,6 +213,7 @@ export type TableControlConfiguration = {
 	enablePaste: boolean;
 	enableFullScreen: boolean;
 	showRowCount: boolean;
+	inlineCreationRowCount?: number;
 	enableMassEdit: boolean | undefined;
 	enableAutoColumnWidth: boolean;
 	dataStateIndicatorFilter: string | undefined;
@@ -236,6 +239,7 @@ export type BaseTableColumn = ConfigurableObject & {
 	propertyInfos?: string[];
 	caseSensitive?: boolean;
 	sortable: boolean;
+	isGroupable?: boolean;
 	horizontalAlign?: HorizontalAlign;
 	formatOptions: FormatOptionsType;
 	importance: string;
@@ -253,26 +257,26 @@ export type AnnotationTableColumn = BaseTableColumn & {
 	tooltip?: string;
 	groupLabel?: string;
 	group?: string;
-	isGroupable?: boolean;
 	FieldGroupHiddenExpressions?: BindingExpression<string>;
 	showDataFieldsLabel?: boolean;
 	isKey?: boolean;
 	unit?: string;
 	unitText?: string;
+	timezoneText?: string;
+	timezone?: string;
 	exportSettings?: {
 		template?: string;
 		label?: string;
-		fieldLabel?: string;
 		wrap?: boolean;
 		type?: string;
 		inputFormat?: string;
 		format?: string;
 		scale?: number;
 		delimiter?: boolean;
-		trueValue?: boolean;
-		falseValue?: boolean;
 		unit?: string;
 		unitProperty?: string;
+		timezone?: string;
+		timezoneProperty?: string;
 	};
 	isDataPointFakeTargetProperty?: boolean;
 	textArrangement?: {
@@ -296,7 +300,7 @@ export type WidthCalculation = null | {
 	includeLabel?: boolean;
 	gap?: number;
 	// only relevant for complex types
-	excludeProperties?: string | string[];
+	excludeProperties?: string[];
 	verticalArrangement?: boolean;
 };
 
@@ -322,6 +326,8 @@ export type TableVisualization = {
 	enableAnalyticsSearch?: boolean;
 	operationAvailableMap: string;
 	operationAvailableProperties: string;
+	headerInfoTitle: string;
+	semanticKeys: string[];
 };
 
 type SorterType = {
@@ -362,7 +368,8 @@ export function getTableActions(
 			enableOnSelect: "overwrite",
 			enableAutoScroll: "overwrite",
 			enabled: "overwrite",
-			defaultValuesExtensionFunction: "overwrite"
+			defaultValuesExtensionFunction: "overwrite",
+			command: "overwrite"
 		}
 	);
 }
@@ -411,7 +418,7 @@ export function getTableColumns(
  * @param converterContext The converter context.
  * @returns The aggregate definitions from the entityType, or undefined if the entity doesn't support analytical queries.
  */
-export const getAggregateDefinitionsFromEntityType = function(
+export const getAggregateDefinitionsFromEntityType = function (
 	entityType: EntityType,
 	tableColumns: TableColumn[],
 	converterContext: ConverterContext
@@ -419,7 +426,7 @@ export const getAggregateDefinitionsFromEntityType = function(
 	const aggregationHelper = new AggregationHelper(entityType, converterContext);
 
 	function findColumnFromPath(path: string): TableColumn | undefined {
-		return tableColumns.find(column => {
+		return tableColumns.find((column) => {
 			const annotationColumn = column as AnnotationTableColumn;
 			return annotationColumn.propertyInfos === undefined && annotationColumn.relativePath === path;
 		});
@@ -432,7 +439,7 @@ export const getAggregateDefinitionsFromEntityType = function(
 	// Keep a set of all currency/unit properties, as we don't want to consider them as aggregates
 	// They are aggregates for technical reasons (to manage multi-units situations) but it doesn't make sense from a user standpoint
 	const mCurrencyOrUnitProperties = new Set();
-	tableColumns.forEach(oColumn => {
+	tableColumns.forEach((oColumn) => {
 		const oTableColumn = oColumn as AnnotationTableColumn;
 		if (oTableColumn.unit) {
 			mCurrencyOrUnitProperties.add(oTableColumn.unit);
@@ -442,15 +449,15 @@ export const getAggregateDefinitionsFromEntityType = function(
 	const aCustomAggregateAnnotations = aggregationHelper.getCustomAggregateDefinitions();
 	const mRawDefinitions: Record<string, string[]> = {};
 
-	aCustomAggregateAnnotations.forEach(annotation => {
-		const oAggregatedProperty = aggregationHelper._entityType.entityProperties.find(oProperty => {
+	aCustomAggregateAnnotations.forEach((annotation) => {
+		const oAggregatedProperty = aggregationHelper._entityType.entityProperties.find((oProperty) => {
 			return oProperty.name === annotation.qualifier;
 		});
 
 		if (oAggregatedProperty) {
 			const aContextDefiningProperties = annotation.annotations?.Aggregation?.ContextDefiningProperties;
 			mRawDefinitions[oAggregatedProperty.name] = aContextDefiningProperties
-				? aContextDefiningProperties.map(oCtxDefProperty => {
+				? aContextDefiningProperties.map((oCtxDefProperty) => {
 						return oCtxDefProperty.value;
 				  })
 				: [];
@@ -458,7 +465,7 @@ export const getAggregateDefinitionsFromEntityType = function(
 	});
 	const mResult: Record<string, AggregateData> = {};
 
-	tableColumns.forEach(oColumn => {
+	tableColumns.forEach((oColumn) => {
 		const oTableColumn = oColumn as AnnotationTableColumn;
 		if (oTableColumn.propertyInfos === undefined && oTableColumn.relativePath) {
 			const aRawContextDefiningProperties = mRawDefinitions[oTableColumn.relativePath];
@@ -474,7 +481,7 @@ export const getAggregateDefinitionsFromEntityType = function(
 					relativePath: oTableColumn.relativePath
 				};
 				const aContextDefiningProperties: string[] = [];
-				aRawContextDefiningProperties.forEach(contextDefiningPropertyName => {
+				aRawContextDefiningProperties.forEach((contextDefiningPropertyName) => {
 					const oColumn = findColumnFromPath(contextDefiningPropertyName);
 					if (oColumn) {
 						aContextDefiningProperties.push(oColumn.name);
@@ -506,18 +513,22 @@ function updateTableVisualizationForAnalytics(
 	presentationVariantAnnotation?: PresentationVariantTypeTypes
 ) {
 	if (tableVisualization.control.type === "AnalyticalTable") {
-		const aggregatesDefinitions = getAggregateDefinitionsFromEntityType(entityType, tableVisualization.columns, converterContext);
+		const aggregatesDefinitions = getAggregateDefinitionsFromEntityType(entityType, tableVisualization.columns, converterContext),
+			aggregationHelper = new AggregationHelper(entityType, converterContext);
 
 		if (aggregatesDefinitions) {
 			tableVisualization.enableAnalytics = true;
 			tableVisualization.aggregates = aggregatesDefinitions;
 
-			const aggregationHelper = new AggregationHelper(entityType, converterContext);
 			const allowedTransformations = aggregationHelper.getAllowedTransformations();
 			tableVisualization.enableAnalyticsSearch = allowedTransformations ? allowedTransformations.indexOf("search") >= 0 : true;
 
 			// Add group and sort conditions from the presentation variant
-			tableVisualization.annotation.groupConditions = getGroupConditions(presentationVariantAnnotation, tableVisualization.columns);
+			tableVisualization.annotation.groupConditions = getGroupConditions(
+				presentationVariantAnnotation,
+				tableVisualization.columns,
+				tableVisualization.control.type
+			);
 			tableVisualization.annotation.aggregateConditions = getAggregateConditions(
 				presentationVariantAnnotation,
 				tableVisualization.columns
@@ -525,6 +536,12 @@ function updateTableVisualizationForAnalytics(
 		}
 
 		tableVisualization.control.type = "GridTable"; // AnalyticalTable isn't a real type for the MDC:Table, so we always switch back to Grid
+	} else if (tableVisualization.control.type === "ResponsiveTable") {
+		tableVisualization.annotation.groupConditions = getGroupConditions(
+			presentationVariantAnnotation,
+			tableVisualization.columns,
+			tableVisualization.control.type
+		);
 	}
 }
 
@@ -562,18 +579,20 @@ function getNavigationTargetPath(converterContext: ConverterContext, navigationP
  */
 export function updateLinkedProperties(entityType: EntityType, tableColumns: TableColumn[]) {
 	function findColumnByPath(path: string): TableColumn | undefined {
-		return tableColumns.find(column => {
+		return tableColumns.find((column) => {
 			const annotationColumn = column as AnnotationTableColumn;
 			return annotationColumn.propertyInfos === undefined && annotationColumn.relativePath === path;
 		});
 	}
 
-	tableColumns.forEach(oColumn => {
+	tableColumns.forEach((oColumn) => {
 		const oTableColumn = oColumn as AnnotationTableColumn;
 		if (oTableColumn.propertyInfos === undefined && oTableColumn.relativePath) {
 			const oProperty = entityType.entityProperties.find((oProp: Property) => oProp.name === oTableColumn.relativePath);
 			if (oProperty) {
 				const oUnit = getAssociatedCurrencyProperty(oProperty) || getAssociatedUnitProperty(oProperty);
+				const oTimezone = getAssociatedTimezoneProperty(oProperty);
+				const sTimezone = oProperty?.annotations?.Common?.Timezone;
 				if (oUnit) {
 					const oUnitColumn = findColumnByPath(oUnit.name);
 					oTableColumn.unit = oUnitColumn?.name;
@@ -583,6 +602,12 @@ export function updateLinkedProperties(entityType: EntityType, tableColumns: Tab
 						oTableColumn.unitText = `${sUnit}`;
 					}
 				}
+				if (oTimezone) {
+					const oTimezoneColumn = findColumnByPath(oTimezone.name);
+					oTableColumn.timezone = oTimezoneColumn?.name;
+				} else if (sTimezone) {
+					oTableColumn.timezoneText = sTimezone.toString();
+				}
 
 				const displayMode = getDisplayMode(oProperty),
 					textAnnotation = oProperty.annotations.Common?.Text;
@@ -600,6 +625,21 @@ 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;
+
+	let semanticKeyColumns: string[] = [];
+	if (semanticKeyAnnotations) {
+		semanticKeyAnnotations.forEach(function (oColumn: any) {
+			semanticKeyColumns.push(oColumn.value);
+		});
+	}
+
+	return { headerInfoTitlePath, semanticKeyColumns };
+}
+
 export function createTableVisualization(
 	lineItemAnnotation: LineItem,
 	visualizationPath: string,
@@ -619,7 +659,7 @@ export function createTableVisualization(
 	const navigationSettings = converterContext.getManifestWrapper().getNavigationConfiguration(navigationTargetPath);
 	const columns = getTableColumns(lineItemAnnotation, visualizationPath, converterContext, navigationSettings);
 	const operationAvailableMap = getOperationAvailableMap(lineItemAnnotation, converterContext);
-
+	const semanticKeysAndHeaderInfoTitle = getSemanticKeysAndTitleInfo(converterContext);
 	const oVisualization: TableVisualization = {
 		type: VisualizationType.Table,
 		annotation: getTableAnnotationConfiguration(
@@ -635,7 +675,9 @@ export function createTableVisualization(
 		actions: removeDuplicateActions(getTableActions(lineItemAnnotation, visualizationPath, converterContext, navigationSettings)),
 		columns: columns,
 		operationAvailableMap: JSON.stringify(operationAvailableMap),
-		operationAvailableProperties: getOperationAvailableProperties(operationAvailableMap, converterContext)
+		operationAvailableProperties: getOperationAvailableProperties(operationAvailableMap, converterContext),
+		headerInfoTitle: semanticKeysAndHeaderInfoTitle.headerInfoTitlePath,
+		semanticKeys: semanticKeysAndHeaderInfoTitle.semanticKeyColumns
 	};
 
 	updateLinkedProperties(converterContext.getAnnotationEntityType(lineItemAnnotation), columns);
@@ -653,6 +695,7 @@ export function createDefaultTableVisualization(converterContext: ConverterConte
 	const tableManifestConfig = getTableManifestConfiguration(undefined, "", converterContext, false);
 	const columns = getColumnsFromEntityType({}, converterContext.getEntityType(), [], [], converterContext, tableManifestConfig.type);
 	const operationAvailableMap = getOperationAvailableMap(undefined, converterContext);
+	const semanticKeysAndHeaderInfoTitle = getSemanticKeysAndTitleInfo(converterContext);
 	const oVisualization: TableVisualization = {
 		type: VisualizationType.Table,
 		annotation: getTableAnnotationConfiguration(undefined, "", converterContext, tableManifestConfig, columns),
@@ -660,7 +703,9 @@ export function createDefaultTableVisualization(converterContext: ConverterConte
 		actions: [],
 		columns: columns,
 		operationAvailableMap: JSON.stringify(operationAvailableMap),
-		operationAvailableProperties: getOperationAvailableProperties(operationAvailableMap, converterContext)
+		operationAvailableProperties: getOperationAvailableProperties(operationAvailableMap, converterContext),
+		headerInfoTitle: semanticKeysAndHeaderInfoTitle.headerInfoTitlePath,
+		semanticKeys: semanticKeysAndHeaderInfoTitle.semanticKeyColumns
 	};
 
 	updateLinkedProperties(converterContext.getEntityType(), columns);
@@ -678,14 +723,14 @@ export function createDefaultTableVisualization(converterContext: ConverterConte
  */
 function getOperationAvailableMap(lineItemAnnotation: LineItem | undefined, converterContext: ConverterContext): Record<string, any> {
 	const operationAvailableMap: Record<string, any> = {};
-	const addToMap = function(key: string, value: any) {
+	const addToMap = function (key: string, value: any) {
 		if (key) {
 			operationAvailableMap[key] = value;
 		}
 	};
 
 	if (lineItemAnnotation) {
-		lineItemAnnotation.forEach(dataField => {
+		lineItemAnnotation.forEach((dataField) => {
 			if (dataField.$Type === UIAnnotationTypes.DataFieldForAction) {
 				const actionName = dataField.Action as string;
 				if (actionName?.indexOf("/") < 0 && !dataField.Determining) {
@@ -783,7 +828,7 @@ function getUIHiddenExpForActionsRequiringContext(
 	isEntitySet: boolean
 ): Expression<boolean>[] {
 	const aUiHiddenPathExpressions: Expression<boolean>[] = [];
-	lineItemAnnotation.forEach(dataField => {
+	lineItemAnnotation.forEach((dataField) => {
 		// Check if the lineItem context is the same as that of the action:
 		if (
 			(dataField.$Type === UIAnnotationTypes.DataFieldForAction &&
@@ -877,7 +922,7 @@ function getBindingExpFromContext(
  * @returns {boolean} `true` if there is at least 1 action that meets the criteria
  */
 function hasBoundActionsAlwaysVisibleInToolBar(lineItemAnnotation: LineItem, currentEntityType: EntityType): boolean {
-	return lineItemAnnotation.some(dataField => {
+	return lineItemAnnotation.some((dataField) => {
 		if (
 			(dataField.$Type === UIAnnotationTypes.DataFieldForAction ||
 				dataField.$Type === UIAnnotationTypes.DataFieldForIntentBasedNavigation) &&
@@ -896,7 +941,7 @@ function hasBoundActionsAlwaysVisibleInToolBar(lineItemAnnotation: LineItem, cur
 }
 
 function hasCustomActionsAlwaysVisibleInToolBar(manifestActions: Record<string, CustomAction>): boolean {
-	return Object.keys(manifestActions).some(actionKey => {
+	return Object.keys(manifestActions).some((actionKey) => {
 		const action = manifestActions[actionKey];
 		if (action.requiresSelection && action.visible?.toString() === "true") {
 			return true;
@@ -915,7 +960,7 @@ function hasCustomActionsAlwaysVisibleInToolBar(manifestActions: Record<string,
 function getVisibleExpForCustomActionsRequiringContext(manifestActions: Record<string, CustomAction>): Expression<boolean>[] {
 	const aVisiblePathExpressions: Expression<boolean>[] = [];
 	if (manifestActions) {
-		Object.keys(manifestActions).forEach(actionKey => {
+		Object.keys(manifestActions).forEach((actionKey) => {
 			const action = manifestActions[actionKey];
 			if (action.requiresSelection === true && action.visible !== undefined) {
 				if (typeof action.visible === "string") {
@@ -983,7 +1028,7 @@ export function getSelectionMode(
 			// Mass Edit in OP is enabled only in edit mode.
 			return compileBinding(
 				ifElse(
-					and(equal(bindingExpression("/editMode", "ui"), "Editable"), massEditVisibilityExpression),
+					and(UI.IsEditable, massEditVisibilityExpression),
 					constant("Multi"),
 					ifElse(deleteButtonVisibilityExpression, constant("Multi"), constant("None"))
 				)
@@ -1031,11 +1076,7 @@ export function getSelectionMode(
 					massEditVisibilityExpression
 				);
 				return compileBinding(
-					ifElse(
-						and(equal(bindingExpression("/editMode", "ui"), "Editable"), buttonVisibilityExpression),
-						constant(selectionMode),
-						constant(SelectionMode.None)
-					)
+					ifElse(and(UI.IsEditable, buttonVisibilityExpression), constant(selectionMode), constant(SelectionMode.None))
 				);
 			} else {
 				return SelectionMode.None;
@@ -1062,7 +1103,7 @@ export function getSelectionMode(
 			);
 			return compileBinding(
 				ifElse(
-					and(equal(bindingExpression("/editMode", "ui"), "Editable"), editModebuttonVisibilityExpression),
+					and(UI.IsEditable, editModebuttonVisibilityExpression),
 					constant(selectionMode),
 					ifElse(
 						or(...aHiddenBindingExpressions.concat(aVisibleBindingExpressions)),
@@ -1220,15 +1261,17 @@ function _getCreationBehaviour(
 	lineItemAnnotation: LineItem | undefined,
 	tableManifestConfiguration: TableControlConfiguration,
 	converterContext: ConverterContext,
-	navigationSettings: NavigationSettingsConfiguration
+	navigationSettings: NavigationSettingsConfiguration,
+	visualizationPath: string
 ): TableAnnotationConfiguration["create"] {
 	const navigation = navigationSettings?.create || navigationSettings?.detail;
-
+	const tableManifestSettings: TableManifestConfiguration = converterContext.getManifestControlConfiguration(visualizationPath);
+	const originalTableSettings = (tableManifestSettings && tableManifestSettings.tableSettings) || {};
 	// cross-app
 	if (navigation?.outbound && navigation.outboundDetail && navigationSettings?.create) {
 		return {
 			mode: "External",
-			outbound: navigation.outbound as string,
+			outbound: navigation.outbound,
 			outboundDetail: navigation.outboundDetail,
 			navigationSettings: navigationSettings
 		};
@@ -1238,11 +1281,10 @@ function _getCreationBehaviour(
 	if (lineItemAnnotation) {
 		// in-app
 		const targetAnnotations = converterContext.getEntitySet()?.annotations;
-		newAction = targetAnnotations?.Common?.DraftRoot?.NewAction || targetAnnotations?.Session?.StickySessionSupported?.NewAction; // TODO: Is there really no 'NewAction' on DraftNode? targetAnnotations?.Common?.DraftNode?.NewAction
+		newAction = targetAnnotations?.Common?.DraftRoot?.NewAction || targetAnnotations?.Session?.StickySessionSupported?.NewAction;
 
 		if (tableManifestConfiguration.creationMode === CreationMode.CreationRow && newAction) {
 			// A combination of 'CreationRow' and 'NewAction' does not make sense
-			// TODO: Or does it?
 			throw Error(`Creation mode '${CreationMode.CreationRow}' can not be used with a custom 'new' action (${newAction})`);
 		}
 		if (navigation?.route) {
@@ -1259,6 +1301,10 @@ function _getCreationBehaviour(
 	// no navigation or no route specified - fallback to inline create if original creation mode was 'NewPage'
 	if (tableManifestConfiguration.creationMode === CreationMode.NewPage) {
 		tableManifestConfiguration.creationMode = CreationMode.Inline;
+		// In case there was no specific configuration for the createAtEnd we force it to false
+		if (originalTableSettings.creationMode?.createAtEnd === undefined) {
+			tableManifestConfiguration.createAtEnd = false;
+		}
 	}
 
 	return {
@@ -1268,7 +1314,7 @@ function _getCreationBehaviour(
 	};
 }
 
-const _getRowConfigurationProperty = function(
+const _getRowConfigurationProperty = function (
 	lineItemAnnotation: LineItem | undefined,
 	visualizationPath: string,
 	converterContext: ConverterContext,
@@ -1314,7 +1360,8 @@ const _getRowConfigurationProperty = function(
 		press: pressProperty,
 		action: pressProperty ? "Navigation" : undefined,
 		rowHighlighting: compileBinding(criticalityProperty),
-		rowNavigated: compileBinding(rowNavigatedExpression)
+		rowNavigated: compileBinding(rowNavigatedExpression),
+		visible: compileBinding(not(UI.IsInactive))
 	};
 };
 
@@ -1329,7 +1376,7 @@ const _getRowConfigurationProperty = function(
  * @param tableType The table type.
  * @returns {AnnotationTableColumn[]} The column from the entityType
  */
-export const getColumnsFromEntityType = function(
+export const getColumnsFromEntityType = function (
 	columnsToBeCreated: Record<string, Property>,
 	entityType: EntityType,
 	annotationColumns: AnnotationTableColumn[] = [],
@@ -1343,7 +1390,7 @@ export const getColumnsFromEntityType = function(
 
 	entityType.entityProperties.forEach((property: Property) => {
 		// Catch already existing columns - which were added before by LineItem Annotations
-		const exists = annotationColumns.some(column => {
+		const exists = annotationColumns.some((column) => {
 			return column.name === property.name;
 		});
 
@@ -1368,10 +1415,11 @@ export const getColumnsFromEntityType = function(
 				aggregationHelper,
 				converterContext
 			);
-			const semanticKeys = converterContext.getAnnotationsByTerm("Common", "com.sap.vocabularies.Common.v1.SemanticKey", [
+
+			const semanticKeys = converterContext.getAnnotationsByTerm("Common", CommonAnnotationTerms.SemanticKey, [
 				converterContext.getEntityType()
 			])[0];
-			const oColumnDraftIndicator = getDefaultDraftIndicatorForColumn(columnInfo.name, semanticKeys);
+			const oColumnDraftIndicator = getDefaultDraftIndicatorForColumn(columnInfo.name, semanticKeys, false, null);
 			if (Object.keys(oColumnDraftIndicator).length > 0) {
 				columnInfo.formatOptions = {
 					...oColumnDraftIndicator
@@ -1384,6 +1432,7 @@ export const getColumnsFromEntityType = function(
 					template: relatedPropertiesInfo.exportSettingsTemplate,
 					wrap: relatedPropertiesInfo.exportSettingsWrapping
 				};
+				columnInfo.exportSettings.type = _getExportDataType(property.type, relatedPropertyNames.length > 1);
 
 				if (relatedPropertiesInfo.exportUnitName) {
 					columnInfo.exportSettings.unitProperty = relatedPropertiesInfo.exportUnitName;
@@ -1391,9 +1440,14 @@ export const getColumnsFromEntityType = function(
 				} else if (relatedPropertiesInfo.exportUnitString) {
 					columnInfo.exportSettings.unit = relatedPropertiesInfo.exportUnitString;
 				}
+				if (relatedPropertiesInfo.exportTimezoneName) {
+					columnInfo.exportSettings.timezoneProperty = relatedPropertiesInfo.exportTimezoneName;
+				} else if (relatedPropertiesInfo.exportTimezoneString) {
+					columnInfo.exportSettings.timezone = relatedPropertiesInfo.exportTimezoneString;
+				}
 
 				// Collect information of related columns to be created.
-				relatedPropertyNames.forEach(name => {
+				relatedPropertyNames.forEach((name) => {
 					columnsToBeCreated[name] = relatedPropertiesInfo.properties[name];
 				});
 			}
@@ -1401,7 +1455,7 @@ export const getColumnsFromEntityType = function(
 			if (additionalPropertyNames.length > 0) {
 				columnInfo.additionalPropertyInfos = additionalPropertyNames;
 				// Create columns for additional properties identified for ALP use case.
-				additionalPropertyNames.forEach(name => {
+				additionalPropertyNames.forEach((name) => {
 					// Intentional overwrite as we require only one new PropertyInfo for a related Property.
 					columnsToBeCreated[name] = relatedPropertiesInfo.additionalProperties[name];
 				});
@@ -1424,7 +1478,7 @@ export const getColumnsFromEntityType = function(
  * @param {ConverterContext} converterContext The converter context
  * @returns {AnnotationTableColumn} The annotation column definition
  */
-const getColumnDefinitionFromProperty = function(
+const getColumnDefinitionFromProperty = function (
 	property: Property,
 	fullPropertyPath: string,
 	relativePath: string,
@@ -1445,6 +1499,10 @@ const getColumnDefinitionFromProperty = function(
 	const sDateInputFormat: string | undefined = property.type === "Edm.Date" ? "YYYY-MM-DD" : undefined;
 	const dataType: string | undefined = getDataFieldDataType(property);
 	const propertyTypeConfig = !isDataPointFakeProperty ? getTypeConfig(property, dataType) : undefined;
+	const semanticKeys: SemanticKey = converterContext.getAnnotationsByTerm("Common", CommonAnnotationTerms.SemanticKey, [
+		converterContext.getEntityType()
+	])[0];
+	const sortable = !isHidden && nonSortableColumns.indexOf(relativePath) === -1 && !isDataPointFakeProperty;
 	const oTypeConfig = !isDataPointFakeProperty
 		? {
 				className: property.type || dataType,
@@ -1460,25 +1518,29 @@ const getColumnDefinitionFromProperty = function(
 				type: exportType,
 				inputFormat: sDateInputFormat,
 				scale: property.scale,
-				delimiter: property.type === "Edm.Int64" ? true : false,
-				trueValue: property.type === "Edm.Boolean" ? "Yes" : undefined,
-				falseValue: property.type === "Edm.Boolean" ? "No" : undefined
+				delimiter: property.type === "Edm.Int64" ? true : false
 		  };
 
 	if (!isDataPointFakeProperty) {
 		const oUnitProperty = getAssociatedCurrencyProperty(property) || getAssociatedUnitProperty(property);
+		const oTimezoneProperty = getAssociatedTimezoneProperty(property);
 		const sUnitText = property?.annotations?.Measures?.ISOCurrency || property?.annotations?.Measures?.Unit;
+		const sTimezoneText = property?.annotations?.Common?.Timezone;
 		if (oUnitProperty) {
 			exportSettings.unitProperty = oUnitProperty.name;
 			exportSettings.type = "Currency"; // Force to a currency because there's a unitProperty (otherwise the value isn't properly formatted when exported)
 		} else if (sUnitText) {
 			exportSettings.unit = `${sUnitText}`;
 		}
+		if (oTimezoneProperty) {
+			exportSettings.timezoneProperty = oTimezoneProperty.name;
+		} else if (sTimezoneText) {
+			exportSettings.timezone = sTimezoneText.toString();
+		}
 	}
 
 	const oColumn: any = {
 		key: key,
-		isGroupable: !isDataPointFakeProperty && !isHidden ? aggregationHelper.isPropertyGroupable(property) : false,
 		type: ColumnType.Annotation,
 		label: _getLabel(property, isGroup),
 		groupLabel: isGroup ? _getLabel(property) : null,
@@ -1492,13 +1554,15 @@ const getColumnDefinitionFromProperty = function(
 		relativePath: isDataPointFakeProperty
 			? (property as any).annotations?.UI?.DataFieldDefault?.Target?.$target?.Value?.path || (property as any).Value.path
 			: relativePath,
-		sortable: !isHidden && nonSortableColumns.indexOf(relativePath) === -1 && !isDataPointFakeProperty,
+		sortable: sortable,
+		isGroupable: aggregationHelper.isAnalyticsSupported() ? aggregationHelper.isPropertyGroupable(property) : sortable,
 		isKey: property.isKey,
 		isDataPointFakeTargetProperty: isDataPointFakeProperty,
 		exportSettings: exportSettings,
 		caseSensitive: isFilteringCaseSensitive(converterContext),
 		typeConfig: oTypeConfig,
-		visualSettings: isDataPointFakeProperty ? { widthCalculation: null } : undefined
+		visualSettings: isDataPointFakeProperty ? { widthCalculation: null } : undefined,
+		importance: getImportance((property as any).annotations?.UI?.DataFieldDefault, semanticKeys)
 	};
 	const sTooltip = _getTooltip(property);
 	if (sTooltip) {
@@ -1515,7 +1579,7 @@ const getColumnDefinitionFromProperty = function(
  * @returns {boolean} True for valid columns, false for invalid columns
  * @private
  */
-const _isValidColumn = function(dataField: DataFieldAbstractTypes) {
+const _isValidColumn = function (dataField: DataFieldAbstractTypes) {
 	switch (dataField.$Type) {
 		case UIAnnotationTypes.DataFieldForAction:
 		case UIAnnotationTypes.DataFieldForIntentBasedNavigation:
@@ -1539,11 +1603,12 @@ 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 {DataModelObjectPath} dataFieldModelPath The metapath referring to the annotation that is evaluated by SAP Fiori elements.
- * @param {FieldFormatOptions} [formatOptions] FormatOptions is optional, used to check if the analytic table has GroupHeader expanded.
+ * @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.
  */
-export const _getVisibleExpression = function(
+export const _getVisibleExpression = function (
 	dataFieldModelPath: DataModelObjectPath,
 	formatOptions?: any,
 	returnExpression: boolean = false
@@ -1586,17 +1651,18 @@ export const _getVisibleExpression = function(
 			or(not(isAnalyticalGroupHeaderExpanded), isAnalyticalLeaf)
 		]
 	);
-	return returnExpression ? ((expression as any) as BindingExpression<string>) : compileBinding(expression);
+	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 {FieldFormatOptions} [fieldFormatOptions] FormatOptions is optional, used to check if the analytic table has GroupHeader expanded.
+ * @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.
  * @private
  */
-const _getFieldGroupHiddenExpressions = function(
+const _getFieldGroupHiddenExpressions = function (
 	dataFieldGroup: DataFieldAbstractTypes,
 	fieldFormatOptions: any
 ): BindingExpression<string> | undefined {
@@ -1611,7 +1677,7 @@ const _getFieldGroupHiddenExpressions = function(
 			);
 		});
 		return compileBinding(
-			ifElse(or(...((aFieldGroupHiddenExpressions as any) as ExpressionOrPrimitive<boolean>[])), constant(true), constant(false))
+			ifElse(or(...(aFieldGroupHiddenExpressions as any as ExpressionOrPrimitive<boolean>[])), constant(true), constant(false))
 		);
 	} else {
 		return undefined;
@@ -1625,7 +1691,7 @@ const _getFieldGroupHiddenExpressions = function(
  * @returns {string} Label of the property or DataField
  * @private
  */
-const _getLabel = function(property: DataFieldAbstractTypes | Property, isGroup: boolean = false): string | undefined {
+const _getLabel = function (property: DataFieldAbstractTypes | Property, isGroup: boolean = false): string | undefined {
 	if (!property) {
 		return undefined;
 	}
@@ -1655,7 +1721,7 @@ const _getLabel = function(property: DataFieldAbstractTypes | Property, isGroup:
 	}
 };
 
-const _getTooltip = function(source: DataFieldAbstractTypes | Property): string | undefined {
+const _getTooltip = function (source: DataFieldAbstractTypes | Property): string | undefined {
 	if (!source) {
 		return undefined;
 	}
@@ -1693,7 +1759,7 @@ export function getRowStatusVisibility(): Expression<boolean> {
  * @param entityType The entity type for the LineItem
  * @returns {AnnotationTableColumn[]} The array of columns created.
  */
-const _createRelatedColumns = function(
+const _createRelatedColumns = function (
 	columnsToBeCreated: Record<string, Property>,
 	existingColumns: AnnotationTableColumn[],
 	nonSortableColumns: string[],
@@ -1704,11 +1770,11 @@ const _createRelatedColumns = function(
 	const relatedPropertyNameMap: Record<string, string> = {};
 	const aggregationHelper = new AggregationHelper(entityType, converterContext);
 
-	Object.keys(columnsToBeCreated).forEach(name => {
+	Object.keys(columnsToBeCreated).forEach((name) => {
 		const property = columnsToBeCreated[name],
 			annotationPath = converterContext.getAbsoluteAnnotationPath(name),
 			// Check whether the related column already exists.
-			relatedColumn = existingColumns.find(column => column.name === name);
+			relatedColumn = existingColumns.find((column) => column.name === name);
 		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.
@@ -1735,7 +1801,7 @@ const _createRelatedColumns = function(
 			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)) {
+			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(
@@ -1757,10 +1823,10 @@ const _createRelatedColumns = function(
 
 	// The property 'name' has been prefixed with 'Property::' for uniqueness.
 	// Update the same in other propertyInfos[] references which point to this property.
-	existingColumns.forEach(column => {
-		column.propertyInfos = column.propertyInfos?.map(propertyInfo => relatedPropertyNameMap[propertyInfo] ?? propertyInfo);
+	existingColumns.forEach((column) => {
+		column.propertyInfos = column.propertyInfos?.map((propertyInfo) => relatedPropertyNameMap[propertyInfo] ?? propertyInfo);
 		column.additionalPropertyInfos = column.additionalPropertyInfos?.map(
-			propertyInfo => relatedPropertyNameMap[propertyInfo] ?? propertyInfo
+			(propertyInfo) => relatedPropertyNameMap[propertyInfo] ?? propertyInfo
 		);
 	});
 
@@ -1776,7 +1842,7 @@ const _createRelatedColumns = function(
  * @returns {string} The name of annotation columns
  * @private
  */
-const _getAnnotationColumnName = function(dataField: DataFieldAbstractTypes) {
+const _getAnnotationColumnName = function (dataField: DataFieldAbstractTypes) {
 	// This is needed as we have flexibility changes already that we have to check against
 	if (isDataFieldTypes(dataField)) {
 		return dataField.Value?.path;
@@ -1796,12 +1862,12 @@ const _getAnnotationColumnName = function(dataField: DataFieldAbstractTypes) {
  * @returns {boolean} `showDataFieldsLabel` value from the manifest
  * @private
  */
-const _getShowDataFieldsLabel = function(fieldGroupName: string, visualizationPath: string, converterContext: ConverterContext): boolean {
+const _getShowDataFieldsLabel = function (fieldGroupName: string, visualizationPath: string, converterContext: ConverterContext): boolean {
 	const oColumns = converterContext.getManifestControlConfiguration(visualizationPath)?.columns;
 	const aColumnKeys = oColumns && Object.keys(oColumns);
 	return (
 		aColumnKeys &&
-		!!aColumnKeys.find(function(key: string) {
+		!!aColumnKeys.find(function (key: string) {
 			return key === fieldGroupName && oColumns[key].showDataFieldsLabel;
 		})
 	);
@@ -1812,7 +1878,7 @@ const _getShowDataFieldsLabel = function(fieldGroupName: string, visualizationPa
  * @param dataField The `DataField` being processed.
  * @returns {string} The relative path
  */
-const _getRelativePath = function(dataField: DataFieldAbstractTypes): string {
+const _getRelativePath = function (dataField: DataFieldAbstractTypes): string {
 	let relativePath: string = "";
 
 	switch (dataField.$Type) {
@@ -1837,7 +1903,7 @@ const _getRelativePath = function(dataField: DataFieldAbstractTypes): string {
 	return relativePath;
 };
 
-const _sliceAtSlash = function(path: string, isLastSlash: boolean, isLastPart: boolean) {
+const _sliceAtSlash = function (path: string, isLastSlash: boolean, isLastPart: boolean) {
 	const iSlashIndex = isLastSlash ? path.lastIndexOf("/") : path.indexOf("/");
 
 	if (iSlashIndex === -1) {
@@ -1854,7 +1920,7 @@ const _sliceAtSlash = function(path: string, isLastSlash: boolean, isLastPart: b
  * @param nonSortableColumns Collection of non-sortable column names as per annotation
  * @returns {boolean} True if the column is sortable
  */
-const _isColumnSortable = function(dataField: DataFieldAbstractTypes, propertyPath: string, nonSortableColumns: string[]): boolean {
+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
@@ -1880,7 +1946,7 @@ const _isColumnSortable = function(dataField: DataFieldAbstractTypes, propertyPa
  * @param {ConverterContext} converterContext The instance of the converter context
  * @returns {boolean} Returns 'false' if FilterFunctions annotation supports 'tolower', else 'true'
  */
-export const isFilteringCaseSensitive = function(converterContext: ConverterContext): boolean {
+export const isFilteringCaseSensitive = function (converterContext: ConverterContext): boolean {
 	const filterFunctions: FilterFunctions | undefined =
 		converterContext.getEntitySet()?.annotations?.Capabilities?.FilterFunctions ||
 		converterContext.getEntityContainer().annotations?.Capabilities?.FilterFunctions;
@@ -1898,93 +1964,197 @@ function getDefaultFormatOptionsForTable(): FormatOptionsType {
 	};
 }
 
+function _findSemanticKeyValues(semanticKeys: any[], name: string): any {
+	const aSemanticKeyValues: string[] = [];
+	let bSemanticKeyFound = false;
+	for (let i = 0; i < semanticKeys.length; i++) {
+		aSemanticKeyValues.push(semanticKeys[i].value);
+		if (semanticKeys[i].value === name) {
+			bSemanticKeyFound = true;
+		}
+	}
+	return {
+		values: aSemanticKeyValues,
+		semanticKeyFound: bSemanticKeyFound
+	};
+}
+
+function _findProperties(semanticKeyValues: any[], fieldGroupProperties: any[]) {
+	let semanticKeyHasPropertyInFieldGroup = false;
+	let sPropertyPath;
+	if (semanticKeyValues && semanticKeyValues.length >= 1 && fieldGroupProperties && fieldGroupProperties.length >= 1) {
+		for (let i = 0; i < semanticKeyValues.length; i++) {
+			if ([semanticKeyValues[i]].some((tmp) => fieldGroupProperties.indexOf(tmp) >= 0)) {
+				semanticKeyHasPropertyInFieldGroup = true;
+				sPropertyPath = semanticKeyValues[i];
+				break;
+			}
+		}
+	}
+	return {
+		semanticKeyHasPropertyInFieldGroup: semanticKeyHasPropertyInFieldGroup,
+		fieldGroupPropertyPath: sPropertyPath
+	};
+}
+
+function _findSemanticKeyValuesInFieldGroup(dataFieldGroup: DataFieldAbstractTypes | null, semanticKeyValues: []): any {
+	const aProperties: any[] = [];
+	let _propertiesFound: { semanticKeyHasPropertyInFieldGroup: boolean; fieldGroupPropertyPath: any } = {
+		semanticKeyHasPropertyInFieldGroup: false,
+		fieldGroupPropertyPath: undefined
+	};
+	if (
+		dataFieldGroup &&
+		dataFieldGroup.$Type === UIAnnotationTypes.DataFieldForAnnotation &&
+		dataFieldGroup.Target?.$target?.$Type === UIAnnotationTypes.FieldGroupType
+	) {
+		dataFieldGroup.Target.$target.Data?.forEach((innerDataField: DataFieldAbstractTypes) => {
+			if (
+				(innerDataField.$Type === UIAnnotationTypes.DataField || innerDataField.$Type === UIAnnotationTypes.DataFieldWithUrl) &&
+				innerDataField.Value
+			) {
+				aProperties.push(innerDataField.Value.path);
+			}
+			_propertiesFound = _findProperties(semanticKeyValues, aProperties);
+		});
+	}
+	return {
+		semanticKeyHasPropertyInFieldGroup: _propertiesFound.semanticKeyHasPropertyInFieldGroup,
+		propertyPath: _propertiesFound.fieldGroupPropertyPath
+	};
+}
+
 /**
  * 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
  */
-function getDefaultDraftIndicatorForColumn(name: string, semanticKeys: any[]) {
-	let bSemanticKeyFound = false;
-	const aSemanticKeyValues: string[] = [];
+function getDefaultDraftIndicatorForColumn(
+	name: string,
+	semanticKeys: any[],
+	isFieldGroupColumn: boolean,
+	dataFieldGroup: DataFieldAbstractTypes | null
+) {
 	if (!semanticKeys) {
 		return {};
 	}
-	for (let i = 0; i < semanticKeys.length; i++) {
-		aSemanticKeyValues.push(semanticKeys[i].value);
-		if (semanticKeys[i].value === name) {
-			bSemanticKeyFound = true;
-		}
-	}
-	if (bSemanticKeyFound) {
+	const semanticKey = _findSemanticKeyValues(semanticKeys, name);
+	const semanticKeyInFieldGroup = _findSemanticKeyValuesInFieldGroup(dataFieldGroup, semanticKey.values);
+	if (semanticKey.semanticKeyFound) {
 		return {
 			hasDraftIndicator: true,
-			semantickeys: aSemanticKeyValues,
+			semantickeys: semanticKey.values,
 			objectStatusTextVisibility: compileBinding(getRowStatusVisibility())
 		};
 	} else {
-		return {};
+		if (!semanticKeyInFieldGroup.semanticKeyHasPropertyInFieldGroup) {
+			return {};
+		} else {
+			// Semantic Key has a property in a FieldGroup
+			return {
+				FieldGroupDraftIndicatorPropertyPath: semanticKeyInFieldGroup.propertyPath,
+				FieldGroupName: name
+			};
+		}
 	}
 }
 
-/**
- * Returns the importance value for an annotation column.
- * If it is not set explicitly via annotations, the default annotation importance is returned.
- *
- * @param lineItem
- * @param semanticKeys
- * @returns {Importance} The importance value
- */
-function _getAnnotationImportance(lineItem: DataFieldAbstractTypes, semanticKeys: SemanticKey): Importance {
-	switch (lineItem.annotations?.UI?.Importance) {
-		case "UI.ImportanceType/High":
-			return Importance.High;
-		case "UI.ImportanceType/Medium":
-			return Importance.Medium;
-		case "UI.ImportanceType/Low":
-			return Importance.Low;
-		default:
-			return _getDefaultAnnotationImportance(lineItem, semanticKeys);
+function _getImpNumber(dataField: DataFieldTypes): number {
+	const importance = dataField?.annotations?.UI?.Importance as string;
+
+	if (importance && importance.includes("UI.ImportanceType/High")) {
+		return 3;
+	}
+	if (importance && importance.includes("UI.ImportanceType/Medium")) {
+		return 2;
 	}
+	if (importance && importance.includes("UI.ImportanceType/Low")) {
+		return 1;
+	}
+	return 0;
+}
+
+function _getDataFieldImportance(dataField: DataFieldTypes): Importance {
+	const importance = dataField?.annotations?.UI?.Importance as string;
+	return importance ? (importance.split("/")[1] as Importance) : Importance.None;
+}
+
+function _getMaxImportance(fields: DataFieldTypes[]): Importance {
+	if (fields && fields.length > 0) {
+		let maxImpNumber = -1;
+		let impNumber = -1;
+		let DataFieldWithMaxImportance;
+		for (const field of fields) {
+			impNumber = _getImpNumber(field);
+			if (impNumber > maxImpNumber) {
+				maxImpNumber = impNumber;
+				DataFieldWithMaxImportance = field;
+			}
+		}
+		return _getDataFieldImportance(DataFieldWithMaxImportance as DataFieldTypes);
+	}
+	return Importance.None;
 }
 
 /**
- * Returns the default importance value for an annotation column as inferred by semantic key configurations.
+ * Returns the importance value for a column.
  *
- * @param lineItem
+ * @param dataField
  * @param semanticKeys
  * @returns {Importance} The importance value
  */
-function _getDefaultAnnotationImportance(lineItem: DataFieldAbstractTypes, semanticKeys: SemanticKey): Importance {
+export function getImportance(dataField: DataFieldAbstractTypes, semanticKeys: SemanticKey): Importance | undefined {
+	//Evaluate default Importance is not set explicitly
+	let fieldsWithImportance, mapSemanticKeys: any;
 	//Check if semanticKeys are defined at the EntitySet level
-	if (!semanticKeys || semanticKeys.length === 0) {
-		return Importance.None;
+	if (semanticKeys && semanticKeys.length > 0) {
+		mapSemanticKeys = semanticKeys.map(function (key) {
+			return key.value;
+		});
 	}
-
-	if (lineItem.$Type === UIAnnotationTypes.DataFieldForAnnotation) {
-		const targetDataField = (lineItem as DataFieldForAnnotation).Target?.$target;
-
+	if (!dataField) {
+		return undefined;
+	}
+	if (dataField.$Type === UIAnnotationTypes.DataFieldForAnnotation) {
+		const fieldGroupData = (dataField as any).Target["$target"]["Data"] as FieldGroupType,
+			fieldGroupHasSemanticKey =
+				fieldGroupData &&
+				(fieldGroupData as any).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 (targetDataField.$Type === UIAnnotationTypes.FieldGroupType) {
-			return ((targetDataField as unknown) as FieldGroupType).Data.some((dataField: DataFieldAbstractTypes) => {
-				return (
-					dataField.$Type !== UIAnnotationTypes.DataFieldForAnnotation &&
-					((dataField as unknown) as DataFieldTypes).Value &&
-					((dataField as unknown) as DataFieldTypes).Value.path &&
-					semanticKeys.find(semanticKey => semanticKey.value === ((dataField as unknown) as DataFieldTypes).Value.path)
-				);
-			})
-				? Importance.High
-				: Importance.None;
+		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 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 current field is a semanticKey, importance set to High
-	return semanticKeys.find(semanticKey => semanticKey.value === (lineItem as DataFieldTypes).Value?.path)
+	return (dataField as DataFieldTypes).Value &&
+		(dataField as DataFieldTypes)?.Value?.path &&
+		mapSemanticKeys &&
+		mapSemanticKeys.includes((dataField as DataFieldTypes).Value.path)
 		? Importance.High
-		: Importance.None;
+		: _getDataFieldImportance(dataField as unknown as DataFieldTypes);
 }
-
 /**
  * Returns line items from metadata annotations.
  *
@@ -1993,7 +2163,7 @@ function _getDefaultAnnotationImportance(lineItem: DataFieldAbstractTypes, seman
  * @param {ConverterContext} converterContext The converter context
  * @returns {TableColumn[]} The columns from the annotations
  */
-const getColumnsFromAnnotations = function(
+const getColumnsFromAnnotations = function (
 	lineItemAnnotation: LineItem,
 	visualizationPath: string,
 	converterContext: ConverterContext
@@ -2004,11 +2174,11 @@ const getColumnsFromAnnotations = function(
 		nonSortableColumns: string[] = getNonSortablePropertiesRestrictions(converterContext.getEntitySet()),
 		tableManifestSettings: TableManifestConfiguration = converterContext.getManifestControlConfiguration(visualizationPath),
 		tableType: TableType = tableManifestSettings?.tableSettings?.type || "ResponsiveTable";
-	const semanticKeys: SemanticKey = converterContext.getAnnotationsByTerm("Common", "com.sap.vocabularies.Common.v1.SemanticKey", [
+	const semanticKeys: SemanticKey = converterContext.getAnnotationsByTerm("Common", CommonAnnotationTerms.SemanticKey, [
 		converterContext.getEntityType()
 	])[0];
 	if (lineItemAnnotation) {
-		lineItemAnnotation.forEach(lineItem => {
+		lineItemAnnotation.forEach((lineItem) => {
 			if (!_isValidColumn(lineItem)) {
 				return;
 			}
@@ -2033,7 +2203,7 @@ const getColumnsFromAnnotations = function(
 			const sDateInputFormat: string | undefined = dataType === "Edm.Date" ? "YYYY-MM-DD" : undefined;
 			const formatOptions = {
 				...getDefaultFormatOptionsForTable(),
-				...getDefaultDraftIndicatorForColumn(name, semanticKeys)
+				...getDefaultDraftIndicatorForColumn(name, semanticKeys, isFieldGroupColumn, lineItem)
 			};
 			let fieldGroupHiddenExpressions: BindingExpression<string>;
 			if (
@@ -2047,9 +2217,7 @@ const getColumnsFromAnnotations = function(
 				wrap: relatedPropertiesInfo.exportSettingsWrapping,
 				type: dataType ? _getExportDataType(dataType, relatedPropertyNames.length > 1) : undefined,
 				inputFormat: sDateInputFormat,
-				delimiter: dataType === "Edm.Int64" ? true : false,
-				trueValue: dataType === "Edm.Boolean" ? "Yes" : undefined,
-				falseValue: dataType === "Edm.Boolean" ? "No" : undefined
+				delimiter: dataType === "Edm.Int64" ? true : false
 			};
 
 			if (relatedPropertiesInfo.exportUnitName) {
@@ -2058,6 +2226,11 @@ const getColumnsFromAnnotations = function(
 			} else if (relatedPropertiesInfo.exportUnitString) {
 				exportSettings.unit = relatedPropertiesInfo.exportUnitString;
 			}
+			if (relatedPropertiesInfo.exportTimezoneName) {
+				exportSettings.timezoneProperty = relatedPropertiesInfo.exportTimezoneName;
+			} else if (relatedPropertiesInfo.exportTimezoneString) {
+				exportSettings.timezone = relatedPropertiesInfo.exportTimezoneString;
+			}
 			const propertyTypeConfig = dataType && getTypeConfig(lineItem, dataType);
 			const oTypeConfig = propertyTypeConfig
 				? {
@@ -2082,18 +2255,6 @@ const getColumnsFromAnnotations = function(
 				visualSettings.widthCalculation = null;
 			}
 
-			// TODO: For situation POC - increase width of the column with the situations indicator - works for the situations demo app only!
-			// Might be a good idea to move the complete column width determination to the converter, that would allow us to widen
-			// the columns as needed. This workaround only deals with Date columns.
-			const { hasDraftIndicator } = getDefaultDraftIndicatorForColumn(name, semanticKeys);
-			const widthOverride =
-				(converterContext.getEntityType().annotations as any).FE?.Situations &&
-				hasDraftIndicator &&
-				lineItem.$Type === UIAnnotationTypes.DataField &&
-				lineItem.Value.$target.type === "Edm.Date"
-					? "11em"
-					: undefined;
-
 			const oColumn: any = {
 				key: KeyHelper.generateKeyFromDataField(lineItem),
 				type: ColumnType.Annotation,
@@ -2111,14 +2272,15 @@ const getColumnsFromAnnotations = function(
 				propertyInfos: relatedPropertyNames.length > 0 ? relatedPropertyNames : undefined,
 				additionalPropertyInfos: additionalPropertyNames.length > 0 ? additionalPropertyNames : undefined,
 				exportSettings: exportSettings,
-				width: lineItem.annotations?.HTML5?.CssDefaults?.width || widthOverride || undefined,
-				importance: _getAnnotationImportance(lineItem, semanticKeys),
+				width: lineItem.annotations?.HTML5?.CssDefaults?.width || undefined,
+				importance: getImportance(lineItem as DataFieldTypes, semanticKeys),
 				isNavigable: true,
 				formatOptions: formatOptions,
 				exportContactProperty: relatedPropertiesInfo.exportSettingsContactProperty,
 				caseSensitive: isFilteringCaseSensitive(converterContext),
 				typeConfig: oTypeConfig,
-				visualSettings: visualSettings
+				visualSettings: visualSettings,
+				timezoneText: exportSettings.timezone
 			};
 			const sTooltip = _getTooltip(lineItem);
 			if (sTooltip) {
@@ -2128,12 +2290,12 @@ const getColumnsFromAnnotations = function(
 			annotationColumns.push(oColumn as AnnotationTableColumn);
 
 			// Collect information of related columns to be created.
-			relatedPropertyNames.forEach(name => {
+			relatedPropertyNames.forEach((name) => {
 				columnsToBeCreated[name] = relatedPropertiesInfo.properties[name];
 			});
 
 			// Create columns for additional properties identified for ALP use case.
-			additionalPropertyNames.forEach(name => {
+			additionalPropertyNames.forEach((name) => {
 				// Intentional overwrite as we require only one new PropertyInfo for a related Property.
 				columnsToBeCreated[name] = relatedPropertiesInfo.additionalProperties[name];
 			});
@@ -2167,7 +2329,7 @@ const getColumnsFromAnnotations = function(
  * @param entityType
  * @returns {string[]} The columns from the annotations
  */
-const _getPropertyNames = function(
+const _getPropertyNames = function (
 	properties: string[] | undefined,
 	annotationColumns: AnnotationTableColumn[],
 	converterContext: ConverterContext,
@@ -2175,8 +2337,8 @@ const _getPropertyNames = function(
 ): string[] | undefined {
 	let matchedProperties: string[] | undefined;
 	if (properties) {
-		matchedProperties = properties.map(function(propertyPath) {
-			const annotationColumn = annotationColumns.find(function(annotationColumn) {
+		matchedProperties = properties.map(function (propertyPath) {
+			const annotationColumn = annotationColumns.find(function (annotationColumn) {
 				return annotationColumn.relativePath === propertyPath && annotationColumn.propertyInfos === undefined;
 			});
 			if (annotationColumn) {
@@ -2198,9 +2360,9 @@ const _getPropertyNames = function(
 	return matchedProperties;
 };
 
-const _appendCustomTemplate = function(properties: string[]): string {
+const _appendCustomTemplate = function (properties: string[]): string {
 	return properties
-		.map(property => {
+		.map((property) => {
 			return `{${properties.indexOf(property)}}`;
 		})
 		.join(`${"\n"}`);
@@ -2217,7 +2379,7 @@ const _appendCustomTemplate = function(properties: string[]): string {
  * @param {boolean} isAnnotationColumn Whether the column, defined in manifest, corresponds to an existing annotation column.
  * @returns {any} Determined property value for the column
  */
-const _getManifestOrDefaultValue = function(property: any, defaultValue: any, isAnnotationColumn: boolean): any {
+const _getManifestOrDefaultValue = function (property: any, defaultValue: any, isAnnotationColumn: boolean): any {
 	if (property === undefined) {
 		// If annotation column has no property defined in manifest,
 		// do not overwrite it with manifest column's default value.
@@ -2236,7 +2398,7 @@ const _getManifestOrDefaultValue = function(property: any, defaultValue: any, is
  * @param navigationSettings
  * @returns {Record<string, CustomColumn>} The columns from the manifest
  */
-const getColumnsFromManifest = function(
+const getColumnsFromManifest = function (
 	columns: Record<string, ManifestTableColumn>,
 	annotationColumns: AnnotationTableColumn[],
 	converterContext: ConverterContext,
@@ -2248,7 +2410,7 @@ const getColumnsFromManifest = function(
 	for (const key in columns) {
 		const manifestColumn = columns[key];
 		// To identify the annotation column property overwrite via manifest use-case.
-		const isAnnotationColumn = annotationColumns.some(column => column.key === key);
+		const isAnnotationColumn = annotationColumns.some((column) => column.key === key);
 		KeyHelper.validateKey(key);
 		const propertyInfos: string[] | undefined = _getPropertyNames(
 			manifestColumn.properties,
@@ -2286,6 +2448,7 @@ const getColumnsFromManifest = function(
 				isNavigable: isAnnotationColumn ? undefined : isActionNavigable(manifestColumn, navigationSettings, true),
 				settings: manifestColumn.settings,
 				sortable: false,
+				isGroupable: false,
 				propertyInfos: propertyInfos,
 				formatOptions: _getManifestOrDefaultValue(
 					manifestColumn.formatOptions,
@@ -2297,7 +2460,6 @@ const getColumnsFromManifest = function(
 				),
 				exportSettings: {
 					template: propertyInfos ? _appendCustomTemplate(propertyInfos) : undefined,
-					fieldLabel: propertyInfos ? manifestColumn.header : undefined,
 					wrap: propertyInfos && propertyInfos.length > 1 ? true : false
 				},
 				caseSensitive: isFilteringCaseSensitive(converterContext)
@@ -2316,13 +2478,21 @@ export function getP13nMode(
 	const tableManifestSettings: TableManifestConfiguration = converterContext.getManifestControlConfiguration(visualizationPath);
 	const variantManagement: VariantManagementType = manifestWrapper.getVariantManagement();
 	const aPersonalization: string[] = [];
-	const bAnalyticalTable = tableManifestConfiguration.type === "AnalyticalTable";
+	const isAnalyticalTable = tableManifestConfiguration.type === "AnalyticalTable";
+	const isResponsiveTable = tableManifestConfiguration.type === "ResponsiveTable";
 	if (tableManifestSettings?.tableSettings?.personalization !== undefined) {
 		// Personalization configured in manifest.
 		const personalization: any = tableManifestSettings.tableSettings.personalization;
 		if (personalization === true) {
 			// Table personalization fully enabled.
-			return bAnalyticalTable ? "Sort,Column,Filter,Group,Aggregate" : "Sort,Column,Filter";
+			switch (tableManifestConfiguration.type) {
+				case "AnalyticalTable":
+					return "Sort,Column,Filter,Group,Aggregate";
+				case "ResponsiveTable":
+					return "Sort,Column,Filter,Group";
+				default:
+					return "Sort,Column,Filter";
+			}
 		} else if (typeof personalization === "object") {
 			// Specific personalization options enabled in manifest. Use them as is.
 			if (personalization.sort) {
@@ -2334,10 +2504,10 @@ export function getP13nMode(
 			if (personalization.filter) {
 				aPersonalization.push("Filter");
 			}
-			if (personalization.group && bAnalyticalTable) {
+			if (personalization.group && (isAnalyticalTable || isResponsiveTable)) {
 				aPersonalization.push("Group");
 			}
-			if (personalization.aggregate && bAnalyticalTable) {
+			if (personalization.aggregate && isAnalyticalTable) {
 				aPersonalization.push("Aggregate");
 			}
 			return aPersonalization.length > 0 ? aPersonalization.join(",") : undefined;
@@ -2346,23 +2516,31 @@ export function getP13nMode(
 		// No personalization configured in manifest.
 		aPersonalization.push("Sort");
 		aPersonalization.push("Column");
-		if (variantManagement === VariantManagementType.Control || _isFilterBarHidden(manifestWrapper, converterContext)) {
-			// Feature parity with V2.
-			// Enable table filtering by default only in case of Control level variant management.
-			// Or when the LR filter bar is hidden via manifest setting
+		if (converterContext.getTemplateType() === TemplateType.ListReport) {
+			if (variantManagement === VariantManagementType.Control || _isFilterBarHidden(manifestWrapper, converterContext)) {
+				// Feature parity with V2.
+				// Enable table filtering by default only in case of Control level variant management.
+				// Or when the LR filter bar is hidden via manifest setting
+				aPersonalization.push("Filter");
+			}
+		} else {
 			aPersonalization.push("Filter");
 		}
-		if (bAnalyticalTable) {
+
+		if (isAnalyticalTable) {
 			aPersonalization.push("Group");
 			aPersonalization.push("Aggregate");
 		}
+		if (isResponsiveTable) {
+			aPersonalization.push("Group");
+		}
 		return aPersonalization.join(",");
 	}
 	return undefined;
 }
 
 /**
- * Returns a boolean suggesting if a filter bar is being used on the page.
+ * Returns a Boolean value suggesting if a filter bar is being used on the page.
  *
  * 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.
@@ -2400,7 +2578,7 @@ function getSortConditions(
 		const conditions = {
 			sorters: sorters
 		};
-		presentationVariantAnnotation.SortOrder.forEach(condition => {
+		presentationVariantAnnotation.SortOrder.forEach((condition) => {
 			const conditionProperty = condition.Property;
 			if (conditionProperty && nonSortableProperties.indexOf(conditionProperty.$target?.name) === -1) {
 				const infoName = convertPropertyPathsToInfoNames([conditionProperty], columns)[0];
@@ -2427,9 +2605,9 @@ function getSortConditions(
 
 function convertPropertyPathsToInfoNames(paths: PropertyPath[], columns: TableColumn[]): string[] {
 	const infoNames: string[] = [];
-	paths.forEach(currentPath => {
+	paths.forEach((currentPath) => {
 		if (currentPath?.$target?.name) {
-			const propertyInfo = columns.find(column => {
+			const propertyInfo = columns.find((column) => {
 				const annotationColumn = column as AnnotationTableColumn;
 				return !annotationColumn.propertyInfos && annotationColumn.relativePath === currentPath?.$target?.name;
 			});
@@ -2451,12 +2629,16 @@ function convertPropertyPathsToInfoNames(paths: PropertyPath[], columns: TableCo
  */
 function getGroupConditions(
 	presentationVariantAnnotation: PresentationVariantTypeTypes | undefined,
-	columns: TableColumn[]
+	columns: TableColumn[],
+	tableType: string
 ): string | undefined {
 	let groupConditions: string | undefined;
 	if (presentationVariantAnnotation?.GroupBy) {
-		const aGroupBy = presentationVariantAnnotation.GroupBy as PropertyPath[];
-		const aGroupLevels = convertPropertyPathsToInfoNames(aGroupBy, columns).map(infoName => {
+		let aGroupBy = presentationVariantAnnotation.GroupBy as PropertyPath[];
+		if (tableType === "ResponsiveTable") {
+			aGroupBy = aGroupBy.slice(0, 1);
+		}
+		const aGroupLevels = convertPropertyPathsToInfoNames(aGroupBy, columns).map((infoName) => {
 			return { name: infoName };
 		});
 
@@ -2480,7 +2662,7 @@ function getAggregateConditions(
 	if (presentationVariantAnnotation?.Total) {
 		const aTotals = presentationVariantAnnotation.Total as PropertyPath[];
 		const aggregates: Record<string, object> = {};
-		convertPropertyPathsToInfoNames(aTotals, columns).forEach(infoName => {
+		convertPropertyPathsToInfoNames(aTotals, columns).forEach((infoName) => {
 			aggregates[infoName] = {};
 		});
 
@@ -2510,7 +2692,13 @@ export function getTableAnnotationConfiguration(
 	const targetCapabilities = getCapabilityRestriction(converterContext);
 	const navigationTargetPath = getNavigationTargetPath(converterContext, navigationPropertyPath);
 	const navigationSettings = pageManifestSettings.getNavigationConfiguration(navigationTargetPath);
-	const creationBehaviour = _getCreationBehaviour(lineItemAnnotation, tableManifestConfiguration, converterContext, navigationSettings);
+	const creationBehaviour = _getCreationBehaviour(
+		lineItemAnnotation,
+		tableManifestConfiguration,
+		converterContext,
+		navigationSettings,
+		visualizationPath
+	);
 	const standardActionsContext = generateStandardActionsContext(
 		converterContext,
 		creationBehaviour.mode as CreationMode,
@@ -2588,6 +2776,9 @@ export function getTableAnnotationConfiguration(
 function _getExportDataType(dataType: string, isComplexProperty: boolean = false): string {
 	let exportDataType: string = "String";
 	if (isComplexProperty) {
+		if (dataType === "Edm.DateTimeOffset") {
+			exportDataType = "DateTime";
+		}
 		return exportDataType;
 	} else {
 		switch (dataType) {
@@ -2783,7 +2974,7 @@ export function getTableManifestConfiguration(
 ): TableControlConfiguration {
 	const tableManifestSettings: TableManifestConfiguration = converterContext.getManifestControlConfiguration(visualizationPath);
 	const tableSettings = (tableManifestSettings && tableManifestSettings.tableSettings) || {};
-	const creationMode = CreationMode.NewPage;
+	const creationMode = tableSettings.creationMode?.name || CreationMode.NewPage;
 	const enableAutoColumnWidth = !converterContext.getManifestWrapper().isPhone();
 	const enablePaste =
 		tableSettings.enablePaste !== undefined ? tableSettings.enablePaste : converterContext.getTemplateType() === "ObjectPage"; // Paste is disabled by default excepted for OP
@@ -2792,13 +2983,18 @@ export function getTableManifestConfiguration(
 	const isCondensedTableLayoutCompliant = checkCondensedLayout && converterContext.getManifestWrapper().isCondensedLayoutCompliant();
 	const oFilterConfiguration = _getFilterConfiguration(tableSettings, lineItemAnnotation, converterContext);
 	const customValidationFunction = tableSettings.creationMode?.customValidationFunction;
-	const condensedTableLayout = tableSettings.condensedTableLayout !== undefined ? tableSettings.condensedTableLayout : false;
 	const entityType = converterContext.getEntityType();
 	const aggregationHelper = new AggregationHelper(entityType, converterContext);
 	const tableType: TableType = _getTableType(tableSettings, aggregationHelper, converterContext);
+	const condensedTableLayout =
+		tableSettings.condensedTableLayout !== undefined && tableType !== "ResponsiveTable" ? tableSettings.condensedTableLayout : false;
 	const oConfiguration = {
-		createAtEnd: tableSettings.creationMode?.createAtEnd !== undefined ? tableSettings.creationMode?.createAtEnd : true,
-		creationMode: tableSettings.creationMode?.name || creationMode,
+		// If no createAtEnd is specified it will be false for Inline create and true otherwise
+		createAtEnd:
+			tableSettings.creationMode?.createAtEnd !== undefined
+				? tableSettings.creationMode?.createAtEnd
+				: creationMode !== CreationMode.Inline,
+		creationMode: creationMode,
 		customValidationFunction: customValidationFunction,
 		dataStateIndicatorFilter: dataStateIndicatorFilter,
 		// if a custom validation function is provided, disableAddRowButtonForEmptyData should not be considered, i.e. set to false
@@ -2811,7 +3007,7 @@ export function getTableManifestConfiguration(
 		headerVisible: true,
 		multiSelectMode: _getMultiSelectMode(tableSettings, tableType, converterContext),
 		selectionLimit: tableSettings.selectAll === true || tableSettings.selectionLimit === 0 ? 0 : tableSettings.selectionLimit || 200,
-
+		inlineCreationRowCount: tableSettings.creationMode?.inlineCreationRowCount ? tableSettings.creationMode?.inlineCreationRowCount : 2,
 		showRowCount:
 			!tableSettings?.quickVariantSelection?.showCounts && !converterContext.getManifestWrapper().getViewConfiguration()?.showCounts,
 		type: tableType,