@sapui5/sap.fe.core 1.95.0 → 1.98.0

package/src/sap/fe/core/converters/MetaModelConverter.ts

@@ -6,6 +6,7 @@ import {
 	ConverterOutput,
 	EntitySet as _EntitySet,
 	EntityType as _EntityType,
+	Singleton as _Singleton,
 	NavigationProperty as _NavigationProperty
 } from "@sap-ux/annotation-converter";
 import {
@@ -18,7 +19,8 @@ import {
 	Action,
 	Reference,
 	EntityContainer,
-	Singleton
+	Singleton,
+	TypeDefinition
 } from "@sap-ux/vocabularies-types/dist/Parser";
 import { Context } from "sap/ui/model";
 import { DataModelObjectPath } from "sap/fe/core/templating/DataModelPathHelper";
@@ -41,13 +43,15 @@ export type EnvironmentCapabilities = {
 	MicroChart: boolean;
 	UShell: boolean;
 	IntentBasedNavigation: boolean;
+	Situations: boolean;
 };
 
 export const DefaultEnvironmentCapabilities = {
 	Chart: true,
 	MicroChart: true,
 	UShell: true,
-	IntentBasedNavigation: true
+	IntentBasedNavigation: true,
+	Situations: false
 };
 
 type MetaModelAction = {
@@ -68,944 +72,871 @@ type MetaModelAction = {
 	};
 };
 
-const MetaModelConverter = {
-	parsePropertyValue(
-		annotationObject: any,
-		propertyKey: string,
-		currentTarget: string,
-		annotationsLists: any[],
-		oCapabilities: EnvironmentCapabilities
-	): any {
-		let value;
-		const currentPropertyTarget: string = currentTarget + "/" + propertyKey;
-		if (annotationObject === null) {
-			value = { type: "Null", Null: null };
-		} else if (typeof annotationObject === "string") {
-			value = { type: "String", String: annotationObject };
-		} else if (typeof annotationObject === "boolean") {
-			value = { type: "Bool", Bool: annotationObject };
-		} else if (typeof annotationObject === "number") {
-			value = { type: "Int", Int: annotationObject };
-		} else if (Array.isArray(annotationObject)) {
-			value = {
-				type: "Collection",
-				Collection: annotationObject.map((subAnnotationObject, subAnnotationObjectIndex) =>
-					this.parseAnnotationObject(
-						subAnnotationObject,
-						currentPropertyTarget + "/" + subAnnotationObjectIndex,
-						annotationsLists,
-						oCapabilities
-					)
+function parsePropertyValue(
+	annotationObject: any,
+	propertyKey: string,
+	currentTarget: string,
+	annotationsLists: Record<string, AnnotationList>,
+	oCapabilities: EnvironmentCapabilities
+): any {
+	let value;
+	const currentPropertyTarget: string = currentTarget + "/" + propertyKey;
+	const typeOfAnnotation = typeof annotationObject;
+	if (annotationObject === null) {
+		value = { type: "Null", Null: null };
+	} else if (typeOfAnnotation === "string") {
+		value = { type: "String", String: annotationObject };
+	} else if (typeOfAnnotation === "boolean") {
+		value = { type: "Bool", Bool: annotationObject };
+	} else if (typeOfAnnotation === "number") {
+		value = { type: "Int", Int: annotationObject };
+	} else if (Array.isArray(annotationObject)) {
+		value = {
+			type: "Collection",
+			Collection: annotationObject.map((subAnnotationObject, subAnnotationObjectIndex) =>
+				parseAnnotationObject(
+					subAnnotationObject,
+					currentPropertyTarget + "/" + subAnnotationObjectIndex,
+					annotationsLists,
+					oCapabilities
 				)
-			};
-			if (annotationObject.length > 0) {
-				if (annotationObject[0].hasOwnProperty("$PropertyPath")) {
-					(value.Collection as any).type = "PropertyPath";
-				} else if (annotationObject[0].hasOwnProperty("$Path")) {
-					(value.Collection as any).type = "Path";
-				} else if (annotationObject[0].hasOwnProperty("$NavigationPropertyPath")) {
-					(value.Collection as any).type = "NavigationPropertyPath";
-				} else if (annotationObject[0].hasOwnProperty("$AnnotationPath")) {
-					(value.Collection as any).type = "AnnotationPath";
-				} else if (annotationObject[0].hasOwnProperty("$Type")) {
-					(value.Collection as any).type = "Record";
-				} else if (annotationObject[0].hasOwnProperty("$If")) {
-					(value.Collection as any).type = "If";
-				} else if (annotationObject[0].hasOwnProperty("$Or")) {
-					(value.Collection as any).type = "Or";
-				} else if (annotationObject[0].hasOwnProperty("$And")) {
-					(value.Collection as any).type = "And";
-				} else if (annotationObject[0].hasOwnProperty("$Eq")) {
-					(value.Collection as any).type = "Eq";
-				} else if (annotationObject[0].hasOwnProperty("$Ne")) {
-					(value.Collection as any).type = "Ne";
-				} else if (annotationObject[0].hasOwnProperty("$Not")) {
-					(value.Collection as any).type = "Not";
-				} else if (annotationObject[0].hasOwnProperty("$Gt")) {
-					(value.Collection as any).type = "Gt";
-				} else if (annotationObject[0].hasOwnProperty("$Ge")) {
-					(value.Collection as any).type = "Ge";
-				} else if (annotationObject[0].hasOwnProperty("$Lt")) {
-					(value.Collection as any).type = "Lt";
-				} else if (annotationObject[0].hasOwnProperty("$Le")) {
-					(value.Collection as any).type = "Le";
-				} else if (annotationObject[0].hasOwnProperty("$Apply")) {
-					(value.Collection as any).type = "Apply";
-				} else if (typeof annotationObject[0] === "object") {
-					// $Type is optional...
-					(value.Collection as any).type = "Record";
-				} else {
-					(value.Collection as any).type = "String";
-				}
+			)
+		};
+		if (annotationObject.length > 0) {
+			if (annotationObject[0].hasOwnProperty("$PropertyPath")) {
+				(value.Collection as any).type = "PropertyPath";
+			} else if (annotationObject[0].hasOwnProperty("$Path")) {
+				(value.Collection as any).type = "Path";
+			} else if (annotationObject[0].hasOwnProperty("$NavigationPropertyPath")) {
+				(value.Collection as any).type = "NavigationPropertyPath";
+			} else if (annotationObject[0].hasOwnProperty("$AnnotationPath")) {
+				(value.Collection as any).type = "AnnotationPath";
+			} else if (annotationObject[0].hasOwnProperty("$Type")) {
+				(value.Collection as any).type = "Record";
+			} else if (annotationObject[0].hasOwnProperty("$If")) {
+				(value.Collection as any).type = "If";
+			} else if (annotationObject[0].hasOwnProperty("$Or")) {
+				(value.Collection as any).type = "Or";
+			} else if (annotationObject[0].hasOwnProperty("$And")) {
+				(value.Collection as any).type = "And";
+			} else if (annotationObject[0].hasOwnProperty("$Eq")) {
+				(value.Collection as any).type = "Eq";
+			} else if (annotationObject[0].hasOwnProperty("$Ne")) {
+				(value.Collection as any).type = "Ne";
+			} else if (annotationObject[0].hasOwnProperty("$Not")) {
+				(value.Collection as any).type = "Not";
+			} else if (annotationObject[0].hasOwnProperty("$Gt")) {
+				(value.Collection as any).type = "Gt";
+			} else if (annotationObject[0].hasOwnProperty("$Ge")) {
+				(value.Collection as any).type = "Ge";
+			} else if (annotationObject[0].hasOwnProperty("$Lt")) {
+				(value.Collection as any).type = "Lt";
+			} else if (annotationObject[0].hasOwnProperty("$Le")) {
+				(value.Collection as any).type = "Le";
+			} else if (annotationObject[0].hasOwnProperty("$Apply")) {
+				(value.Collection as any).type = "Apply";
+			} else if (typeof annotationObject[0] === "object") {
+				// $Type is optional...
+				(value.Collection as any).type = "Record";
+			} else {
+				(value.Collection as any).type = "String";
 			}
-		} else if (annotationObject.$Path !== undefined) {
-			value = { type: "Path", Path: annotationObject.$Path };
-		} else if (annotationObject.$Decimal !== undefined) {
-			value = { type: "Decimal", Decimal: parseFloat(annotationObject.$Decimal) };
-		} else if (annotationObject.$PropertyPath !== undefined) {
-			value = { type: "PropertyPath", PropertyPath: annotationObject.$PropertyPath };
-		} else if (annotationObject.$NavigationPropertyPath !== undefined) {
-			value = {
-				type: "NavigationPropertyPath",
-				NavigationPropertyPath: annotationObject.$NavigationPropertyPath
-			};
-		} else if (annotationObject.$If !== undefined) {
-			value = { type: "If", If: annotationObject.$If };
-		} else if (annotationObject.$And !== undefined) {
-			value = { type: "And", And: annotationObject.$And };
-		} else if (annotationObject.$Or !== undefined) {
-			value = { type: "Or", Or: annotationObject.$Or };
-		} else if (annotationObject.$Not !== undefined) {
-			value = { type: "Not", Not: annotationObject.$Not };
-		} else if (annotationObject.$Eq !== undefined) {
-			value = { type: "Eq", Eq: annotationObject.$Eq };
-		} else if (annotationObject.$Ne !== undefined) {
-			value = { type: "Ne", Ne: annotationObject.$Ne };
-		} else if (annotationObject.$Gt !== undefined) {
-			value = { type: "Gt", Gt: annotationObject.$Gt };
-		} else if (annotationObject.$Ge !== undefined) {
-			value = { type: "Ge", Ge: annotationObject.$Ge };
-		} else if (annotationObject.$Lt !== undefined) {
-			value = { type: "Lt", Lt: annotationObject.$Lt };
-		} else if (annotationObject.$Le !== undefined) {
-			value = { type: "Le", Le: annotationObject.$Le };
-		} else if (annotationObject.$Apply !== undefined) {
-			value = { type: "Apply", Apply: annotationObject.$Apply, Function: annotationObject.$Function };
-		} else if (annotationObject.$AnnotationPath !== undefined) {
-			value = { type: "AnnotationPath", AnnotationPath: annotationObject.$AnnotationPath };
-		} else if (annotationObject.$EnumMember !== undefined) {
-			value = {
-				type: "EnumMember",
-				EnumMember:
-					this.mapNameToAlias(annotationObject.$EnumMember.split("/")[0]) + "/" + annotationObject.$EnumMember.split("/")[1]
-			};
-		} else if (annotationObject.$Type) {
-			value = {
-				type: "Record",
-				Record: this.parseAnnotationObject(annotationObject, currentTarget, annotationsLists, oCapabilities)
-			};
-		} else {
-			value = {
-				type: "Record",
-				Record: this.parseAnnotationObject(annotationObject, currentTarget, annotationsLists, oCapabilities)
-			};
 		}
+	} else if (annotationObject.$Path !== undefined) {
+		value = { type: "Path", Path: annotationObject.$Path };
+	} else if (annotationObject.$Decimal !== undefined) {
+		value = { type: "Decimal", Decimal: parseFloat(annotationObject.$Decimal) };
+	} else if (annotationObject.$PropertyPath !== undefined) {
+		value = { type: "PropertyPath", PropertyPath: annotationObject.$PropertyPath };
+	} else if (annotationObject.$NavigationPropertyPath !== undefined) {
+		value = {
+			type: "NavigationPropertyPath",
+			NavigationPropertyPath: annotationObject.$NavigationPropertyPath
+		};
+	} else if (annotationObject.$If !== undefined) {
+		value = { type: "If", If: annotationObject.$If };
+	} else if (annotationObject.$And !== undefined) {
+		value = { type: "And", And: annotationObject.$And };
+	} else if (annotationObject.$Or !== undefined) {
+		value = { type: "Or", Or: annotationObject.$Or };
+	} else if (annotationObject.$Not !== undefined) {
+		value = { type: "Not", Not: annotationObject.$Not };
+	} else if (annotationObject.$Eq !== undefined) {
+		value = { type: "Eq", Eq: annotationObject.$Eq };
+	} else if (annotationObject.$Ne !== undefined) {
+		value = { type: "Ne", Ne: annotationObject.$Ne };
+	} else if (annotationObject.$Gt !== undefined) {
+		value = { type: "Gt", Gt: annotationObject.$Gt };
+	} else if (annotationObject.$Ge !== undefined) {
+		value = { type: "Ge", Ge: annotationObject.$Ge };
+	} else if (annotationObject.$Lt !== undefined) {
+		value = { type: "Lt", Lt: annotationObject.$Lt };
+	} else if (annotationObject.$Le !== undefined) {
+		value = { type: "Le", Le: annotationObject.$Le };
+	} else if (annotationObject.$Apply !== undefined) {
+		value = { type: "Apply", Apply: annotationObject.$Apply, Function: annotationObject.$Function };
+	} else if (annotationObject.$AnnotationPath !== undefined) {
+		value = { type: "AnnotationPath", AnnotationPath: annotationObject.$AnnotationPath };
+	} else if (annotationObject.$EnumMember !== undefined) {
+		value = {
+			type: "EnumMember",
+			EnumMember: mapNameToAlias(annotationObject.$EnumMember.split("/")[0]) + "/" + annotationObject.$EnumMember.split("/")[1]
+		};
+	} else if (annotationObject.$Type) {
+		value = {
+			type: "Record",
+			Record: parseAnnotationObject(annotationObject, currentTarget, annotationsLists, oCapabilities)
+		};
+	} else {
+		value = {
+			type: "Record",
+			Record: parseAnnotationObject(annotationObject, currentTarget, annotationsLists, oCapabilities)
+		};
+	}
 
-		return {
-			name: propertyKey,
-			value
+	return {
+		name: propertyKey,
+		value
+	};
+}
+function mapNameToAlias(annotationName: string): string {
+	let [pathPart, annoPart] = annotationName.split("@");
+	if (!annoPart) {
+		annoPart = pathPart;
+		pathPart = "";
+	} else {
+		pathPart += "@";
+	}
+	const lastDot = annoPart.lastIndexOf(".");
+	return pathPart + VOCABULARY_ALIAS[annoPart.substr(0, lastDot)] + "." + annoPart.substr(lastDot + 1);
+}
+function parseAnnotationObject(
+	annotationObject: any,
+	currentObjectTarget: string,
+	annotationsLists: Record<string, AnnotationList>,
+	oCapabilities: EnvironmentCapabilities
+): Expression | AnnotationRecord | Annotation {
+	let parsedAnnotationObject: any = {};
+	const typeOfObject = typeof annotationObject;
+	if (annotationObject === null) {
+		parsedAnnotationObject = { type: "Null", Null: null };
+	} else if (typeOfObject === "string") {
+		parsedAnnotationObject = { type: "String", String: annotationObject };
+	} else if (typeOfObject === "boolean") {
+		parsedAnnotationObject = { type: "Bool", Bool: annotationObject };
+	} else if (typeOfObject === "number") {
+		parsedAnnotationObject = { type: "Int", Int: annotationObject };
+	} else if (annotationObject.$AnnotationPath !== undefined) {
+		parsedAnnotationObject = { type: "AnnotationPath", AnnotationPath: annotationObject.$AnnotationPath };
+	} else if (annotationObject.$Path !== undefined) {
+		parsedAnnotationObject = { type: "Path", Path: annotationObject.$Path };
+	} else if (annotationObject.$Decimal !== undefined) {
+		parsedAnnotationObject = { type: "Decimal", Decimal: parseFloat(annotationObject.$Decimal) };
+	} else if (annotationObject.$PropertyPath !== undefined) {
+		parsedAnnotationObject = { type: "PropertyPath", PropertyPath: annotationObject.$PropertyPath };
+	} else if (annotationObject.$If !== undefined) {
+		parsedAnnotationObject = { type: "If", If: annotationObject.$If };
+	} else if (annotationObject.$And !== undefined) {
+		parsedAnnotationObject = { type: "And", And: annotationObject.$And };
+	} else if (annotationObject.$Or !== undefined) {
+		parsedAnnotationObject = { type: "Or", Or: annotationObject.$Or };
+	} else if (annotationObject.$Not !== undefined) {
+		parsedAnnotationObject = { type: "Not", Not: annotationObject.$Not };
+	} else if (annotationObject.$Eq !== undefined) {
+		parsedAnnotationObject = { type: "Eq", Eq: annotationObject.$Eq };
+	} else if (annotationObject.$Ne !== undefined) {
+		parsedAnnotationObject = { type: "Ne", Ne: annotationObject.$Ne };
+	} else if (annotationObject.$Gt !== undefined) {
+		parsedAnnotationObject = { type: "Gt", Gt: annotationObject.$Gt };
+	} else if (annotationObject.$Ge !== undefined) {
+		parsedAnnotationObject = { type: "Ge", Ge: annotationObject.$Ge };
+	} else if (annotationObject.$Lt !== undefined) {
+		parsedAnnotationObject = { type: "Lt", Lt: annotationObject.$Lt };
+	} else if (annotationObject.$Le !== undefined) {
+		parsedAnnotationObject = { type: "Le", Le: annotationObject.$Le };
+	} else if (annotationObject.$Apply !== undefined) {
+		parsedAnnotationObject = { type: "Apply", Apply: annotationObject.$Apply, Function: annotationObject.$Function };
+	} else if (annotationObject.$NavigationPropertyPath !== undefined) {
+		parsedAnnotationObject = {
+			type: "NavigationPropertyPath",
+			NavigationPropertyPath: annotationObject.$NavigationPropertyPath
+		};
+	} else if (annotationObject.$EnumMember !== undefined) {
+		parsedAnnotationObject = {
+			type: "EnumMember",
+			EnumMember: mapNameToAlias(annotationObject.$EnumMember.split("/")[0]) + "/" + annotationObject.$EnumMember.split("/")[1]
+		};
+	} else if (Array.isArray(annotationObject)) {
+		const parsedAnnotationCollection = parsedAnnotationObject as any;
+		parsedAnnotationCollection.collection = annotationObject.map((subAnnotationObject, subAnnotationIndex) =>
+			parseAnnotationObject(subAnnotationObject, currentObjectTarget + "/" + subAnnotationIndex, annotationsLists, oCapabilities)
+		);
+		if (annotationObject.length > 0) {
+			if (annotationObject[0].hasOwnProperty("$PropertyPath")) {
+				(parsedAnnotationCollection.collection as any).type = "PropertyPath";
+			} else if (annotationObject[0].hasOwnProperty("$Path")) {
+				(parsedAnnotationCollection.collection as any).type = "Path";
+			} else if (annotationObject[0].hasOwnProperty("$NavigationPropertyPath")) {
+				(parsedAnnotationCollection.collection as any).type = "NavigationPropertyPath";
+			} else if (annotationObject[0].hasOwnProperty("$AnnotationPath")) {
+				(parsedAnnotationCollection.collection as any).type = "AnnotationPath";
+			} else if (annotationObject[0].hasOwnProperty("$Type")) {
+				(parsedAnnotationCollection.collection as any).type = "Record";
+			} else if (annotationObject[0].hasOwnProperty("$If")) {
+				(parsedAnnotationCollection.collection as any).type = "If";
+			} else if (annotationObject[0].hasOwnProperty("$And")) {
+				(parsedAnnotationCollection.collection as any).type = "And";
+			} else if (annotationObject[0].hasOwnProperty("$Or")) {
+				(parsedAnnotationCollection.collection as any).type = "Or";
+			} else if (annotationObject[0].hasOwnProperty("$Eq")) {
+				(parsedAnnotationCollection.collection as any).type = "Eq";
+			} else if (annotationObject[0].hasOwnProperty("$Ne")) {
+				(parsedAnnotationCollection.collection as any).type = "Ne";
+			} else if (annotationObject[0].hasOwnProperty("$Not")) {
+				(parsedAnnotationCollection.collection as any).type = "Not";
+			} else if (annotationObject[0].hasOwnProperty("$Gt")) {
+				(parsedAnnotationCollection.collection as any).type = "Gt";
+			} else if (annotationObject[0].hasOwnProperty("$Ge")) {
+				(parsedAnnotationCollection.collection as any).type = "Ge";
+			} else if (annotationObject[0].hasOwnProperty("$Lt")) {
+				(parsedAnnotationCollection.collection as any).type = "Lt";
+			} else if (annotationObject[0].hasOwnProperty("$Le")) {
+				(parsedAnnotationCollection.collection as any).type = "Le";
+			} else if (annotationObject[0].hasOwnProperty("$Apply")) {
+				(parsedAnnotationCollection.collection as any).type = "Apply";
+			} else if (typeof annotationObject[0] === "object") {
+				(parsedAnnotationCollection.collection as any).type = "Record";
+			} else {
+				(parsedAnnotationCollection.collection as any).type = "String";
+			}
+		}
+	} else {
+		if (annotationObject.$Type) {
+			const typeValue = annotationObject.$Type;
+			parsedAnnotationObject.type = typeValue; //`${typeAlias}.${typeTerm}`;
+		}
+		const propertyValues: any = [];
+		Object.keys(annotationObject).forEach(propertyKey => {
+			if (
+				propertyKey !== "$Type" &&
+				propertyKey !== "$If" &&
+				propertyKey !== "$Apply" &&
+				propertyKey !== "$And" &&
+				propertyKey !== "$Or" &&
+				propertyKey !== "$Ne" &&
+				propertyKey !== "$Gt" &&
+				propertyKey !== "$Ge" &&
+				propertyKey !== "$Lt" &&
+				propertyKey !== "$Le" &&
+				propertyKey !== "$Not" &&
+				propertyKey !== "$Eq" &&
+				!propertyKey.startsWith("@")
+			) {
+				propertyValues.push(
+					parsePropertyValue(annotationObject[propertyKey], propertyKey, currentObjectTarget, annotationsLists, oCapabilities)
+				);
+			} else if (propertyKey.startsWith("@")) {
+				// Annotation of annotation
+				createAnnotationLists(
+					{ [propertyKey]: annotationObject[propertyKey] },
+					currentObjectTarget,
+					annotationsLists,
+					oCapabilities
+				);
+			}
+		});
+		parsedAnnotationObject.propertyValues = propertyValues;
+	}
+	return parsedAnnotationObject;
+}
+function getOrCreateAnnotationList(target: string, annotationsLists: Record<string, AnnotationList>): AnnotationList {
+	if (!annotationsLists.hasOwnProperty(target)) {
+		annotationsLists[target] = {
+			target: target,
+			annotations: []
 		};
-	},
-	mapNameToAlias(annotationName: string): string {
-		let [pathPart, annoPart] = annotationName.split("@");
-		if (!annoPart) {
-			annoPart = pathPart;
-			pathPart = "";
+	}
+	return annotationsLists[target];
+}
+
+function removeChartAnnotations(annotationObject: any) {
+	return annotationObject.filter((oRecord: any) => {
+		if (oRecord.Target && oRecord.Target.$AnnotationPath) {
+			return oRecord.Target.$AnnotationPath.indexOf("@com.sap.vocabularies.UI.v1.Chart") === -1;
+		} else {
+			return true;
+		}
+	});
+}
+
+function removeIBNAnnotations(annotationObject: any) {
+	return annotationObject.filter((oRecord: any) => {
+		return oRecord.$Type !== "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation";
+	});
+}
+
+function handlePresentationVariant(annotationObject: any) {
+	return annotationObject.filter((oRecord: any) => {
+		return oRecord.$AnnotationPath !== "@com.sap.vocabularies.UI.v1.Chart";
+	});
+}
+
+function createAnnotationLists(
+	annotationObjects: any,
+	annotationTarget: string,
+	annotationLists: Record<string, AnnotationList>,
+	oCapabilities: EnvironmentCapabilities
+) {
+	if (Object.keys(annotationObjects).length === 0) {
+		return;
+	}
+	const outAnnotationObject = getOrCreateAnnotationList(annotationTarget, annotationLists);
+	if (!oCapabilities.MicroChart) {
+		delete annotationObjects["@com.sap.vocabularies.UI.v1.Chart"];
+	}
+
+	for (let annotationKey in annotationObjects) {
+		let annotationObject = annotationObjects[annotationKey];
+		switch (annotationKey) {
+			case "@com.sap.vocabularies.UI.v1.HeaderFacets":
+				if (!oCapabilities.MicroChart) {
+					annotationObject = removeChartAnnotations(annotationObject);
+					annotationObjects[annotationKey] = annotationObject;
+				}
+				break;
+			case "@com.sap.vocabularies.UI.v1.Identification":
+				if (!oCapabilities.IntentBasedNavigation) {
+					annotationObject = removeIBNAnnotations(annotationObject);
+					annotationObjects[annotationKey] = annotationObject;
+				}
+				break;
+			case "@com.sap.vocabularies.UI.v1.LineItem":
+				if (!oCapabilities.IntentBasedNavigation) {
+					annotationObject = removeIBNAnnotations(annotationObject);
+					annotationObjects[annotationKey] = annotationObject;
+				}
+				if (!oCapabilities.MicroChart) {
+					annotationObject = removeChartAnnotations(annotationObject);
+					annotationObjects[annotationKey] = annotationObject;
+				}
+				break;
+			case "@com.sap.vocabularies.UI.v1.FieldGroup":
+				if (!oCapabilities.IntentBasedNavigation) {
+					annotationObject.Data = removeIBNAnnotations(annotationObject.Data);
+					annotationObjects[annotationKey] = annotationObject;
+				}
+				if (!oCapabilities.MicroChart) {
+					annotationObject.Data = removeChartAnnotations(annotationObject.Data);
+					annotationObjects[annotationKey] = annotationObject;
+				}
+				break;
+			case "@com.sap.vocabularies.UI.v1.PresentationVariant":
+				if (!oCapabilities.Chart && annotationObject.Visualizations) {
+					annotationObject.Visualizations = handlePresentationVariant(annotationObject.Visualizations);
+					annotationObjects[annotationKey] = annotationObject;
+				}
+				break;
+			default:
+				break;
+		}
+
+		let currentOutAnnotationObject = outAnnotationObject;
+
+		// Check for annotation of annotation
+		const annotationOfAnnotationSplit = annotationKey.split("@");
+		if (annotationOfAnnotationSplit.length > 2) {
+			currentOutAnnotationObject = getOrCreateAnnotationList(
+				annotationTarget + "@" + annotationOfAnnotationSplit[1],
+				annotationLists
+			);
+			annotationKey = annotationOfAnnotationSplit[2];
 		} else {
-			pathPart += "@";
+			annotationKey = annotationOfAnnotationSplit[1];
 		}
-		const lastDot = annoPart.lastIndexOf(".");
-		return pathPart + VOCABULARY_ALIAS[annoPart.substr(0, lastDot)] + "." + annoPart.substr(lastDot + 1);
-	},
-	parseAnnotationObject(
-		annotationObject: any,
-		currentObjectTarget: string,
-		annotationsLists: any[],
-		oCapabilities: EnvironmentCapabilities
-	): Expression | AnnotationRecord | Annotation {
-		let parsedAnnotationObject: any = {};
+
+		const annotationQualifierSplit = annotationKey.split("#");
+		const qualifier = annotationQualifierSplit[1];
+		annotationKey = annotationQualifierSplit[0];
+
+		const parsedAnnotationObject: any = {
+			term: `${annotationKey}`,
+			qualifier: qualifier
+		};
+		let currentAnnotationTarget = annotationTarget + "@" + parsedAnnotationObject.term;
+		if (qualifier) {
+			currentAnnotationTarget += "#" + qualifier;
+		}
+		let isCollection = false;
+		const typeofAnnotation = typeof annotationObject;
 		if (annotationObject === null) {
-			parsedAnnotationObject = { type: "Null", Null: null };
-		} else if (typeof annotationObject === "string") {
-			parsedAnnotationObject = { type: "String", String: annotationObject };
-		} else if (typeof annotationObject === "boolean") {
-			parsedAnnotationObject = { type: "Bool", Bool: annotationObject };
-		} else if (typeof annotationObject === "number") {
-			parsedAnnotationObject = { type: "Int", Int: annotationObject };
-		} else if (annotationObject.$AnnotationPath !== undefined) {
-			parsedAnnotationObject = { type: "AnnotationPath", AnnotationPath: annotationObject.$AnnotationPath };
-		} else if (annotationObject.$Path !== undefined) {
-			parsedAnnotationObject = { type: "Path", Path: annotationObject.$Path };
-		} else if (annotationObject.$Decimal !== undefined) {
-			parsedAnnotationObject = { type: "Decimal", Decimal: parseFloat(annotationObject.$Decimal) };
-		} else if (annotationObject.$PropertyPath !== undefined) {
-			parsedAnnotationObject = { type: "PropertyPath", PropertyPath: annotationObject.$PropertyPath };
+			parsedAnnotationObject.value = { type: "Bool", Bool: annotationObject };
+		} else if (typeofAnnotation === "string") {
+			parsedAnnotationObject.value = { type: "String", String: annotationObject };
+		} else if (typeofAnnotation === "boolean") {
+			parsedAnnotationObject.value = { type: "Bool", Bool: annotationObject };
+		} else if (typeofAnnotation === "number") {
+			parsedAnnotationObject.value = { type: "Int", Int: annotationObject };
 		} else if (annotationObject.$If !== undefined) {
-			parsedAnnotationObject = { type: "If", If: annotationObject.$If };
+			parsedAnnotationObject.value = { type: "If", If: annotationObject.$If };
 		} else if (annotationObject.$And !== undefined) {
-			parsedAnnotationObject = { type: "And", And: annotationObject.$And };
+			parsedAnnotationObject.value = { type: "And", And: annotationObject.$And };
 		} else if (annotationObject.$Or !== undefined) {
-			parsedAnnotationObject = { type: "Or", Or: annotationObject.$Or };
+			parsedAnnotationObject.value = { type: "Or", Or: annotationObject.$Or };
 		} else if (annotationObject.$Not !== undefined) {
-			parsedAnnotationObject = { type: "Not", Not: annotationObject.$Not };
+			parsedAnnotationObject.value = { type: "Not", Not: annotationObject.$Not };
 		} else if (annotationObject.$Eq !== undefined) {
-			parsedAnnotationObject = { type: "Eq", Eq: annotationObject.$Eq };
+			parsedAnnotationObject.value = { type: "Eq", Eq: annotationObject.$Eq };
 		} else if (annotationObject.$Ne !== undefined) {
-			parsedAnnotationObject = { type: "Ne", Ne: annotationObject.$Ne };
+			parsedAnnotationObject.value = { type: "Ne", Ne: annotationObject.$Ne };
 		} else if (annotationObject.$Gt !== undefined) {
-			parsedAnnotationObject = { type: "Gt", Gt: annotationObject.$Gt };
+			parsedAnnotationObject.value = { type: "Gt", Gt: annotationObject.$Gt };
 		} else if (annotationObject.$Ge !== undefined) {
-			parsedAnnotationObject = { type: "Ge", Ge: annotationObject.$Ge };
+			parsedAnnotationObject.value = { type: "Ge", Ge: annotationObject.$Ge };
 		} else if (annotationObject.$Lt !== undefined) {
-			parsedAnnotationObject = { type: "Lt", Lt: annotationObject.$Lt };
+			parsedAnnotationObject.value = { type: "Lt", Lt: annotationObject.$Lt };
 		} else if (annotationObject.$Le !== undefined) {
-			parsedAnnotationObject = { type: "Le", Le: annotationObject.$Le };
+			parsedAnnotationObject.value = { type: "Le", Le: annotationObject.$Le };
 		} else if (annotationObject.$Apply !== undefined) {
-			parsedAnnotationObject = { type: "Apply", Apply: annotationObject.$Apply, Function: annotationObject.$Function };
-		} else if (annotationObject.$NavigationPropertyPath !== undefined) {
-			parsedAnnotationObject = {
-				type: "NavigationPropertyPath",
-				NavigationPropertyPath: annotationObject.$NavigationPropertyPath
+			parsedAnnotationObject.value = { type: "Apply", Apply: annotationObject.$Apply, Function: annotationObject.$Function };
+		} else if (annotationObject.$Path !== undefined) {
+			parsedAnnotationObject.value = { type: "Path", Path: annotationObject.$Path };
+		} else if (annotationObject.$AnnotationPath !== undefined) {
+			parsedAnnotationObject.value = {
+				type: "AnnotationPath",
+				AnnotationPath: annotationObject.$AnnotationPath
 			};
+		} else if (annotationObject.$Decimal !== undefined) {
+			parsedAnnotationObject.value = { type: "Decimal", Decimal: parseFloat(annotationObject.$Decimal) };
 		} else if (annotationObject.$EnumMember !== undefined) {
-			parsedAnnotationObject = {
+			parsedAnnotationObject.value = {
 				type: "EnumMember",
-				EnumMember:
-					this.mapNameToAlias(annotationObject.$EnumMember.split("/")[0]) + "/" + annotationObject.$EnumMember.split("/")[1]
+				EnumMember: mapNameToAlias(annotationObject.$EnumMember.split("/")[0]) + "/" + annotationObject.$EnumMember.split("/")[1]
 			};
 		} else if (Array.isArray(annotationObject)) {
-			const parsedAnnotationCollection = parsedAnnotationObject as any;
-			parsedAnnotationCollection.collection = annotationObject.map((subAnnotationObject, subAnnotationIndex) =>
-				this.parseAnnotationObject(
+			isCollection = true;
+			parsedAnnotationObject.collection = annotationObject.map((subAnnotationObject, subAnnotationIndex) =>
+				parseAnnotationObject(
 					subAnnotationObject,
-					currentObjectTarget + "/" + subAnnotationIndex,
-					annotationsLists,
+					currentAnnotationTarget + "/" + subAnnotationIndex,
+					annotationLists,
 					oCapabilities
 				)
 			);
 			if (annotationObject.length > 0) {
 				if (annotationObject[0].hasOwnProperty("$PropertyPath")) {
-					(parsedAnnotationCollection.collection as any).type = "PropertyPath";
+					(parsedAnnotationObject.collection as any).type = "PropertyPath";
 				} else if (annotationObject[0].hasOwnProperty("$Path")) {
-					(parsedAnnotationCollection.collection as any).type = "Path";
+					(parsedAnnotationObject.collection as any).type = "Path";
 				} else if (annotationObject[0].hasOwnProperty("$NavigationPropertyPath")) {
-					(parsedAnnotationCollection.collection as any).type = "NavigationPropertyPath";
+					(parsedAnnotationObject.collection as any).type = "NavigationPropertyPath";
 				} else if (annotationObject[0].hasOwnProperty("$AnnotationPath")) {
-					(parsedAnnotationCollection.collection as any).type = "AnnotationPath";
+					(parsedAnnotationObject.collection as any).type = "AnnotationPath";
 				} else if (annotationObject[0].hasOwnProperty("$Type")) {
-					(parsedAnnotationCollection.collection as any).type = "Record";
+					(parsedAnnotationObject.collection as any).type = "Record";
 				} else if (annotationObject[0].hasOwnProperty("$If")) {
-					(parsedAnnotationCollection.collection as any).type = "If";
-				} else if (annotationObject[0].hasOwnProperty("$And")) {
-					(parsedAnnotationCollection.collection as any).type = "And";
+					(parsedAnnotationObject.collection as any).type = "If";
 				} else if (annotationObject[0].hasOwnProperty("$Or")) {
-					(parsedAnnotationCollection.collection as any).type = "Or";
+					(parsedAnnotationObject.collection as any).type = "Or";
 				} else if (annotationObject[0].hasOwnProperty("$Eq")) {
-					(parsedAnnotationCollection.collection as any).type = "Eq";
+					(parsedAnnotationObject.collection as any).type = "Eq";
 				} else if (annotationObject[0].hasOwnProperty("$Ne")) {
-					(parsedAnnotationCollection.collection as any).type = "Ne";
+					(parsedAnnotationObject.collection as any).type = "Ne";
 				} else if (annotationObject[0].hasOwnProperty("$Not")) {
-					(parsedAnnotationCollection.collection as any).type = "Not";
+					(parsedAnnotationObject.collection as any).type = "Not";
 				} else if (annotationObject[0].hasOwnProperty("$Gt")) {
-					(parsedAnnotationCollection.collection as any).type = "Gt";
+					(parsedAnnotationObject.collection as any).type = "Gt";
 				} else if (annotationObject[0].hasOwnProperty("$Ge")) {
-					(parsedAnnotationCollection.collection as any).type = "Ge";
+					(parsedAnnotationObject.collection as any).type = "Ge";
 				} else if (annotationObject[0].hasOwnProperty("$Lt")) {
-					(parsedAnnotationCollection.collection as any).type = "Lt";
+					(parsedAnnotationObject.collection as any).type = "Lt";
 				} else if (annotationObject[0].hasOwnProperty("$Le")) {
-					(parsedAnnotationCollection.collection as any).type = "Le";
+					(parsedAnnotationObject.collection as any).type = "Le";
+				} else if (annotationObject[0].hasOwnProperty("$And")) {
+					(parsedAnnotationObject.collection as any).type = "And";
 				} else if (annotationObject[0].hasOwnProperty("$Apply")) {
-					(parsedAnnotationCollection.collection as any).type = "Apply";
+					(parsedAnnotationObject.collection as any).type = "Apply";
 				} else if (typeof annotationObject[0] === "object") {
-					(parsedAnnotationCollection.collection as any).type = "Record";
+					(parsedAnnotationObject.collection as any).type = "Record";
 				} else {
-					(parsedAnnotationCollection.collection as any).type = "String";
+					(parsedAnnotationObject.collection as any).type = "String";
 				}
 			}
 		} else {
+			const record: AnnotationRecord = {
+				propertyValues: []
+			};
 			if (annotationObject.$Type) {
 				const typeValue = annotationObject.$Type;
-				parsedAnnotationObject.type = typeValue; //`${typeAlias}.${typeTerm}`;
+				record.type = `${typeValue}`;
 			}
-			const propertyValues: any = [];
-			Object.keys(annotationObject).forEach(propertyKey => {
-				if (
-					propertyKey !== "$Type" &&
-					propertyKey !== "$If" &&
-					propertyKey !== "$Apply" &&
-					propertyKey !== "$And" &&
-					propertyKey !== "$Or" &&
-					propertyKey !== "$Ne" &&
-					propertyKey !== "$Gt" &&
-					propertyKey !== "$Ge" &&
-					propertyKey !== "$Lt" &&
-					propertyKey !== "$Le" &&
-					propertyKey !== "$Not" &&
-					propertyKey !== "$Eq" &&
-					!propertyKey.startsWith("@")
-				) {
+			const propertyValues: any[] = [];
+			for (const propertyKey in annotationObject) {
+				if (propertyKey !== "$Type" && !propertyKey.startsWith("@")) {
 					propertyValues.push(
-						this.parsePropertyValue(
+						parsePropertyValue(
 							annotationObject[propertyKey],
 							propertyKey,
-							currentObjectTarget,
-							annotationsLists,
+							currentAnnotationTarget,
+							annotationLists,
 							oCapabilities
 						)
 					);
 				} else if (propertyKey.startsWith("@")) {
-					// Annotation of annotation
-					this.createAnnotationLists(
+					// Annotation of record
+					createAnnotationLists(
 						{ [propertyKey]: annotationObject[propertyKey] },
-						currentObjectTarget,
-						annotationsLists,
+						currentAnnotationTarget,
+						annotationLists,
 						oCapabilities
 					);
 				}
-			});
-			parsedAnnotationObject.propertyValues = propertyValues;
-		}
-		return parsedAnnotationObject;
-	},
-	getOrCreateAnnotationList(target: string, annotationsLists: AnnotationList[]): AnnotationList {
-		let potentialTarget = annotationsLists.find(annotationList => annotationList.target === target);
-		if (!potentialTarget) {
-			potentialTarget = {
-				target: target,
-				annotations: []
-			};
-			annotationsLists.push(potentialTarget);
+			}
+			record.propertyValues = propertyValues;
+			parsedAnnotationObject.record = record;
 		}
-		return potentialTarget;
-	},
+		parsedAnnotationObject.isCollection = isCollection;
+		currentOutAnnotationObject.annotations.push(parsedAnnotationObject);
+	}
+}
 
-	createAnnotationLists(
-		annotationObjects: any,
-		annotationTarget: string,
-		annotationLists: any[],
-		oCapabilities: EnvironmentCapabilities
-	) {
-		const outAnnotationObject = this.getOrCreateAnnotationList(annotationTarget, annotationLists);
-		if (!oCapabilities.MicroChart) {
-			delete annotationObjects["@com.sap.vocabularies.UI.v1.Chart"];
-		}
+function prepareProperty(propertyDefinition: any, entityTypeObject: EntityType | ComplexType, propertyName: string): Property {
+	const propertyObject: Property = {
+		_type: "Property",
+		name: propertyName,
+		fullyQualifiedName: `${entityTypeObject.fullyQualifiedName}/${propertyName}`,
+		type: propertyDefinition.$Type,
+		maxLength: propertyDefinition.$MaxLength,
+		precision: propertyDefinition.$Precision,
+		scale: propertyDefinition.$Scale,
+		nullable: propertyDefinition.$Nullable
+	};
+	return propertyObject;
+}
 
-		function removeChartAnnotations(annotationObject: any) {
-			return annotationObject.filter((oRecord: any) => {
-				if (oRecord.Target && oRecord.Target.$AnnotationPath) {
-					return oRecord.Target.$AnnotationPath.indexOf("@com.sap.vocabularies.UI.v1.Chart") === -1;
-				} else {
-					return true;
-				}
-			});
-		}
+function prepareNavigationProperty(
+	navPropertyDefinition: any,
+	entityTypeObject: EntityType | ComplexType,
+	navPropertyName: string
+): V4NavigationProperty {
+	let referentialConstraint: ReferentialConstraint[] = [];
+	if (navPropertyDefinition.$ReferentialConstraint) {
+		referentialConstraint = Object.keys(navPropertyDefinition.$ReferentialConstraint).map(sourcePropertyName => {
+			return {
+				sourceTypeName: entityTypeObject.name,
+				sourceProperty: sourcePropertyName,
+				targetTypeName: navPropertyDefinition.$Type,
+				targetProperty: navPropertyDefinition.$ReferentialConstraint[sourcePropertyName]
+			};
+		});
+	}
+	const navigationProperty: V4NavigationProperty = {
+		_type: "NavigationProperty",
+		name: navPropertyName,
+		fullyQualifiedName: `${entityTypeObject.fullyQualifiedName}/${navPropertyName}`,
+		partner: navPropertyDefinition.$Partner,
+		isCollection: navPropertyDefinition.$isCollection ? navPropertyDefinition.$isCollection : false,
+		containsTarget: navPropertyDefinition.$ContainsTarget,
+		targetTypeName: navPropertyDefinition.$Type,
+		referentialConstraint
+	};
 
-		function removeIBNAnnotations(annotationObject: any) {
-			return annotationObject.filter((oRecord: any) => {
-				return oRecord.$Type !== "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation";
-			});
-		}
+	return navigationProperty;
+}
 
-		function handlePresentationVariant(annotationObject: any) {
-			return annotationObject.filter((oRecord: any) => {
-				return oRecord.$AnnotationPath !== "@com.sap.vocabularies.UI.v1.Chart";
-			});
-		}
+function prepareEntitySet(entitySetDefinition: any, entitySetName: string, entityContainerName: string): EntitySet {
+	const entitySetObject: EntitySet = {
+		_type: "EntitySet",
+		name: entitySetName,
+		navigationPropertyBinding: {},
+		entityTypeName: entitySetDefinition.$Type,
+		fullyQualifiedName: `${entityContainerName}/${entitySetName}`
+	};
+	return entitySetObject;
+}
 
-		Object.keys(annotationObjects).forEach(annotationKey => {
-			let annotationObject = annotationObjects[annotationKey];
-			switch (annotationKey) {
-				case "@com.sap.vocabularies.UI.v1.HeaderFacets":
-					if (!oCapabilities.MicroChart) {
-						annotationObject = removeChartAnnotations(annotationObject);
-					}
-					break;
-				case "@com.sap.vocabularies.UI.v1.Identification":
-					if (!oCapabilities.IntentBasedNavigation) {
-						annotationObject = removeIBNAnnotations(annotationObject);
-					}
-					break;
-				case "@com.sap.vocabularies.UI.v1.LineItem":
-					if (!oCapabilities.IntentBasedNavigation) {
-						annotationObject = removeIBNAnnotations(annotationObject);
-					}
-					if (!oCapabilities.MicroChart) {
-						annotationObject = removeChartAnnotations(annotationObject);
-					}
-					break;
-				case "@com.sap.vocabularies.UI.v1.FieldGroup":
-					if (!oCapabilities.IntentBasedNavigation) {
-						annotationObject.Data = removeIBNAnnotations(annotationObject.Data);
-					}
-					if (!oCapabilities.MicroChart) {
-						annotationObject.Data = removeChartAnnotations(annotationObject.Data);
-					}
-					break;
-				case "@com.sap.vocabularies.UI.v1.PresentationVariant":
-					if (!oCapabilities.Chart && annotationObject.Visualizations) {
-						annotationObject.Visualizations = handlePresentationVariant(annotationObject.Visualizations);
-					}
-					break;
-				default:
-					break;
-			}
-			annotationObjects[annotationKey] = annotationObject;
-			let currentOutAnnotationObject = outAnnotationObject;
+function prepareSingleton(singletonDefinition: any, singletonName: string, entityContainerName: string): Singleton {
+	const singletonObject: Singleton = {
+		_type: "Singleton",
+		name: singletonName,
+		navigationPropertyBinding: {},
+		typeName: singletonDefinition.$Type,
+		fullyQualifiedName: `${entityContainerName}/${singletonName}`,
+		nullable: true
+	};
+	return singletonObject;
+}
 
-			// Check for annotation of annotation
-			const annotationOfAnnotationSplit = annotationKey.split("@");
-			if (annotationOfAnnotationSplit.length > 2) {
-				currentOutAnnotationObject = this.getOrCreateAnnotationList(
-					annotationTarget + "@" + annotationOfAnnotationSplit[1],
-					annotationLists
-				);
-				annotationKey = annotationOfAnnotationSplit[2];
-			} else {
-				annotationKey = annotationOfAnnotationSplit[1];
-			}
+function prepareTypeDefinition(typeDefinition: any, typeName: string, namespace: string): TypeDefinition {
+	const typeObject: TypeDefinition = {
+		_type: "TypeDefinition",
+		name: typeName.replace(namespace + ".", ""),
+		fullyQualifiedName: typeName,
+		underlyingType: typeDefinition.$UnderlyingType
+	};
+	return typeObject;
+}
 
-			const annotationQualifierSplit = annotationKey.split("#");
-			const qualifier = annotationQualifierSplit[1];
-			annotationKey = annotationQualifierSplit[0];
+function prepareComplexType(complexTypeDefinition: any, complexTypeName: string, namespace: string): ComplexType {
+	const complexTypeObject: ComplexType = {
+		_type: "ComplexType",
+		name: complexTypeName.replace(namespace + ".", ""),
+		fullyQualifiedName: complexTypeName,
+		properties: [],
+		navigationProperties: []
+	};
 
-			const parsedAnnotationObject: any = {
-				term: `${annotationKey}`,
-				qualifier: qualifier
-			};
-			let currentAnnotationTarget = annotationTarget + "@" + parsedAnnotationObject.term;
-			if (qualifier) {
-				currentAnnotationTarget += "#" + qualifier;
+	const complexTypeProperties = Object.keys(complexTypeDefinition)
+		.filter(propertyNameOrNot => {
+			if (propertyNameOrNot != "$Key" && propertyNameOrNot != "$kind") {
+				return complexTypeDefinition[propertyNameOrNot].$kind === "Property";
 			}
-			let isCollection = false;
-			if (annotationObject === null) {
-				parsedAnnotationObject.value = { type: "Bool", Bool: annotationObject };
-			} else if (typeof annotationObject === "string") {
-				parsedAnnotationObject.value = { type: "String", String: annotationObject };
-			} else if (typeof annotationObject === "boolean") {
-				parsedAnnotationObject.value = { type: "Bool", Bool: annotationObject };
-			} else if (typeof annotationObject === "number") {
-				parsedAnnotationObject.value = { type: "Int", Int: annotationObject };
-			} else if (annotationObject.$If !== undefined) {
-				parsedAnnotationObject.value = { type: "If", If: annotationObject.$If };
-			} else if (annotationObject.$And !== undefined) {
-				parsedAnnotationObject.value = { type: "And", And: annotationObject.$And };
-			} else if (annotationObject.$Or !== undefined) {
-				parsedAnnotationObject.value = { type: "Or", Or: annotationObject.$Or };
-			} else if (annotationObject.$Not !== undefined) {
-				parsedAnnotationObject.value = { type: "Not", Not: annotationObject.$Not };
-			} else if (annotationObject.$Eq !== undefined) {
-				parsedAnnotationObject.value = { type: "Eq", Eq: annotationObject.$Eq };
-			} else if (annotationObject.$Ne !== undefined) {
-				parsedAnnotationObject.value = { type: "Ne", Ne: annotationObject.$Ne };
-			} else if (annotationObject.$Gt !== undefined) {
-				parsedAnnotationObject.value = { type: "Gt", Gt: annotationObject.$Gt };
-			} else if (annotationObject.$Ge !== undefined) {
-				parsedAnnotationObject.value = { type: "Ge", Ge: annotationObject.$Ge };
-			} else if (annotationObject.$Lt !== undefined) {
-				parsedAnnotationObject.value = { type: "Lt", Lt: annotationObject.$Lt };
-			} else if (annotationObject.$Le !== undefined) {
-				parsedAnnotationObject.value = { type: "Le", Le: annotationObject.$Le };
-			} else if (annotationObject.$Apply !== undefined) {
-				parsedAnnotationObject.value = { type: "Apply", Apply: annotationObject.$Apply, Function: annotationObject.$Function };
-			} else if (annotationObject.$Path !== undefined) {
-				parsedAnnotationObject.value = { type: "Path", Path: annotationObject.$Path };
-			} else if (annotationObject.$AnnotationPath !== undefined) {
-				parsedAnnotationObject.value = {
-					type: "AnnotationPath",
-					AnnotationPath: annotationObject.$AnnotationPath
-				};
-			} else if (annotationObject.$Decimal !== undefined) {
-				parsedAnnotationObject.value = { type: "Decimal", Decimal: parseFloat(annotationObject.$Decimal) };
-			} else if (annotationObject.$EnumMember !== undefined) {
-				parsedAnnotationObject.value = {
-					type: "EnumMember",
-					EnumMember:
-						this.mapNameToAlias(annotationObject.$EnumMember.split("/")[0]) + "/" + annotationObject.$EnumMember.split("/")[1]
-				};
-			} else if (Array.isArray(annotationObject)) {
-				isCollection = true;
-				parsedAnnotationObject.collection = annotationObject.map((subAnnotationObject, subAnnotationIndex) =>
-					this.parseAnnotationObject(
-						subAnnotationObject,
-						currentAnnotationTarget + "/" + subAnnotationIndex,
-						annotationLists,
-						oCapabilities
-					)
-				);
-				if (annotationObject.length > 0) {
-					if (annotationObject[0].hasOwnProperty("$PropertyPath")) {
-						(parsedAnnotationObject.collection as any).type = "PropertyPath";
-					} else if (annotationObject[0].hasOwnProperty("$Path")) {
-						(parsedAnnotationObject.collection as any).type = "Path";
-					} else if (annotationObject[0].hasOwnProperty("$NavigationPropertyPath")) {
-						(parsedAnnotationObject.collection as any).type = "NavigationPropertyPath";
-					} else if (annotationObject[0].hasOwnProperty("$AnnotationPath")) {
-						(parsedAnnotationObject.collection as any).type = "AnnotationPath";
-					} else if (annotationObject[0].hasOwnProperty("$Type")) {
-						(parsedAnnotationObject.collection as any).type = "Record";
-					} else if (annotationObject[0].hasOwnProperty("$If")) {
-						(parsedAnnotationObject.collection as any).type = "If";
-					} else if (annotationObject[0].hasOwnProperty("$Or")) {
-						(parsedAnnotationObject.collection as any).type = "Or";
-					} else if (annotationObject[0].hasOwnProperty("$Eq")) {
-						(parsedAnnotationObject.collection as any).type = "Eq";
-					} else if (annotationObject[0].hasOwnProperty("$Ne")) {
-						(parsedAnnotationObject.collection as any).type = "Ne";
-					} else if (annotationObject[0].hasOwnProperty("$Not")) {
-						(parsedAnnotationObject.collection as any).type = "Not";
-					} else if (annotationObject[0].hasOwnProperty("$Gt")) {
-						(parsedAnnotationObject.collection as any).type = "Gt";
-					} else if (annotationObject[0].hasOwnProperty("$Ge")) {
-						(parsedAnnotationObject.collection as any).type = "Ge";
-					} else if (annotationObject[0].hasOwnProperty("$Lt")) {
-						(parsedAnnotationObject.collection as any).type = "Lt";
-					} else if (annotationObject[0].hasOwnProperty("$Le")) {
-						(parsedAnnotationObject.collection as any).type = "Le";
-					} else if (annotationObject[0].hasOwnProperty("$And")) {
-						(parsedAnnotationObject.collection as any).type = "And";
-					} else if (annotationObject[0].hasOwnProperty("$Apply")) {
-						(parsedAnnotationObject.collection as any).type = "Apply";
-					} else if (typeof annotationObject[0] === "object") {
-						(parsedAnnotationObject.collection as any).type = "Record";
-					} else {
-						(parsedAnnotationObject.collection as any).type = "String";
-					}
-				}
-			} else {
-				const record: AnnotationRecord = {
-					propertyValues: []
-				};
-				if (annotationObject.$Type) {
-					const typeValue = annotationObject.$Type;
-					record.type = `${typeValue}`;
-				}
-				const propertyValues: any[] = [];
-				Object.keys(annotationObject).forEach(propertyKey => {
-					if (propertyKey !== "$Type" && !propertyKey.startsWith("@")) {
-						propertyValues.push(
-							this.parsePropertyValue(
-								annotationObject[propertyKey],
-								propertyKey,
-								currentAnnotationTarget,
-								annotationLists,
-								oCapabilities
-							)
-						);
-					} else if (propertyKey.startsWith("@")) {
-						// Annotation of record
-						this.createAnnotationLists(
-							{ [propertyKey]: annotationObject[propertyKey] },
-							currentAnnotationTarget,
-							annotationLists,
-							oCapabilities
-						);
-					}
-				});
-				record.propertyValues = propertyValues;
-				parsedAnnotationObject.record = record;
-			}
-			parsedAnnotationObject.isCollection = isCollection;
-			currentOutAnnotationObject.annotations.push(parsedAnnotationObject);
+		})
+		.sort((a, b) => (a > b ? 1 : -1))
+		.map(propertyName => {
+			return prepareProperty(complexTypeDefinition[propertyName], complexTypeObject, propertyName);
 		});
-	},
-	parseProperty(
-		oMetaModel: any,
-		entityTypeObject: EntityType | ComplexType,
-		propertyName: string,
-		annotationLists: AnnotationList[],
-		oCapabilities: EnvironmentCapabilities
-	): Property {
-		const propertyAnnotation = oMetaModel.getObject(`/${entityTypeObject.fullyQualifiedName}/${propertyName}@`);
-		const propertyDefinition = oMetaModel.getObject(`/${entityTypeObject.fullyQualifiedName}/${propertyName}`);
-
-		const propertyObject: Property = {
-			_type: "Property",
-			name: propertyName,
-			fullyQualifiedName: `${entityTypeObject.fullyQualifiedName}/${propertyName}`,
-			type: propertyDefinition.$Type,
-			maxLength: propertyDefinition.$MaxLength,
-			precision: propertyDefinition.$Precision,
-			scale: propertyDefinition.$Scale,
-			nullable: propertyDefinition.$Nullable
-		};
-
-		this.createAnnotationLists(propertyAnnotation, propertyObject.fullyQualifiedName, annotationLists, oCapabilities);
 
-		return propertyObject;
-	},
-	parseNavigationProperty(
-		oMetaModel: any,
-		entityTypeObject: EntityType | ComplexType,
-		navPropertyName: string,
-		annotationLists: AnnotationList[],
-		oCapabilities: EnvironmentCapabilities
-	): V4NavigationProperty {
-		const navPropertyAnnotation = oMetaModel.getObject(`/${entityTypeObject.fullyQualifiedName}/${navPropertyName}@`);
-		const navPropertyDefinition = oMetaModel.getObject(`/${entityTypeObject.fullyQualifiedName}/${navPropertyName}`);
+	complexTypeObject.properties = complexTypeProperties;
+	const complexTypeNavigationProperties = Object.keys(complexTypeDefinition)
+		.filter(propertyNameOrNot => {
+			if (propertyNameOrNot != "$Key" && propertyNameOrNot != "$kind") {
+				return complexTypeDefinition[propertyNameOrNot].$kind === "NavigationProperty";
+			}
+		})
+		.sort((a, b) => (a > b ? 1 : -1))
+		.map(navPropertyName => {
+			return prepareNavigationProperty(complexTypeDefinition[navPropertyName], complexTypeObject, navPropertyName);
+		});
+	complexTypeObject.navigationProperties = complexTypeNavigationProperties;
+	return complexTypeObject;
+}
 
-		let referentialConstraint: ReferentialConstraint[] = [];
-		if (navPropertyDefinition.$ReferentialConstraint) {
-			referentialConstraint = Object.keys(navPropertyDefinition.$ReferentialConstraint).map(sourcePropertyName => {
-				return {
-					sourceTypeName: entityTypeObject.name,
-					sourceProperty: sourcePropertyName,
-					targetTypeName: navPropertyDefinition.$Type,
-					targetProperty: navPropertyDefinition.$ReferentialConstraint[sourcePropertyName]
-				};
-			});
-		}
-		const navigationProperty: V4NavigationProperty = {
-			_type: "NavigationProperty",
-			name: navPropertyName,
-			fullyQualifiedName: `${entityTypeObject.fullyQualifiedName}/${navPropertyName}`,
-			partner: navPropertyDefinition.$Partner,
-			isCollection: navPropertyDefinition.$isCollection ? navPropertyDefinition.$isCollection : false,
-			containsTarget: navPropertyDefinition.$ContainsTarget,
-			targetTypeName: navPropertyDefinition.$Type,
-			referentialConstraint
-		};
+function prepareEntityKeys(entityTypeDefinition: any, oMetaModelData: any): any {
+	if (!entityTypeDefinition.$Key && entityTypeDefinition.$BaseType) {
+		return prepareEntityKeys(oMetaModelData[`${entityTypeDefinition.$BaseType}`], oMetaModelData);
+	}
+	return entityTypeDefinition.$Key || []; //handling of entity types without key as well as basetype
+}
 
-		this.createAnnotationLists(navPropertyAnnotation, navigationProperty.fullyQualifiedName, annotationLists, oCapabilities);
+function prepareEntityType(entityTypeDefinition: any, entityTypeName: string, namespace: string, metaModelData: any): EntityType {
+	const entityKeys: any = prepareEntityKeys(entityTypeDefinition, metaModelData);
 
-		return navigationProperty;
-	},
-	parseEntitySet(
-		oMetaModel: any,
-		entitySetName: string,
-		annotationLists: AnnotationList[],
-		entityContainerName: string,
-		oCapabilities: EnvironmentCapabilities
-	): EntitySet {
-		const entitySetDefinition = oMetaModel.getObject(`/${entitySetName}`);
-		const entitySetAnnotation = oMetaModel.getObject(`/${entitySetName}@`);
-		const entitySetObject: EntitySet = {
-			_type: "EntitySet",
-			name: entitySetName,
-			navigationPropertyBinding: {},
-			entityTypeName: entitySetDefinition.$Type,
-			fullyQualifiedName: `${entityContainerName}/${entitySetName}`
-		};
-		this.createAnnotationLists(entitySetAnnotation, entitySetObject.fullyQualifiedName, annotationLists, oCapabilities);
-		return entitySetObject;
-	},
+	const entityTypeObject: EntityType = {
+		_type: "EntityType",
+		name: entityTypeName.replace(namespace + ".", ""),
+		fullyQualifiedName: entityTypeName,
+		keys: [],
+		entityProperties: [],
+		navigationProperties: []
+	};
 
-	parseSingleton(
-		oMetaModel: any,
-		singletonName: string,
-		annotationLists: AnnotationList[],
-		entityContainerName: string,
-		oCapabilities: EnvironmentCapabilities
-	): Singleton {
-		const singletonDefinition = oMetaModel.getObject(`/${singletonName}`);
-		const singletonAnnotation = oMetaModel.getObject(`/${singletonName}@`);
-		const singletonObject: Singleton = {
-			_type: "Singleton",
-			name: singletonName,
-			navigationPropertyBinding: {},
-			typeName: singletonDefinition.$Type,
-			fullyQualifiedName: `${entityContainerName}/${singletonName}`,
-			nullable: true
-		};
-		this.createAnnotationLists(singletonAnnotation, singletonObject.fullyQualifiedName, annotationLists, oCapabilities);
-		return singletonObject;
-	},
+	const entityProperties = Object.keys(entityTypeDefinition)
+		.filter(propertyNameOrNot => {
+			if (propertyNameOrNot != "$Key" && propertyNameOrNot != "$kind") {
+				return entityTypeDefinition[propertyNameOrNot].$kind === "Property";
+			}
+		})
+		.map(propertyName => {
+			return prepareProperty(entityTypeDefinition[propertyName], entityTypeObject, propertyName);
+		});
 
-	parseEntityType(
-		oMetaModel: any,
-		entityTypeName: string,
-		annotationLists: AnnotationList[],
-		namespace: string,
-		oCapabilities: EnvironmentCapabilities
-	): EntityType {
-		const entityTypeAnnotation = oMetaModel.getObject(`/${entityTypeName}@`);
-		const entityTypeDefinition = oMetaModel.getObject(`/${entityTypeName}`);
+	const navigationProperties = Object.keys(entityTypeDefinition)
+		.filter(propertyNameOrNot => {
+			if (propertyNameOrNot != "$Key" && propertyNameOrNot != "$kind") {
+				return entityTypeDefinition[propertyNameOrNot].$kind === "NavigationProperty";
+			}
+		})
+		.map(navPropertyName => {
+			return prepareNavigationProperty(entityTypeDefinition[navPropertyName], entityTypeObject, navPropertyName);
+		});
 
-		const entityKeys: any = getEntityKeys(entityTypeDefinition);
+	entityTypeObject.keys = entityKeys
+		.map((entityKey: string) => entityProperties.find((property: Property) => property.name === entityKey))
+		.filter((property: Property) => property !== undefined);
+	entityTypeObject.entityProperties = entityProperties;
+	entityTypeObject.navigationProperties = navigationProperties;
 
-		function getEntityKeys(entityTypeDefinition: any): any {
-			if (!entityTypeDefinition.$Key && entityTypeDefinition.$BaseType) {
-				return getEntityKeys(oMetaModel.getObject(`/${entityTypeDefinition.$BaseType}`));
+	return entityTypeObject;
+}
+function prepareAction(actionName: string, actionRawData: MetaModelAction, namespace: string, entityContainerName: string): Action {
+	let actionEntityType: string = "";
+	let actionFQN = `${actionName}`;
+	const actionShortName = actionName.substr(namespace.length + 1);
+	if (actionRawData.$IsBound) {
+		const bindingParameter = actionRawData.$Parameter[0];
+		actionEntityType = bindingParameter.$Type;
+		if (bindingParameter.$isCollection === true) {
+			actionFQN = `${actionName}(Collection(${actionEntityType}))`;
+		} else {
+			actionFQN = `${actionName}(${actionEntityType})`;
+		}
+	} else {
+		actionFQN = `${entityContainerName}/${actionShortName}`;
+	}
+	const parameters = actionRawData.$Parameter || [];
+	return {
+		_type: "Action",
+		name: actionShortName,
+		fullyQualifiedName: actionFQN,
+		isBound: actionRawData.$IsBound,
+		isFunction: false,
+		sourceType: actionEntityType,
+		returnType: actionRawData.$ReturnType ? actionRawData.$ReturnType.$Type : "",
+		parameters: parameters.map(param => {
+			return {
+				_type: "ActionParameter",
+				isEntitySet: param.$Type === actionRawData.$EntitySetPath,
+				fullyQualifiedName: `${actionFQN}/${param.$Name}`,
+				type: param.$Type
+				// TODO missing properties ?
+			};
+		})
+	};
+}
+export function prepareEntityTypes(
+	oMetaModel: ODataMetaModel,
+	oCapabilities: EnvironmentCapabilities = DefaultEnvironmentCapabilities
+): ParserOutput {
+	const oMetaModelData = oMetaModel.getObject("/$");
+	const annotationLists: Record<string, AnnotationList> = {};
+	const entityTypes: EntityType[] = [];
+	const entitySets: EntitySet[] = [];
+	const singletons: Singleton[] = [];
+	const complexTypes: ComplexType[] = [];
+	const typeDefinitions: TypeDefinition[] = [];
+	const entityContainerName = oMetaModelData.$EntityContainer;
+	let namespace = "";
+	const schemaKeys = Object.keys(oMetaModelData).filter(metamodelKey => oMetaModelData[metamodelKey].$kind === "Schema");
+	if (schemaKeys && schemaKeys.length > 0) {
+		namespace = schemaKeys[0].substr(0, schemaKeys[0].length - 1);
+	} else if (entityTypes && entityTypes.length) {
+		namespace = entityTypes[0].fullyQualifiedName.replace(entityTypes[0].name, "");
+		namespace = namespace.substr(0, namespace.length - 1);
+	}
+	Object.keys(oMetaModelData).forEach(sObjectName => {
+		if (sObjectName !== "$kind") {
+			switch (oMetaModelData[sObjectName].$kind) {
+				case "EntityType":
+					const entityType = prepareEntityType(oMetaModelData[sObjectName], sObjectName, namespace, oMetaModelData);
+					// Check if there are filter facets defined for the entityType and if yes, check if all of them have an ID
+					// The ID is optional, but it is internally taken for grouping filter fields and if it's not present
+					// a fallback ID needs to be generated here.
+					if (
+						oMetaModelData.$Annotations[entityType.fullyQualifiedName] &&
+						oMetaModelData.$Annotations[entityType.fullyQualifiedName]["@com.sap.vocabularies.UI.v1.FilterFacets"]
+					) {
+						oMetaModelData.$Annotations[entityType.fullyQualifiedName]["@com.sap.vocabularies.UI.v1.FilterFacets"].forEach(
+							(filterFacetAnnotation: any) => {
+								filterFacetAnnotation.ID = filterFacetAnnotation.ID || generate([{ Facet: filterFacetAnnotation }]);
+							}
+						);
+					}
+					entityType.entityProperties.forEach(entityProperty => {
+						if (!oMetaModelData.$Annotations[entityProperty.fullyQualifiedName]) {
+							oMetaModelData.$Annotations[entityProperty.fullyQualifiedName] = {};
+						}
+						if (
+							!oMetaModelData.$Annotations[entityProperty.fullyQualifiedName]["@com.sap.vocabularies.UI.v1.DataFieldDefault"]
+						) {
+							oMetaModelData.$Annotations[entityProperty.fullyQualifiedName][
+								"@com.sap.vocabularies.UI.v1.DataFieldDefault"
+							] = {
+								$Type: "com.sap.vocabularies.UI.v1.DataField",
+								Value: { $Path: entityProperty.name }
+							};
+						}
+					});
+					entityTypes.push(entityType);
+					break;
+				case "ComplexType":
+					const complexType = prepareComplexType(oMetaModelData[sObjectName], sObjectName, namespace);
+					complexTypes.push(complexType);
+					break;
+				case "TypeDefinition":
+					const typeDefinition = prepareTypeDefinition(oMetaModelData[sObjectName], sObjectName, namespace);
+					typeDefinitions.push(typeDefinition);
+					break;
 			}
-			return entityTypeDefinition.$Key || []; //handling of entity types without key as well as basetype
 		}
-		const entityTypeObject: EntityType = {
-			_type: "EntityType",
-			name: entityTypeName.replace(namespace + ".", ""),
-			fullyQualifiedName: entityTypeName,
-			keys: [],
-			entityProperties: [],
-			navigationProperties: []
-		};
-
-		this.createAnnotationLists(entityTypeAnnotation, entityTypeObject.fullyQualifiedName, annotationLists, oCapabilities);
-		const entityProperties = Object.keys(entityTypeDefinition)
-			.filter(propertyNameOrNot => {
-				if (propertyNameOrNot != "$Key" && propertyNameOrNot != "$kind") {
-					return entityTypeDefinition[propertyNameOrNot].$kind === "Property";
-				}
-			})
-			.map(propertyName => {
-				return this.parseProperty(oMetaModel, entityTypeObject, propertyName, annotationLists, oCapabilities);
-			});
-
-		const navigationProperties = Object.keys(entityTypeDefinition)
-			.filter(propertyNameOrNot => {
-				if (propertyNameOrNot != "$Key" && propertyNameOrNot != "$kind") {
-					return entityTypeDefinition[propertyNameOrNot].$kind === "NavigationProperty";
-				}
-			})
-			.map(navPropertyName => {
-				return this.parseNavigationProperty(oMetaModel, entityTypeObject, navPropertyName, annotationLists, oCapabilities);
-			});
-
-		entityTypeObject.keys = entityKeys
-			.map((entityKey: string) => entityProperties.find((property: Property) => property.name === entityKey))
-			.filter((property: Property) => property !== undefined);
-		entityTypeObject.entityProperties = entityProperties;
-		entityTypeObject.navigationProperties = navigationProperties;
-
-		return entityTypeObject;
-	},
-	parseComplexType(
-		oMetaModel: any,
-		complexTypeName: string,
-		annotationLists: AnnotationList[],
-		namespace: string,
-		oCapabilities: EnvironmentCapabilities
-	): ComplexType {
-		const complexTypeAnnotation = oMetaModel.getObject(`/${complexTypeName}@`);
-		const complexTypeDefinition = oMetaModel.getObject(`/${complexTypeName}`);
-		const complexTypeObject: ComplexType = {
-			_type: "ComplexType",
-			name: complexTypeName.replace(namespace + ".", ""),
-			fullyQualifiedName: complexTypeName,
-			properties: [],
-			navigationProperties: []
-		};
+	});
 
-		this.createAnnotationLists(complexTypeAnnotation, complexTypeObject.fullyQualifiedName, annotationLists, oCapabilities);
-		const complexTypeProperties = Object.keys(complexTypeDefinition)
-			.filter(propertyNameOrNot => {
-				if (propertyNameOrNot != "$Key" && propertyNameOrNot != "$kind") {
-					return complexTypeDefinition[propertyNameOrNot].$kind === "Property";
-				}
-			})
-			.map(propertyName => {
-				return this.parseProperty(oMetaModel, complexTypeObject, propertyName, annotationLists, oCapabilities);
-			});
-
-		complexTypeObject.properties = complexTypeProperties;
-		const complexTypeNavigationProperties = Object.keys(complexTypeDefinition)
-			.filter(propertyNameOrNot => {
-				if (propertyNameOrNot != "$Key" && propertyNameOrNot != "$kind") {
-					return complexTypeDefinition[propertyNameOrNot].$kind === "NavigationProperty";
-				}
-			})
-			.map(navPropertyName => {
-				return this.parseNavigationProperty(oMetaModel, complexTypeObject, navPropertyName, annotationLists, oCapabilities);
-			});
-		complexTypeObject.navigationProperties = complexTypeNavigationProperties;
-		return complexTypeObject;
-	},
-	parseAction(actionName: string, actionRawData: MetaModelAction, namespace: string, entityContainerName: string): Action {
-		let actionEntityType: string = "";
-		let actionFQN = `${actionName}`;
-		const actionShortName = actionName.substr(namespace.length + 1);
-		if (actionRawData.$IsBound) {
-			const bindingParameter = actionRawData.$Parameter[0];
-			actionEntityType = bindingParameter.$Type;
-			if (bindingParameter.$isCollection === true) {
-				actionFQN = `${actionName}(Collection(${actionEntityType}))`;
-			} else {
-				actionFQN = `${actionName}(${actionEntityType})`;
+	const oEntityContainer = oMetaModelData[entityContainerName];
+	Object.keys(oEntityContainer).forEach(sObjectName => {
+		if (sObjectName !== "$kind") {
+			switch (oEntityContainer[sObjectName].$kind) {
+				case "EntitySet":
+					const entitySet = prepareEntitySet(oEntityContainer[sObjectName], sObjectName, entityContainerName);
+					entitySets.push(entitySet);
+					break;
+				case "Singleton":
+					const singleton = prepareSingleton(oEntityContainer[sObjectName], sObjectName, entityContainerName);
+					singletons.push(singleton);
+					break;
 			}
-		} else {
-			actionFQN = `${entityContainerName}/${actionShortName}`;
 		}
-		const parameters = actionRawData.$Parameter || [];
-		return {
-			_type: "Action",
-			name: actionShortName,
-			fullyQualifiedName: actionFQN,
-			isBound: actionRawData.$IsBound,
-			sourceType: actionEntityType,
-			returnType: actionRawData.$ReturnType ? actionRawData.$ReturnType.$Type : "",
-			parameters: parameters.map(param => {
-				return {
-					_type: "ActionParameter",
-					isEntitySet: param.$Type === actionRawData.$EntitySetPath,
-					fullyQualifiedName: `${actionFQN}/${param.$Name}`,
-					type: param.$Type
-					// TODO missing properties ?
-				};
-			})
+	});
+
+	let entityContainer: EntityContainer = {};
+	if (entityContainerName) {
+		entityContainer = {
+			name: entityContainerName.replace(namespace + ".", ""),
+			fullyQualifiedName: entityContainerName
 		};
-	},
-	parseEntityTypes(oMetaModel: any, oInCapabilities?: EnvironmentCapabilities): ParserOutput {
-		let oCapabilities: EnvironmentCapabilities;
-		if (!oInCapabilities) {
-			oCapabilities = DefaultEnvironmentCapabilities;
-		} else {
-			oCapabilities = oInCapabilities;
-		}
-		const oMetaModelData = oMetaModel.getObject("/$");
-		const oEntitySets = oMetaModel.getObject("/");
-		let annotationLists: AnnotationList[] = [];
-		const entityTypes: EntityType[] = [];
-		const entitySets: EntitySet[] = [];
-		const singletons: Singleton[] = [];
-		const complexTypes: ComplexType[] = [];
-		const entityContainerName = oMetaModelData.$EntityContainer;
-		let namespace = "";
-		const schemaKeys = Object.keys(oMetaModelData).filter(metamodelKey => oMetaModelData[metamodelKey].$kind === "Schema");
-		if (schemaKeys && schemaKeys.length > 0) {
-			namespace = schemaKeys[0].substr(0, schemaKeys[0].length - 1);
-		} else if (entityTypes && entityTypes.length) {
-			namespace = entityTypes[0].fullyQualifiedName.replace(entityTypes[0].name, "");
-			namespace = namespace.substr(0, namespace.length - 1);
-		}
-		Object.keys(oMetaModelData)
-			.filter(entityTypeName => {
-				return entityTypeName !== "$kind" && oMetaModelData[entityTypeName].$kind === "EntityType";
-			})
-			.forEach(entityTypeName => {
-				const entityType = this.parseEntityType(oMetaModel, entityTypeName, annotationLists, namespace, oCapabilities);
-				// Check if there are filter facets defined for the entityType and if yes, check if all of them have an ID
-				// The ID is optional, but it is internally taken for grouping filter fields and if it's not present
-				// a fallback ID needs to be generated here.
-				if (
-					oMetaModelData.$Annotations[entityType.fullyQualifiedName] &&
-					oMetaModelData.$Annotations[entityType.fullyQualifiedName]["@com.sap.vocabularies.UI.v1.FilterFacets"]
-				) {
-					oMetaModelData.$Annotations[entityType.fullyQualifiedName]["@com.sap.vocabularies.UI.v1.FilterFacets"].forEach(
-						(filterFacetAnnotation: any) => {
-							filterFacetAnnotation.ID = filterFacetAnnotation.ID || generate([{ Facet: filterFacetAnnotation }]);
-							this.createAnnotationLists(
-								{
-									"@com.sap.vocabularies.UI.v1.FilterFacets":
-										oMetaModelData.$Annotations[entityType.fullyQualifiedName][
-											"@com.sap.vocabularies.UI.v1.FilterFacets"
-										]
-								},
-								entityType.fullyQualifiedName,
-								annotationLists,
-								oCapabilities
-							);
-						}
-					);
+	}
+	entitySets.forEach(entitySet => {
+		const navPropertyBindings = oEntityContainer[entitySet.name].$NavigationPropertyBinding;
+		if (navPropertyBindings) {
+			Object.keys(navPropertyBindings).forEach(navPropName => {
+				const targetEntitySet = entitySets.find(entitySetName => entitySetName.name === navPropertyBindings[navPropName]);
+				if (targetEntitySet) {
+					entitySet.navigationPropertyBinding[navPropName] = targetEntitySet;
 				}
-				entityType.entityProperties.forEach(entityProperty => {
-					if (!oMetaModelData.$Annotations[entityProperty.fullyQualifiedName]) {
-						oMetaModelData.$Annotations[entityProperty.fullyQualifiedName] = {};
-					}
-					if (!oMetaModelData.$Annotations[entityProperty.fullyQualifiedName]["@com.sap.vocabularies.UI.v1.DataFieldDefault"]) {
-						oMetaModelData.$Annotations[entityProperty.fullyQualifiedName]["@com.sap.vocabularies.UI.v1.DataFieldDefault"] = {
-							$Type: "com.sap.vocabularies.UI.v1.DataField",
-							Value: { $Path: entityProperty.name }
-						};
-						this.createAnnotationLists(
-							{
-								"@com.sap.vocabularies.UI.v1.DataFieldDefault":
-									oMetaModelData.$Annotations[entityProperty.fullyQualifiedName][
-										"@com.sap.vocabularies.UI.v1.DataFieldDefault"
-									]
-							},
-							entityProperty.fullyQualifiedName,
-							annotationLists,
-							oCapabilities
-						);
-					}
-				});
-				entityTypes.push(entityType);
-			});
-		Object.keys(oEntitySets)
-			.filter(entitySetName => {
-				return entitySetName !== "$kind" && oEntitySets[entitySetName].$kind === "EntitySet";
-			})
-			.forEach(entitySetName => {
-				const entitySet = this.parseEntitySet(oMetaModel, entitySetName, annotationLists, entityContainerName, oCapabilities);
-				entitySets.push(entitySet);
 			});
-		Object.keys(oEntitySets)
-			.filter(singletonName => {
-				return singletonName !== "$kind" && oEntitySets[singletonName].$kind === "Singleton";
-			})
-			.forEach(singletonName => {
-				const singleton = this.parseSingleton(oMetaModel, singletonName, annotationLists, entityContainerName, oCapabilities);
-				singletons.push(singleton);
-			});
-		Object.keys(oMetaModelData)
-			.filter(complexTypeName => {
-				return complexTypeName !== "$kind" && oMetaModelData[complexTypeName].$kind === "ComplexType";
-			})
-			.forEach(complexTypeName => {
-				const complexType = this.parseComplexType(oMetaModel, complexTypeName, annotationLists, namespace, oCapabilities);
-				complexTypes.push(complexType);
-			});
-		const oEntityContainerName = Object.keys(oMetaModelData).find(entityContainerName => {
-			return entityContainerName !== "$kind" && oMetaModelData[entityContainerName].$kind === "EntityContainer";
-		});
-		let entityContainer: EntityContainer = {};
-		if (oEntityContainerName) {
-			entityContainer = {
-				name: oEntityContainerName.replace(namespace + ".", ""),
-				fullyQualifiedName: oEntityContainerName
-			};
 		}
-		entitySets.forEach(entitySet => {
-			const navPropertyBindings = oMetaModelData[entityContainerName][entitySet.name].$NavigationPropertyBinding;
-			if (navPropertyBindings) {
-				Object.keys(navPropertyBindings).forEach(navPropName => {
-					const targetEntitySet = entitySets.find(entitySetName => entitySetName.name === navPropertyBindings[navPropName]);
-					if (targetEntitySet) {
-						entitySet.navigationPropertyBinding[navPropName] = targetEntitySet;
-					}
-				});
-			}
-		});
+	});
 
-		const actions: Action[] = Object.keys(oMetaModelData)
-			.filter(key => {
-				return Array.isArray(oMetaModelData[key]) && oMetaModelData[key].length > 0 && oMetaModelData[key][0].$kind === "Action";
-			})
-			.reduce((outActions: Action[], actionName) => {
-				const actions = oMetaModelData[actionName];
-				actions.forEach((action: MetaModelAction) => {
-					outActions.push(this.parseAction(actionName, action, namespace, entityContainerName));
-				});
-				return outActions;
-			}, []);
-		// FIXME Crappy code to deal with annotations for functions
-		const annotations = oMetaModelData.$Annotations;
-		const actionAnnotations = Object.keys(annotations).filter(target => target.indexOf("(") !== -1);
-		actionAnnotations.forEach(target => {
-			this.createAnnotationLists(oMetaModelData.$Annotations[target], target, annotationLists, oCapabilities);
-		});
-		const actionsNameWithoutOverload = actions.map(action => action.fullyQualifiedName.split("(")[0]);
-		actionsNameWithoutOverload.forEach(actionName => {
-			if (annotations.hasOwnProperty(actionName)) {
-				this.createAnnotationLists(oMetaModelData.$Annotations[actionName], actionName, annotationLists, oCapabilities);
-			}
-		});
-		const entityContainerAnnotations = annotations[entityContainerName];
+	const actions: Action[] = Object.keys(oMetaModelData)
+		.filter(key => {
+			return Array.isArray(oMetaModelData[key]) && oMetaModelData[key].length > 0 && oMetaModelData[key][0].$kind === "Action";
+		})
+		.reduce((outActions: Action[], actionName) => {
+			const actions = oMetaModelData[actionName];
+			actions.forEach((action: MetaModelAction) => {
+				outActions.push(prepareAction(actionName, action, namespace, entityContainerName));
+			});
+			return outActions;
+		}, []);
 
-		// Retrieve Entity Container annotations
-		if (entityContainerAnnotations) {
-			this.createAnnotationLists(entityContainerAnnotations, entityContainerName, annotationLists, oCapabilities);
-		}
-		// Sort by target length
-		annotationLists = annotationLists.sort((a, b) => (a.target.length >= b.target.length ? 1 : -1));
-		const references: Reference[] = [];
-		return {
-			identification: "metamodelResult",
-			version: "4.0",
-			schema: {
-				entityContainer,
-				entitySets,
-				entityTypes,
-				complexTypes,
-				singletons,
-				associations: [],
-				actions,
-				namespace,
-				annotations: {
-					"metamodelResult": annotationLists
-				}
-			},
-			references: references
-		};
+	for (const target in oMetaModelData.$Annotations) {
+		createAnnotationLists(oMetaModelData.$Annotations[target], target, annotationLists, oCapabilities);
 	}
-};
+
+	// Sort by target length
+	const outAnnotationLists = Object.keys(annotationLists)
+		.sort((a, b) => (a.length >= b.length ? 1 : -1))
+		.map(sAnnotationName => annotationLists[sAnnotationName]);
+	const references: Reference[] = [];
+	return {
+		identification: "metamodelResult",
+		version: "4.0",
+		schema: {
+			entityContainer,
+			entitySets,
+			entityTypes,
+			complexTypes,
+			typeDefinitions,
+			singletons,
+			associations: [],
+			associationSets: [],
+			actions,
+			namespace,
+			annotations: {
+				"metamodelResult": outAnnotationLists
+			}
+		},
+		references: references
+	};
+}
 
 const mMetaModelMap: Record<string, ParserOutput> = {};
 
@@ -1019,22 +950,58 @@ const mMetaModelMap: Record<string, ParserOutput> = {};
 export function convertTypes(oMetaModel: ODataMetaModel, oCapabilities?: EnvironmentCapabilities): ConverterOutput {
 	const sMetaModelId = (oMetaModel as any).id;
 	if (!mMetaModelMap.hasOwnProperty(sMetaModelId)) {
-		const parsedOutput = MetaModelConverter.parseEntityTypes(oMetaModel, oCapabilities);
-		mMetaModelMap[sMetaModelId] = AnnotationConverter.convertTypes(parsedOutput);
+		const parsedOutput = prepareEntityTypes(oMetaModel, oCapabilities);
+		if (oCapabilities && oCapabilities.Situations) {
+			// Only Experimental Feature!
+			mMetaModelMap[sMetaModelId] = addSyntheticAnnotations(AnnotationConverter.convertTypes(parsedOutput));
+		} else {
+			mMetaModelMap[sMetaModelId] = AnnotationConverter.convertTypes(parsedOutput);
+		}
 	}
 	return (mMetaModelMap[sMetaModelId] as any) as ConverterOutput;
 }
 
+function addSyntheticAnnotations(metaModel: ParserOutput) {
+	// [Situations POC] Determine mixed-in situations navigation property.
+	// This will probably happen either
+	//  - by a fixed navigation property name ("SAP__Situation"), or
+	//  - by an entity type annotation that declares the navigation property to use (similar to com.sap.vocabularies.Common.v1.Messages)
+	//
+	// For now, we add an 'invented' annotation "com.sap.vocabularies.FioriElements.v1.Situations" consisting of a path to the situations navigation property
+	((metaModel as any) as ConverterOutput).entityTypes.forEach(entityType => {
+		const situationsNavProp = entityType.navigationProperties.find(
+			navProp => navProp.name === "SAP__Situation" || navProp.name === "_SAP__Situation"
+		);
+
+		if (situationsNavProp) {
+			(entityType.annotations as any).FE = {
+				Situations: {
+					term: "com.sap.vocabularies.FioriElements.v1.Situations",
+					type: "Path",
+					path: situationsNavProp.name,
+					$target: situationsNavProp
+				}
+			};
+		}
+	});
+	return metaModel;
+}
+
 export function deleteModelCacheData(oMetaModel: ODataMetaModel) {
 	delete mMetaModelMap[(oMetaModel as any).id];
 }
 
-export function convertMetaModelContext(oMetaModelContext: Context, bIncludeVisitedObjects: boolean = false): any {
-	const oConverterOutput = convertTypes((oMetaModelContext.getModel() as unknown) as ODataMetaModel);
+export function convertMetaModelContext(oMetaModelContext: Context<ODataMetaModel>, bIncludeVisitedObjects: boolean = false): any {
+	const oConverterOutput = convertTypes(oMetaModelContext.getModel());
 	const sPath = oMetaModelContext.getPath();
 
 	const aPathSplit = sPath.split("/");
-	let targetEntitySet: _EntitySet = oConverterOutput.entitySets.find(entitySet => entitySet.name === aPathSplit[1]) as _EntitySet;
+	let targetEntitySet: _EntitySet | _Singleton = oConverterOutput.entitySets.find(
+		entitySet => entitySet.name === aPathSplit[1]
+	) as _EntitySet;
+	if (!targetEntitySet) {
+		targetEntitySet = oConverterOutput.singletons.find(singleton => singleton.name === aPathSplit[1]) as _Singleton;
+	}
 	let relativePath = aPathSplit.slice(2).join("/");
 
 	const localObjects: any[] = [targetEntitySet];
@@ -1073,7 +1040,13 @@ export function convertMetaModelContext(oMetaModelContext: Context, bIncludeVisi
 			localObjects.push(targetEntitySet);
 		}
 		// Re-calculating the relative path
-		relativePath = relativeSplit.slice(aNavProps.length || 1).join("/");
+		// As each navigation name is enclosed between '$NavigationPropertyBinding' and '$' (to be able to access the entityset easily in the metamodel)
+		// we need to remove the closing '$' to be able to switch to the next navigation
+		relativeSplit = relativeSplit.slice(aNavProps.length || 1);
+		if (relativeSplit.length && relativeSplit[0] === "$") {
+			relativeSplit.shift();
+		}
+		relativePath = relativeSplit.join("/");
 	}
 	if (relativePath.startsWith("$Type")) {
 		// We're anyway going to look on the entityType...
@@ -1123,7 +1096,10 @@ export type ResolvedTarget = {
 	visitedObjects: ConverterObject[];
 };
 
-export function getInvolvedDataModelObjects(oMetaModelContext: Context, oEntitySetMetaModelContext?: Context): DataModelObjectPath {
+export function getInvolvedDataModelObjects(
+	oMetaModelContext: Context<ODataMetaModel>,
+	oEntitySetMetaModelContext?: Context<ODataMetaModel>
+): DataModelObjectPath {
 	const metaModelContext = convertMetaModelContext(oMetaModelContext, true);
 	let targetEntitySetLocation;
 	if (oEntitySetMetaModelContext && oEntitySetMetaModelContext.getPath() !== "/") {