@ui5/task-adaptation 1.2.0 → 1.3.0

package/dist/bundle.js

@@ -1,8 +1,4 @@
 var window = {};
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var fnIsEmptyObject = function isEmptyObject(obj) {
   for (var sName in obj) {
     return false;
@@ -20,7 +16,7 @@ function getDescriptorChanges(oManifest) {
   });
 }
 var Applier = {
-  applyChanges: function (oUpdatedManifest, aAppDescriptorChanges, mStrategy) {
+  applyChanges(oUpdatedManifest, aAppDescriptorChanges, mStrategy) {
     return mStrategy.registry().then(function (Registry) {
       var aChangeHandlerPromises = aAppDescriptorChanges.map(function (oChange) {
         return Registry[oChange.getChangeType()] && Registry[oChange.getChangeType()]();
@@ -41,7 +37,7 @@ var Applier = {
       return oUpdatedManifest;
     });
   },
-  applyChangesIncludedInManifest: function (oManifest, mStrategy) {
+  applyChangesIncludedInManifest(oManifest, mStrategy) {
     var aDescriptorChanges = getDescriptorChanges(oManifest);
     var oManifestJSON = oManifest.getJson();
     delete oManifestJSON[CHANGES_NAMESPACE];
@@ -1846,11 +1842,11 @@ p.escapeQuerySpace = function (v) {
 };
 
 var ApplyUtil = {
-  formatBundleName: function (sId, sBundleUrl) {
+  formatBundleName(sId, sBundleUrl) {
     if (sBundleUrl.startsWith("/")) {
       throw Error("Absolute paths are not supported");
     }
-    var sNormalizedUrl = new URI(sId + "/" + sBundleUrl).normalize().path();
+    var sNormalizedUrl = new URI(`${sId}/${sBundleUrl}`).normalize().path();
     return sNormalizedUrl.replace(/\//g, ".").replace("..", ".").replace(/.properties$/g, "");
   }
 };
@@ -1929,27 +1925,6 @@ function changePropertyValueByPath (vChanges, oRootPath) {
   }
 }
 
-var fnValues = function values(mObject) {
-  if (typeof mObject === "undefined" || mObject === null || mObject !== mObject) {
-    return [];
-  }
-  return Object.values(mObject);
-};
-
-var fnIncludes = function (vCollection, vValue, iFromIndex) {
-  if (typeof iFromIndex !== "number") {
-    iFromIndex = 0;
-  }
-  if (Array.isArray(vCollection) || typeof vCollection === "string") {
-    if (iFromIndex < 0) {
-      iFromIndex = vCollection.length + iFromIndex < 0 ? 0 : vCollection.length + iFromIndex;
-    }
-    return vCollection.includes(vValue, iFromIndex);
-  } else {
-    return fnIncludes(fnValues(vCollection), vValue, iFromIndex);
-  }
-};
-
 var Layer = {
   USER: "USER",
   PUBLIC: "PUBLIC",
@@ -1960,14 +1935,12 @@ var Layer = {
   BASE: "BASE"
 };
 
-function checkChange(oEntityPropertyChange, aSupportedProperties, aSupportedOperations) {
-  if (Array.isArray(oEntityPropertyChange)) {
-    oEntityPropertyChange.forEach(function (change) {
-      formatEntityCheck(change, aSupportedProperties, aSupportedOperations);
-    });
-  } else {
-    formatEntityCheck(oEntityPropertyChange, aSupportedProperties, aSupportedOperations);
-  }
+function checkChange(oEntityPropertyChange, aSupportedProperties, aSupportedOperations, oSupportedPropertyPattern) {
+  const aEntityPropertyChanges = Array.isArray(oEntityPropertyChange) ? oEntityPropertyChange : [oEntityPropertyChange];
+  aEntityPropertyChanges.forEach(function (oChange) {
+    formatEntityCheck(oChange, aSupportedProperties, aSupportedOperations);
+    checkPropertyValuePattern(oChange, oSupportedPropertyPattern);
+  });
 }
 function getClearedGenericPath(aSupportedProperties) {
   var aPropertiesClearedGenericPath = [];
@@ -2000,24 +1973,24 @@ function formatEntityCheck(oChangeEntity, aSupportedProperties, aSupportedOperat
       throw new Error("Invalid change format: The mandatory 'propertyValue' is not defined. Please define the mandatory property 'propertyValue'");
     }
   }
-  if (!fnIncludes(aSupportedProperties, oChangeEntity.propertyPath) && !isGenericPropertyPathSupported(aSupportedProperties, oChangeEntity.propertyPath)) {
-    throw new Error("Changing " + oChangeEntity.propertyPath + " is not supported. The supported 'propertyPath' is: " + aSupportedProperties.join("|"));
+  if (!aSupportedProperties.includes(oChangeEntity.propertyPath) && !isGenericPropertyPathSupported(aSupportedProperties, oChangeEntity.propertyPath)) {
+    throw new Error(`Changing ${oChangeEntity.propertyPath} is not supported. The supported 'propertyPath' is: ${aSupportedProperties.join("|")}`);
   }
-  if (!fnIncludes(aSupportedOperations, oChangeEntity.operation)) {
-    throw new Error("Operation " + oChangeEntity.operation + " is not supported. The supported 'operation' is " + aSupportedOperations.join("|"));
+  if (!aSupportedOperations.includes(oChangeEntity.operation)) {
+    throw new Error(`Operation ${oChangeEntity.operation} is not supported. The supported 'operation' is ${aSupportedOperations.join("|")}`);
   }
 }
-function checkEntityPropertyChange(oChange, aSupportedProperties, aSupportedOperations) {
-  var id = Object.keys(oChange).filter(function (key) {
-    return key.endsWith("Id");
+function checkEntityPropertyChange(oChange, aSupportedProperties, aSupportedOperations, oSupportedPropertyPattern) {
+  var sId = Object.keys(oChange).filter(function (sKey) {
+    return sKey.endsWith("Id");
   }).shift();
-  if (!oChange[id]) {
-    throw new Error("Mandatory \"" + id + "\" parameter is not provided.");
+  if (!oChange[sId]) {
+    throw new Error(`Mandatory "${sId}" parameter is not provided.`);
   }
   if (!oChange.entityPropertyChange) {
-    throw new Error("Changes for \"" + oChange[id] + "\" are not provided.");
+    throw new Error(`Changes for "${oChange[sId]}" are not provided.`);
   }
-  checkChange(oChange.entityPropertyChange, aSupportedProperties, aSupportedOperations);
+  checkChange(oChange.entityPropertyChange, aSupportedProperties, aSupportedOperations, oSupportedPropertyPattern);
 }
 var layer_prefixes = {};
 layer_prefixes[Layer.CUSTOMER] = "customer.";
@@ -2033,41 +2006,50 @@ function checkIdNamespaceCompliance(sId, oChange) {
   if (sPrefix === null) {
     Object.keys(layer_prefixes).forEach(function (sKey) {
       if (layer_prefixes[sKey] && sId.startsWith(layer_prefixes[sKey])) {
-        throw new Error("Id " + sId + " must not start with reserved " + layer_prefixes[sKey]);
+        throw new Error(`Id ${sId} must not start with reserved ${layer_prefixes[sKey]}`);
       }
     });
   } else if (!sId.startsWith(sPrefix)) {
-    throw new Error("Id " + sId + " must start with " + sPrefix);
+    throw new Error(`Id ${sId} must start with ${sPrefix}`);
   }
 }
 function getNamespacePrefixForLayer(sLayer) {
   var sPrefix = layer_prefixes[sLayer];
   if (sPrefix === undefined) {
-    throw new Error("Layer " + sLayer + " not supported.");
+    throw new Error(`Layer ${sLayer} not supported.`);
   }
   return sPrefix;
 }
+function checkPropertyValuePattern(oChange, oSupportedPattern) {
+  if (!Object.keys(oSupportedPattern).includes(oChange.propertyPath)) {
+    return;
+  }
+  if (!oChange.propertyValue.match(oSupportedPattern[oChange.propertyPath])) {
+    throw new Error(`Not supported format for propertyPath ${oChange.propertyPath}. ` + `The supported pattern is ${oSupportedPattern[oChange.propertyPath]}`);
+  }
+}
 var DescriptorChangeCheck = {
-  checkEntityPropertyChange: checkEntityPropertyChange,
-  checkIdNamespaceCompliance: checkIdNamespaceCompliance,
-  getNamespacePrefixForLayer: getNamespacePrefixForLayer,
-  getClearedGenericPath: getClearedGenericPath,
-  isGenericPropertyPathSupported: isGenericPropertyPathSupported
+  checkEntityPropertyChange,
+  checkIdNamespaceCompliance,
+  getNamespacePrefixForLayer,
+  getClearedGenericPath,
+  isGenericPropertyPathSupported
 };
 
 var SUPPORTED_OPERATIONS$1 = ["UPDATE", "UPSERT"];
 var SUPPORTED_PROPERTIES$1 = ["uri", "settings/maxAge"];
+var PROPERTIES_PATTERNS$1 = {};
 var ChangeDataSource = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     var oDataSources = oManifest["sap.app"].dataSources;
     var oChangeContent = oChange.getContent();
-    DescriptorChangeCheck.checkEntityPropertyChange(oChangeContent, SUPPORTED_PROPERTIES$1, SUPPORTED_OPERATIONS$1);
+    DescriptorChangeCheck.checkEntityPropertyChange(oChangeContent, SUPPORTED_PROPERTIES$1, SUPPORTED_OPERATIONS$1, PROPERTIES_PATTERNS$1);
     if (oDataSources) {
       var oDataSource = oDataSources[oChangeContent.dataSourceId];
       if (oDataSource) {
         changePropertyValueByPath(oChangeContent.entityPropertyChange, oDataSource);
       } else {
-        throw new Error("Nothing to update. DataSource with ID \"" + oChangeContent.dataSourceId + "\" does not exist.");
+        throw new Error(`Nothing to update. DataSource with ID "${oChangeContent.dataSourceId}" does not exist.`);
       }
     } else {
       throw Error("No sap.app/dataSource found in manifest.json");
@@ -2077,7 +2059,7 @@ var ChangeDataSource = {
 };
 
 var AddNewModelEnhanceWith = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     var sModelId = oChange.getContent().modelId;
     var sI18N = ApplyUtil.formatBundleName(oManifest["sap.app"].id, oChange.getTexts().i18n);
     var oModel = oManifest["sap.ui5"].models[sModelId];
@@ -2098,15 +2080,13 @@ var AddNewModelEnhanceWith = {
 };
 
 var AddComponentUsages = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     var oChangeComponentUsages = oChange.getContent().componentUsages;
-    if (!oManifest["sap.ui5"]["componentUsages"]) {
-      oManifest["sap.ui5"]["componentUsages"] = {};
-    }
+    oManifest["sap.ui5"].componentUsages ||= {};
     var oManifestComponentUsages = oManifest["sap.ui5"].componentUsages;
     Object.keys(oChangeComponentUsages).forEach(function (sComponentUsageName) {
       if (oManifestComponentUsages[sComponentUsageName]) {
-        throw new Error("Component usage '" + sComponentUsageName + "' already exists");
+        throw new Error(`Component usage '${sComponentUsageName}' already exists`);
       } else {
         oManifestComponentUsages[sComponentUsageName] = oChangeComponentUsages[sComponentUsageName];
       }
@@ -2165,7 +2145,7 @@ Version.prototype.inRange = function (vMin, vMax) {
 };
 
 var SetMinUI5Version = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     var vCurrentVersion = new Version(oManifest["sap.ui5"].dependencies.minUI5Version);
     if (vCurrentVersion.compareTo(oChange.getContent().minUI5Version) <= 0) {
       oManifest["sap.ui5"].dependencies.minUI5Version = oChange.getContent().minUI5Version;
@@ -2175,14 +2155,14 @@ var SetMinUI5Version = {
 };
 
 var SetRegistrationIds = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     ObjectPath.set(["sap.fiori", "registrationIds"], oChange.getContent().registrationIds, oManifest);
     return oManifest;
   }
 };
 
 var SetFlexExtensionPointEnabled = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     if (!oChange.getContent().flexExtensionPointEnabled) {
       throw new Error("No flexExtensionPointEnabled in change content provided");
     }
@@ -2194,11 +2174,11 @@ var SetFlexExtensionPointEnabled = {
 var SUPPORTED_MODEL_DATASOURCE_TYPES = ["OData", "INA", "XML", "JSON", "FHIR", "http", "WebSocket"];
 var SUPPORTED_DATASOURCE_TYPES = SUPPORTED_MODEL_DATASOURCE_TYPES.concat(["ODataAnnotation"]);
 function isDataSourceTypeSupported(oChangeDataSource, sDataSource, aSupportedTypes) {
-  return !oChangeDataSource[sDataSource].type || aSupportedTypes.indexOf(oChangeDataSource[sDataSource]["type"]) >= 0;
+  return !oChangeDataSource[sDataSource].type || aSupportedTypes.indexOf(oChangeDataSource[sDataSource].type) >= 0;
 }
 function isODataDefinedForODataAnnotation(oChangeDataSources, sODataAnnotationName) {
   return getObjectAsArray(oChangeDataSources).some(function (oDataSource) {
-    return (!oDataSource.type || oDataSource["type"] === "OData") && oDataSource["settings"]["annotations"].indexOf(sODataAnnotationName) >= 0;
+    return (!oDataSource.type || oDataSource.type === "OData") && oDataSource.settings.annotations.indexOf(sODataAnnotationName) >= 0;
   });
 }
 function isReferencedModelDataSourceExisting(oManifestDataSource, oChangeDataSource, sDataSource) {
@@ -2209,8 +2189,8 @@ function isExistingAndSupported(oDataSources, sDataSource, aSupportedTypes) {
 }
 function isDataSourceExistingInManifest(oDataSources, sDataSource) {
   if (hasSearchType(oDataSources, sDataSource)) {
-    if (oDataSources[sDataSource].type && oDataSources[sDataSource]["type"] === "ODataAnnotation") {
-      throw new Error("The already existing dataSource '" + sDataSource + "' in the manifest is type of 'ODataAnnotation'. A model must not reference to a dataSource which is of type 'ODataAnnotation'");
+    if (oDataSources[sDataSource].type && oDataSources[sDataSource].type === "ODataAnnotation") {
+      throw new Error(`The already existing dataSource '${sDataSource}' in the manifest is type of 'ODataAnnotation'. A model must not reference to a dataSource which is of type 'ODataAnnotation'`);
     }
     return true;
   }
@@ -2223,16 +2203,14 @@ function mergeChange(oManifestContent, oChangeContent, sErrorMessage) {
   if (oChangeContent) {
     Object.keys(oChangeContent).forEach(function (sNewModelName) {
       if (oManifestContent[sNewModelName]) {
-        throw new Error("The " + sErrorMessage + " '" + sNewModelName + "' already exists");
+        throw new Error(`The ${sErrorMessage} '${sNewModelName}' already exists`);
       }
       oManifestContent[sNewModelName] = oChangeContent[sNewModelName];
     });
   }
 }
 function merge$2(oManifest, oChange, sRootPath, sChildPath, sModelPath) {
-  if (!oManifest[sRootPath][sChildPath]) {
-    oManifest[sRootPath][sChildPath] = {};
-  }
+  oManifest[sRootPath][sChildPath] ||= {};
   mergeChange(oManifest[sRootPath][sChildPath], oChange.getContent()[sModelPath], sModelPath);
   return oManifest[sRootPath][sChildPath];
 }
@@ -2241,7 +2219,7 @@ function isChangeDataSourceUsedByChangeModel(oChangeDataSource, oChangeModel, sD
     return true;
   }
   return getObjectAsArray(oChangeModel).some(function (oModel) {
-    return oModel.dataSource && oModel["dataSource"] === sDataSource;
+    return oModel.dataSource && oModel.dataSource === sDataSource;
   });
 }
 function hasModelPropertyTypOrDataSource(oChangeModel, sModel) {
@@ -2253,20 +2231,20 @@ function getObjectAsArray(oObject) {
   });
 }
 var AddNewModel = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     var oChangeModel = oChange.getContent().model;
     var oChangeDataSource = oChange.getContent().dataSource;
     if (oChangeModel) {
       if (Object.keys(oChangeModel).length !== 1) {
-        throw new Error("There are currently '" + Object.keys(oChangeModel).length + "' models in the change. Currently it is only allowed to add '1' model");
+        throw new Error(`There are currently '${Object.keys(oChangeModel).length}' models in the change. Currently it is only allowed to add '1' model`);
       }
       Object.keys(oChangeModel).forEach(function (sModel) {
         if (!hasModelPropertyTypOrDataSource(oChangeModel, sModel)) {
-          throw new Error("There is no 'dataSource' or 'type' in the change model defined. Please define either 'type' or 'dataSource' in property '" + sModel + "'");
+          throw new Error(`There is no 'dataSource' or 'type' in the change model defined. Please define either 'type' or 'dataSource' in property '${sModel}'`);
         }
         if (oChangeModel[sModel].dataSource) {
-          if (!isReferencedModelDataSourceExisting(oManifest["sap.app"]["dataSources"], oChangeDataSource, oChangeModel[sModel]["dataSource"])) {
-            throw new Error("The defined dataSource '" + oChangeModel[sModel]["dataSource"] + "' in the model does not exists as dataSource or must be allowed type of " + SUPPORTED_MODEL_DATASOURCE_TYPES.join("|"));
+          if (!isReferencedModelDataSourceExisting(oManifest["sap.app"].dataSources, oChangeDataSource, oChangeModel[sModel].dataSource)) {
+            throw new Error(`The defined dataSource '${oChangeModel[sModel].dataSource}' in the model does not exists as dataSource or must be allowed type of ${SUPPORTED_MODEL_DATASOURCE_TYPES.join("|")}`);
           }
         }
       });
@@ -2276,14 +2254,14 @@ var AddNewModel = {
     if (oChangeDataSource) {
       Object.keys(oChangeDataSource).forEach(function (sDataSource) {
         if (!isDataSourceTypeSupported(oChangeDataSource, sDataSource, SUPPORTED_DATASOURCE_TYPES)) {
-          throw new Error("The dataSource '" + sDataSource + "' has the type '" + oChangeDataSource[sDataSource]["type"] + "', but only dataSources with the follwing types are supported: " + SUPPORTED_DATASOURCE_TYPES.join("|"));
+          throw new Error(`The dataSource '${sDataSource}' has the type '${oChangeDataSource[sDataSource].type}', but only dataSources with the follwing types are supported: ${SUPPORTED_DATASOURCE_TYPES.join("|")}`);
         }
         if (!isChangeDataSourceUsedByChangeModel(oChangeDataSource, oChangeModel, sDataSource)) {
-          throw new Error("The dataSource in the change '" + sDataSource + "' is not used by any model in the change. A dataSource in the change must be used by model in the change");
+          throw new Error(`The dataSource in the change '${sDataSource}' is not used by any model in the change. A dataSource in the change must be used by model in the change`);
         }
-        if (oChangeDataSource[sDataSource]["type"] === "ODataAnnotation") {
+        if (oChangeDataSource[sDataSource].type === "ODataAnnotation") {
           if (!isODataDefinedForODataAnnotation(oChangeDataSource, sDataSource)) {
-            throw new Error("There is no dataSource with type 'OData' defined which includes the annotation '" + sDataSource + "'");
+            throw new Error(`There is no dataSource with type 'OData' defined which includes the annotation '${sDataSource}'`);
           }
         }
       });
@@ -2314,10 +2292,10 @@ function checkingDataSourceId(oManifestDataSources, sChangeDataSourceId) {
   if (sChangeDataSourceId) {
     if (Object.keys(oManifestDataSources).length > 0) {
       if (!isDataSourceIdExistingInManifest(oManifestDataSources, sChangeDataSourceId)) {
-        throw new Error("There is no dataSource '" + sChangeDataSourceId + "' existing in the manifest. You can only add annotations to already existing dataSources in the manifest");
+        throw new Error(`There is no dataSource '${sChangeDataSourceId}' existing in the manifest. You can only add annotations to already existing dataSources in the manifest`);
       }
       if (!isDataSourceTypeOData(oManifestDataSources, sChangeDataSourceId)) {
-        throw new Error("The dataSource '" + sChangeDataSourceId + "' is existing in the manifest but is not type of 'OData'. The type of the dataSource in the manifest is '" + oManifestDataSources[sChangeDataSourceId].type + "'");
+        throw new Error(`The dataSource '${sChangeDataSourceId}' is existing in the manifest but is not type of 'OData'. The type of the dataSource in the manifest is '${oManifestDataSources[sChangeDataSourceId].type}'`);
       }
     } else {
       throw new Error("There are no dataSources in the manifest at all");
@@ -2337,7 +2315,7 @@ function checkingAnnotationArray(aChangeAnnotations) {
 }
 function checkingAnnotationsInsertPosition(sChangeAnnotationsInsertPosition) {
   if (!(SUPPORTED_INSERT_POSITION.indexOf(sChangeAnnotationsInsertPosition) >= 0) && !(sChangeAnnotationsInsertPosition === undefined)) {
-    throw new Error("The defined insert position '" + sChangeAnnotationsInsertPosition + "' is not supported. The supported insert positions are: " + SUPPORTED_INSERT_POSITION.join("|"));
+    throw new Error(`The defined insert position '${sChangeAnnotationsInsertPosition}' is not supported. The supported insert positions are: ${SUPPORTED_INSERT_POSITION.join("|")}`);
   }
 }
 function checkingAnnotationDataSource(oChangeDataSource, aChangeAnnotations, oChange) {
@@ -2348,10 +2326,10 @@ function checkingAnnotationDataSource(oChangeDataSource, aChangeAnnotations, oCh
     Object.keys(oChangeDataSource).forEach(function (sAnnotation) {
       DescriptorChangeCheck.checkIdNamespaceCompliance(sAnnotation, oChange);
       if (!isAnnotationTypeOfOdataAnnotation(oChangeDataSource, sAnnotation)) {
-        throw new Error("The dataSource annotation '" + sAnnotation + "' is type of '" + oChangeDataSource[sAnnotation].type + "'. Only dataSource annotations of type 'ODataAnnotation' is supported");
+        throw new Error(`The dataSource annotation '${sAnnotation}' is type of '${oChangeDataSource[sAnnotation].type}'. Only dataSource annotations of type 'ODataAnnotation' is supported`);
       }
       if (!isAnnotationPartOfAnnotationsArray(aChangeAnnotations, sAnnotation)) {
-        throw new Error("The annotation '" + sAnnotation + "' is not part of 'annotations' array property. Please add the annotation '" + sAnnotation + "' in the 'annotations' array property");
+        throw new Error(`The annotation '${sAnnotation}' is not part of 'annotations' array property. Please add the annotation '${sAnnotation}' in the 'annotations' array property`);
       }
     });
   } else {
@@ -2363,20 +2341,16 @@ function merge$1(oManifestDataSources, sChangeDataSourceId, aChangeAnnotations,
   mergeAnnotationDataSources(oManifestDataSources, oChangeDataSource);
 }
 function mergeAnnotationArray(oManifestDataSourceId, aChangeAnnotations, sChangeAnnotationsInsertPosition) {
-  if (!oManifestDataSourceId["settings"]) {
-    oManifestDataSourceId["settings"] = {};
-  }
-  if (!oManifestDataSourceId["settings"].annotations) {
-    oManifestDataSourceId["settings"].annotations = [];
-  }
-  var aNotExistingAnnotationsInChange = oManifestDataSourceId["settings"].annotations.filter(function (annotation) {
+  oManifestDataSourceId.settings ||= {};
+  oManifestDataSourceId.settings.annotations ||= [];
+  var aNotExistingAnnotationsInChange = oManifestDataSourceId.settings.annotations.filter(function (annotation) {
     return aChangeAnnotations.indexOf(annotation) < 0;
   });
-  oManifestDataSourceId["settings"].annotations = aNotExistingAnnotationsInChange;
+  oManifestDataSourceId.settings.annotations = aNotExistingAnnotationsInChange;
   if (sChangeAnnotationsInsertPosition === "END") {
-    oManifestDataSourceId["settings"].annotations = oManifestDataSourceId["settings"].annotations.concat(aChangeAnnotations);
+    oManifestDataSourceId.settings.annotations = oManifestDataSourceId.settings.annotations.concat(aChangeAnnotations);
   } else {
-    oManifestDataSourceId["settings"].annotations = aChangeAnnotations.concat(oManifestDataSourceId["settings"].annotations);
+    oManifestDataSourceId.settings.annotations = aChangeAnnotations.concat(oManifestDataSourceId.settings.annotations);
   }
 }
 function mergeAnnotationDataSources(oManifestDataSources, oChangeDataSource) {
@@ -2385,12 +2359,12 @@ function mergeAnnotationDataSources(oManifestDataSources, oChangeDataSource) {
 function postChecks(oManifestDataSources, oChangeDataSource, aChangeAnnotations) {
   aChangeAnnotations.forEach(function (sAnnotation) {
     if (!isAnnotationExisting(oManifestDataSources, oChangeDataSource, sAnnotation)) {
-      throw new Error("The annotation '" + sAnnotation + "' is part of 'annotations' array property but does not exists in the change property 'dataSource' and in the manifest (or it is not type of 'ODataAnnotation' in the manifest)");
+      throw new Error(`The annotation '${sAnnotation}' is part of 'annotations' array property but does not exists in the change property 'dataSource' and in the manifest (or it is not type of 'ODataAnnotation' in the manifest)`);
     }
   });
 }
 var AddAnnotationsToOData = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     var sChangeDataSourceId = oChange.getContent().dataSourceId;
     var aChangeAnnotations = oChange.getContent().annotations;
     var sChangeAnnotationsInsertPosition = oChange.getContent().annotationsInsertPosition;
@@ -2399,8 +2373,8 @@ var AddAnnotationsToOData = {
     checkingAnnotationArray(aChangeAnnotations);
     checkingAnnotationsInsertPosition(sChangeAnnotationsInsertPosition);
     checkingAnnotationDataSource(oChangeDataSource, aChangeAnnotations, oChange);
-    postChecks(oManifest["sap.app"]["dataSources"], oChangeDataSource, aChangeAnnotations);
-    merge$1(oManifest["sap.app"]["dataSources"], sChangeDataSourceId, aChangeAnnotations, sChangeAnnotationsInsertPosition, oChangeDataSource);
+    postChecks(oManifest["sap.app"].dataSources, oChangeDataSource, aChangeAnnotations);
+    merge$1(oManifest["sap.app"].dataSources, sChangeDataSourceId, aChangeAnnotations, sChangeAnnotationsInsertPosition, oChangeDataSource);
     return oManifest;
   }
 };
@@ -2409,12 +2383,12 @@ function checkManifestPath(oManifest) {
   if (!oManifest["sap.app"].hasOwnProperty("crossNavigation")) {
     throw new Error("No sap.app/crossNavigation path exists in the manifest");
   }
-  if (!oManifest["sap.app"]["crossNavigation"].hasOwnProperty("inbounds")) {
+  if (!oManifest["sap.app"].crossNavigation.hasOwnProperty("inbounds")) {
     throw new Error("No sap.app/crossNavigation/inbounds path exists in the manifest");
   }
 }
 function getAndCheckInboundId$1(oChangeContent) {
-  var sInbounds = oChangeContent["inboundId"];
+  var sInbounds = oChangeContent.inboundId;
   if (sInbounds === "") {
     throw new Error("The ID of your inbound is empty");
   }
@@ -2425,35 +2399,39 @@ function getAndCheckInboundId$1(oChangeContent) {
 }
 function merge(oManifest, sInboundId) {
   var oInbound = {};
-  oInbound[sInboundId] = oManifest["sap.app"]["crossNavigation"]["inbounds"][sInboundId];
-  oManifest["sap.app"]["crossNavigation"]["inbounds"] = oInbound;
+  oInbound[sInboundId] = oManifest["sap.app"].crossNavigation.inbounds[sInboundId];
+  oManifest["sap.app"].crossNavigation.inbounds = oInbound;
 }
 var RemoveAllInboundsExceptOne = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     checkManifestPath(oManifest);
     var sInboundId = getAndCheckInboundId$1(oChange.getContent());
-    if (oManifest["sap.app"]["crossNavigation"]["inbounds"][sInboundId]) {
+    if (oManifest["sap.app"].crossNavigation.inbounds[sInboundId]) {
       merge(oManifest, sInboundId);
     } else {
-      throw new Error("No inbound exists with the ID \"" + sInboundId + "\" in sap.app/crossNavigation/inbounds");
+      throw new Error(`No inbound exists with the ID "${sInboundId}" in sap.app/crossNavigation/inbounds`);
     }
     return oManifest;
   }
 };
 
 var SUPPORTED_OPERATIONS = ["UPDATE", "UPSERT"];
-var SUPPORTED_PROPERTIES = ["title", "subTitle", "icon", "signature/parameters/*"];
+var SUPPORTED_PROPERTIES = ["semanticObject", "action", "title", "subTitle", "icon", "signature/parameters/*"];
+var PROPERTIES_PATTERNS = {
+  semanticObject: "^[\\w\\*]{0,30}$",
+  action: "^[\\w\\*]{0,60}$"
+};
 var ChangeInbound = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     var oCrossNavigation = oManifest["sap.app"].crossNavigation;
     var oChangeContent = oChange.getContent();
-    DescriptorChangeCheck.checkEntityPropertyChange(oChangeContent, SUPPORTED_PROPERTIES, SUPPORTED_OPERATIONS);
+    DescriptorChangeCheck.checkEntityPropertyChange(oChangeContent, SUPPORTED_PROPERTIES, SUPPORTED_OPERATIONS, PROPERTIES_PATTERNS);
     if (oCrossNavigation && oCrossNavigation.inbounds) {
       var oInbound = oCrossNavigation.inbounds[oChangeContent.inboundId];
       if (oInbound) {
         changePropertyValueByPath(oChangeContent.entityPropertyChange, oInbound);
       } else {
-        throw new Error("Nothing to update. Inbound with ID \"" + oChangeContent.inboundId + "\" does not exist.");
+        throw new Error(`Nothing to update. Inbound with ID "${oChangeContent.inboundId}" does not exist.`);
       }
     } else {
       throw new Error("sap.app/crossNavigation or sap.app/crossNavigation/inbounds sections have not been found in manifest.json");
@@ -2463,7 +2441,7 @@ var ChangeInbound = {
 };
 
 function getAndCheckInboundId(oChangeContent) {
-  var aInbounds = Object.keys(oChangeContent["inbound"]);
+  var aInbounds = Object.keys(oChangeContent.inbound);
   if (aInbounds.length > 1) {
     throw new Error("It is not allowed to add more than one inbound");
   }
@@ -2476,33 +2454,29 @@ function getAndCheckInboundId(oChangeContent) {
   return aInbounds[aInbounds.length - 1];
 }
 var AddNewInbound = {
-  applyChange: function (oManifest, oChange) {
-    if (!oManifest["sap.app"]["crossNavigation"]) {
-      oManifest["sap.app"]["crossNavigation"] = {};
-    }
-    if (!oManifest["sap.app"]["crossNavigation"]["inbounds"]) {
-      oManifest["sap.app"]["crossNavigation"]["inbounds"] = {};
-    }
+  applyChange(oManifest, oChange) {
+    oManifest["sap.app"].crossNavigation ||= {};
+    oManifest["sap.app"].crossNavigation.inbounds ||= {};
     var oChangeContent = oChange.getContent();
     var sInboundId = getAndCheckInboundId(oChangeContent);
-    var oInboundInManifest = oManifest["sap.app"]["crossNavigation"]["inbounds"][sInboundId];
+    var oInboundInManifest = oManifest["sap.app"].crossNavigation.inbounds[sInboundId];
     if (!oInboundInManifest) {
       DescriptorChangeCheck.checkIdNamespaceCompliance(sInboundId, oChange);
-      oManifest["sap.app"]["crossNavigation"]["inbounds"][sInboundId] = oChangeContent["inbound"][sInboundId];
+      oManifest["sap.app"].crossNavigation.inbounds[sInboundId] = oChangeContent.inbound[sInboundId];
     } else {
-      throw new Error("Inbound with ID \"" + sInboundId + "\" already exist.");
+      throw new Error(`Inbound with ID "${sInboundId}" already exist.`);
     }
     return oManifest;
   }
 };
 
 var SetAbstract = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     if (!oChange.getContent().hasOwnProperty("abstract")) {
       throw new Error("No abstract in change content provided");
     }
     if (oChange.getContent().abstract !== false) {
-      throw new Error("The current change value of property abstract is '" + oChange.getContent().abstract + "'. Only allowed value for property abstract is boolean 'false'");
+      throw new Error(`The current change value of property abstract is '${oChange.getContent().abstract}'. Only allowed value for property abstract is boolean 'false'`);
     }
     ObjectPath.set(["sap.fiori", "abstract"], oChange.getContent().abstract, oManifest);
     return oManifest;
@@ -2521,11 +2495,9 @@ function _mergeExistingLibrary(oManifestLib, oChangeLib) {
   return oUpdatedLibrary;
 }
 var AddLibrary = {
-  applyChange: function (oManifest, oChange) {
-    if (!oManifest["sap.ui5"]["dependencies"]["libs"]) {
-      oManifest["sap.ui5"]["dependencies"]["libs"] = {};
-    }
-    var oManifestLibs = oManifest["sap.ui5"]["dependencies"]["libs"];
+  applyChange(oManifest, oChange) {
+    oManifest["sap.ui5"].dependencies.libs ||= {};
+    var oManifestLibs = oManifest["sap.ui5"].dependencies.libs;
     var oChangeLibs = oChange.getContent().libraries;
     Object.keys(oChangeLibs).forEach(function (sLibName) {
       if (oManifestLibs[sLibName]) {
@@ -2539,14 +2511,14 @@ var AddLibrary = {
 };
 
 var SetTitle = {
-  applyChange: function (oManifest) {
-    oManifest["sap.app"].title = "{{" + oManifest["sap.app"].id + "_sap.app.title}}";
+  applyChange(oManifest) {
+    oManifest["sap.app"].title = `{{${oManifest["sap.app"].id}_sap.app.title}}`;
     return oManifest;
   }
 };
 
 var ChangeCard = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     var oChangedCard = oChange.getContent();
     var bIsOperationValid = oChangedCard.entityPropertyChange.operation === "UPSERT";
     var oOldCards = oManifest["sap.ovp"].cards;
@@ -2567,7 +2539,7 @@ var ChangeCard = {
 };
 
 var AddNewCard = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     var oNewCard = oChange.getContent();
     var oOldCards = oManifest["sap.ovp"].cards;
     if (("card" in oNewCard) && Object.keys(oNewCard.card).length > 0 && !((Object.keys(oNewCard.card) in oOldCards))) {
@@ -2580,7 +2552,7 @@ var AddNewCard = {
 };
 
 var DeleteCard = {
-  applyChange: function (oManifest, oChange) {
+  applyChange(oManifest, oChange) {
     var oDeleteCard = oChange.getContent();
     var oOldCards = oManifest["sap.ovp"].cards;
     if ((oDeleteCard.cardId in oOldCards)) {
@@ -2599,12 +2571,20 @@ var fnAssert = function (bResult, vMessage) {
   }
 };
 
-var fnNow = !(typeof window != "undefined" && window.performance && performance.now && performance.timing) ? Date.now : (function () {
-  var iNavigationStart = performance.timing.navigationStart;
-  return function perfnow() {
-    return iNavigationStart + performance.now();
-  };
-})();
+class config {
+  static get Type() {
+    return {
+      String: "string"
+    };
+  }
+  static get({name}) {
+    return name === "sapUiLogLevel" ? "Error" : undefined;
+  }
+}
+
+var fnNow = function now() {
+  return performance.timeOrigin + performance.now();
+};
 
 var Log = {};
 Log.Level = {
@@ -2846,6 +2826,17 @@ Log.getLogger = function (sComponent, iDefaultLogLevel) {
   }
   return new Logger(sComponent);
 };
+const sLogLevel = config.get({
+  name: "sapUiLogLevel",
+  type: config.Type.String,
+  defaultValue: undefined,
+  external: true
+});
+if (sLogLevel) {
+  Log.setLevel(Log.Level[sLogLevel.toUpperCase()] || parseInt(sLogLevel));
+} else if (!globalThis["sap-ui-optimized"]) {
+  Log.setLevel(Log.Level.DEBUG);
+}
 
 var fnUniqueSort = function (aArray) {
   fnAssert(Array.isArray(aArray), "uniqueSort: input parameter must be an Array");
@@ -2871,13 +2862,16 @@ function isFunction(obj) {
 var Metadata = function (sClassName, oClassInfo) {
   fnAssert(typeof sClassName === "string" && sClassName, "Metadata: sClassName must be a non-empty string");
   fnAssert(typeof oClassInfo === "object", "Metadata: oClassInfo must be empty or an object");
-  if (!oClassInfo || typeof oClassInfo.metadata !== "object") {
-    oClassInfo = {
-      metadata: oClassInfo || ({}),
-      constructor: ObjectPath.get(sClassName)
-    };
-    oClassInfo.metadata.__version = 1;
-  }
+  (() => {
+    if (!oClassInfo || typeof oClassInfo.metadata !== "object") {
+      oClassInfo = {
+        metadata: oClassInfo || ({}),
+        constructor: ObjectPath.get(sClassName)
+      };
+      oClassInfo.metadata.__version = 1;
+    }
+  })();
+  oClassInfo.metadata ??= {};
   oClassInfo.metadata.__version = oClassInfo.metadata.__version || 2;
   if (!isFunction(oClassInfo.constructor)) {
     throw Error("constructor for class " + sClassName + " must have been declared before creating metadata for it");
@@ -2893,13 +2887,14 @@ Metadata.prototype.extend = function (oClassInfo) {
 Metadata.prototype.applySettings = function (oClassInfo) {
   var that = this, oStaticInfo = oClassInfo.metadata, oPrototype;
   if (oStaticInfo.baseType) {
-    var oParentClass;
-    if (isFunction(oStaticInfo.baseType)) {
+    var oParentClass, bValidBaseType = isFunction(oStaticInfo.baseType);
+    if (bValidBaseType) {
       oParentClass = oStaticInfo.baseType;
       if (!isFunction(oParentClass.getMetadata)) {
         throw new TypeError("baseType must be a UI5 class with a static getMetadata function");
       }
-    } else {
+    }
+    if (!bValidBaseType) {
       oParentClass = ObjectPath.get(oStaticInfo.baseType);
       if (!isFunction(oParentClass)) {
         Log.fatal("base class '" + oStaticInfo.baseType + "' does not exist");
@@ -3125,6 +3120,9 @@ BaseObject.prototype.isA = function (vTypeName) {
 BaseObject.isA = function (oObject, vTypeName) {
   return oObject instanceof BaseObject && oObject.isA(vTypeName);
 };
+BaseObject.isObjectA = function (oObject, vTypeName) {
+  return oObject instanceof BaseObject && oObject.isA(vTypeName);
+};
 BaseObject._Interface = function (oObject, aMethods, _bReturnFacade) {
   if (!oObject) {
     return oObject;
@@ -3170,7 +3168,7 @@ var fnIsPlainObject = function (obj) {
 };
 
 var oToken = Object.create(null);
-var fnMerge = function () {
+var fnMerge$1 = function () {
   var src, copyIsArray, copy, name, options, clone, target = arguments[2] || ({}), i = 3, length = arguments.length, deep = arguments[0] || false, skipToken = arguments[1] ? undefined : oToken;
   if (typeof target !== "object" && typeof target !== "function") {
     target = {};
@@ -3190,7 +3188,7 @@ var fnMerge = function () {
           } else {
             clone = src && fnIsPlainObject(src) ? src : {};
           }
-          target[name] = fnMerge(deep, arguments[1], clone, copy);
+          target[name] = fnMerge$1(deep, arguments[1], clone, copy);
         } else if (copy !== skipToken) {
           target[name] = copy;
         }
@@ -3203,7 +3201,7 @@ var fnMerge = function () {
 var fnExtend = function () {
   var args = [false, true];
   args.push.apply(args, arguments);
-  return fnMerge.apply(null, args);
+  return fnMerge$1.apply(null, args);
 };
 
 var sFioriComponent = "FioriElements: ";
@@ -3284,12 +3282,12 @@ var mergerUtil = {
       }
       var aChildkeys = Object.keys(oChangeContent.childPage.definition);
       aChildkeys.forEach(function (sKey) {
-        if (!fnIncludes(aSupportedProperties, sKey)) {
+        if (!aSupportedProperties.includes(sKey)) {
           throw new Error("Changing " + sKey + " is not supported. The supported 'propertyPath' is: " + aSupportedProperties.join(","));
         }
       });
       var aMandatoryParams = aSupportedProperties.filter(function (sComponentKey) {
-        return !fnIncludes(aChildkeys, sComponentKey);
+        return !aChildkeys.includes(sComponentKey);
       });
       if (aMandatoryParams.length) {
         throw new Error("Mandatory parameter " + aMandatoryParams + " is not defined.");
@@ -3370,76 +3368,76 @@ var changePageConfiguration = {
   }
 };
 
-var o = {};
-let e = {};
-function i(n, o) {
-  const e = o.getContent();
-  const i = e === null || e === void 0 ? void 0 : e.page;
-  const a = e === null || e === void 0 ? void 0 : e.entityPropertyChange;
-  if ((a === null || a === void 0 ? void 0 : a.operation) !== "UPSERT" || !(a !== null && a !== void 0 && a.propertyPath) || (a === null || a === void 0 ? void 0 : a.propertyValue) === undefined || a !== null && a !== void 0 && a.propertyPath.startsWith("/")) {
+var _exports = {};
+let pageConfigurationChanges = {};
+function applyChange(manifest, change) {
+  const changeContent = change.getContent();
+  const pageId = changeContent === null || changeContent === void 0 ? void 0 : changeContent.page;
+  const propertyChange = changeContent === null || changeContent === void 0 ? void 0 : changeContent.entityPropertyChange;
+  if ((propertyChange === null || propertyChange === void 0 ? void 0 : propertyChange.operation) !== "UPSERT" || !(propertyChange !== null && propertyChange !== void 0 && propertyChange.propertyPath) || (propertyChange === null || propertyChange === void 0 ? void 0 : propertyChange.propertyValue) === undefined || propertyChange !== null && propertyChange !== void 0 && propertyChange.propertyPath.startsWith("/")) {
     Log.error("Change content is not a valid");
-    return n;
+    return manifest;
   }
-  return r(n, i, a.propertyPath, a.propertyValue);
+  return changeConfiguration(manifest, pageId, propertyChange.propertyPath, propertyChange.propertyValue);
 }
-o.applyChange = i;
-function r(o, i, r, l, u) {
-  const c = s(o, i);
-  if (c) {
-    const t = a(r);
-    ObjectPath.set(t, l, c);
-    if (u) {
-      e[i] = e[i] || [];
-      e[i].push(r);
+_exports.applyChange = applyChange;
+function changeConfiguration(manifest, pageId, path, value, lateChange) {
+  const pageSettings = getPageSettings(manifest, pageId);
+  if (pageSettings) {
+    const propertyPath = retrievePropertyPath(path);
+    ObjectPath.set(propertyPath, value, pageSettings);
+    if (lateChange) {
+      pageConfigurationChanges[pageId] = pageConfigurationChanges[pageId] || [];
+      pageConfigurationChanges[pageId].push(path);
     }
   } else {
-    Log.error(`No Fiori elements page with ID ${i} found in routing targets.`);
-  }
-  return o;
-}
-o.changeConfiguration = r;
-function a(t) {
-  let n = t.split("/");
-  if (n[0] === "controlConfiguration") {
-    let t = "";
-    for (let o = 1; o < n.length; o++) {
-      t += (o > 1 ? "/" : "") + n[o];
-      if (t.indexOf("@") > -1) {
-        n = ["controlConfiguration", t].concat(n.slice(o + 1));
+    Log.error(`No Fiori elements page with ID ${pageId} found in routing targets.`);
+  }
+  return manifest;
+}
+_exports.changeConfiguration = changeConfiguration;
+function retrievePropertyPath(path) {
+  let propertyPath = path.split("/");
+  if (propertyPath[0] === "controlConfiguration") {
+    let annotationPath = "";
+    for (let i = 1; i < propertyPath.length; i++) {
+      annotationPath += (i > 1 ? "/" : "") + propertyPath[i];
+      if (annotationPath.includes("@")) {
+        propertyPath = ["controlConfiguration", annotationPath].concat(propertyPath.slice(i + 1));
         break;
       }
     }
   }
-  return n;
+  return propertyPath;
 }
-function s(t, n) {
-  var o, e;
-  let i;
-  const r = ((o = t["sap.ui5"]) === null || o === void 0 ? void 0 : (e = o.routing) === null || e === void 0 ? void 0 : e.targets) ?? ({});
-  for (const t in r) {
-    if (r[t].id === n && r[t].name.startsWith("sap.fe.templates.")) {
-      var a;
-      i = ((a = r[t].options) === null || a === void 0 ? void 0 : a.settings) ?? ({});
+function getPageSettings(manifest, pageId) {
+  var _manifest$sapUi, _manifest$sapUi$routi;
+  let pageSettings;
+  const targets = ((_manifest$sapUi = manifest["sap.ui5"]) === null || _manifest$sapUi === void 0 ? void 0 : (_manifest$sapUi$routi = _manifest$sapUi.routing) === null || _manifest$sapUi$routi === void 0 ? void 0 : _manifest$sapUi$routi.targets) ?? ({});
+  for (const p in targets) {
+    if (targets[p].id === pageId && targets[p].name.startsWith("sap.fe.templates.")) {
+      var _targets$p$options;
+      pageSettings = ((_targets$p$options = targets[p].options) === null || _targets$p$options === void 0 ? void 0 : _targets$p$options.settings) ?? ({});
       break;
     }
   }
-  return i;
+  return pageSettings;
 }
-function l(t, o, i, r) {
-  o = o ?? ({});
-  const s = e[r] || [];
-  for (const e of s) {
-    const i = a(e);
-    const r = ObjectPath.get(i, t);
-    ObjectPath.set(i, r, o);
-  }
-  return o;
+function applyPageConfigurationChanges(manifest, viewData, appComponent, pageId) {
+  viewData = viewData ?? ({});
+  const pageChanges = pageConfigurationChanges[pageId] || [];
+  for (const path of pageChanges) {
+    const propertyPath = retrievePropertyPath(path);
+    const manifestValue = ObjectPath.get(propertyPath, manifest);
+    ObjectPath.set(propertyPath, manifestValue, viewData);
+  }
+  return viewData;
 }
-o.applyPageConfigurationChanges = l;
-function u() {
-  e = {};
+_exports.applyPageConfigurationChanges = applyPageConfigurationChanges;
+function cleanPageConfigurationChanges() {
+  pageConfigurationChanges = {};
 }
-o.cleanPageConfigurationChanges = u;
+_exports.cleanPageConfigurationChanges = cleanPageConfigurationChanges;
 
 var Registration = {
   appdescr_ui5_addLibraries: () => Promise.resolve(AddLibrary),
@@ -3449,7 +3447,7 @@ var Registration = {
   appdescr_ovp_removeCard: () => Promise.resolve(DeleteCard),
   appdescr_ui_generic_app_addNewObjectPage: () => Promise.resolve(addNewObjectPage),
   appdescr_ui_generic_app_changePageConfiguration: () => Promise.resolve(changePageConfiguration),
-  appdescr_fe_changePageConfiguration: () => Promise.resolve(o)
+  appdescr_fe_changePageConfiguration: () => Promise.resolve(_exports)
 };
 
 var RegistrationBuild = {
@@ -3469,7 +3467,3486 @@ var RegistrationBuild = {
 var RegistrationCopy = Object.assign({}, Registration);
 var RegistrationBuild$1 = Object.assign(RegistrationCopy, RegistrationBuild);
 
-exports.Applier = Applier;
-exports.ApplyUtil = ApplyUtil;
-exports.Change = Change;
-exports.RegistrationBuild = RegistrationBuild$1;
+var fnEqual = function (a, b, maxDepth, contains, depth) {
+  if (typeof maxDepth == "boolean") {
+    contains = maxDepth;
+    maxDepth = undefined;
+  }
+  if (!depth) {
+    depth = 0;
+  }
+  if (!maxDepth) {
+    maxDepth = 10;
+  }
+  if (depth > maxDepth) {
+    Log.warning("deepEqual comparison exceeded maximum recursion depth of " + maxDepth + ". Treating values as unequal");
+    return false;
+  }
+  if (a === b || Number.isNaN(a) && Number.isNaN(b)) {
+    return true;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (!contains && a.length !== b.length) {
+      return false;
+    }
+    if (a.length > b.length) {
+      return false;
+    }
+    for (var i = 0; i < a.length; i++) {
+      if (!fnEqual(a[i], b[i], maxDepth, contains, depth + 1)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (typeof a == "object" && typeof b == "object") {
+    if (!a || !b) {
+      return false;
+    }
+    if (a.constructor !== b.constructor) {
+      return false;
+    }
+    if (!contains && Object.keys(a).length !== Object.keys(b).length) {
+      return false;
+    }
+    if (a instanceof Node) {
+      return a.isEqualNode(b);
+    }
+    if (a instanceof Date) {
+      return a.valueOf() === b.valueOf();
+    }
+    for (var i in a) {
+      if (!fnEqual(a[i], b[i], maxDepth, contains, depth + 1)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+};
+
+var fnMerge = function () {
+  var args = [true, false];
+  args.push.apply(args, arguments);
+  return fnMerge$1.apply(null, args);
+};
+
+var iIdCounter = 0;
+var fnUid = function uid() {
+  return "id-" + new Date().valueOf() + "-" + iIdCounter++;
+};
+
+var oResolved = new SyncPromise(function (resolve, reject) {
+  resolve();
+}), oResolvedNull = new SyncPromise(function (resolve, reject) {
+  resolve(null);
+});
+function call(fnThen, resolve, reject) {
+  var bOnce;
+  function rejectPromise(vReason) {
+    if (!bOnce) {
+      bOnce = true;
+      reject(vReason);
+    }
+  }
+  function resolvePromise(vResult) {
+    if (!bOnce) {
+      bOnce = true;
+      resolve(vResult);
+    }
+  }
+  try {
+    fnThen(resolvePromise, rejectPromise);
+  } catch (e) {
+    rejectPromise(e);
+  }
+}
+function hasThen(vValue) {
+  return vValue && (typeof vValue === "function" || typeof vValue === "object") && ("then" in vValue);
+}
+function SyncPromise(fnExecutor) {
+  var bCaught = false, iState, fnReject, fnResolve, vResult, that = this;
+  function reject(vReason) {
+    vResult = vReason;
+    iState = -1;
+    if (!bCaught && SyncPromise.listener) {
+      SyncPromise.listener(that, false);
+    }
+    if (fnReject) {
+      fnReject(vReason);
+      fnReject = fnResolve = null;
+    }
+  }
+  function resolve(vResult0) {
+    var fnThen;
+    if (vResult0 === that) {
+      reject(new TypeError("A promise cannot be resolved with itself."));
+      return;
+    }
+    if (vResult0 instanceof SyncPromise) {
+      if (vResult0.isFulfilled()) {
+        resolve(vResult0.getResult());
+        return;
+      } else if (vResult0.isRejected()) {
+        vResult0.caught();
+        reject(vResult0.getResult());
+        return;
+      } else {
+        vResult0.caught();
+        vResult0 = vResult0.getResult();
+      }
+    }
+    iState = 0;
+    vResult = vResult0;
+    if (hasThen(vResult)) {
+      try {
+        fnThen = vResult.then;
+      } catch (e) {
+        reject(e);
+        return;
+      }
+      if (typeof fnThen === "function") {
+        call(fnThen.bind(vResult), resolve, reject);
+        return;
+      }
+    }
+    iState = 1;
+    if (fnResolve) {
+      fnResolve(vResult);
+      fnReject = fnResolve = null;
+    }
+  }
+  this.caught = function () {
+    if (!bCaught) {
+      bCaught = true;
+      if (SyncPromise.listener && this.isRejected()) {
+        SyncPromise.listener(this, true);
+      }
+    }
+  };
+  this.getResult = function () {
+    return vResult;
+  };
+  this.isFulfilled = function () {
+    return iState === 1;
+  };
+  this.isPending = function () {
+    return !iState;
+  };
+  this.isRejected = function () {
+    return iState === -1;
+  };
+  call(fnExecutor, resolve, reject);
+  if (iState === undefined) {
+    vResult = new Promise(function (resolve, reject) {
+      fnResolve = resolve;
+      fnReject = reject;
+    });
+    vResult.catch(function () {});
+  }
+}
+SyncPromise.prototype.catch = function (fnOnRejected) {
+  return this.then(undefined, fnOnRejected);
+};
+SyncPromise.prototype.finally = function (fnOnFinally) {
+  if (typeof fnOnFinally === "function") {
+    return this.then(function (vResult) {
+      return SyncPromise.resolve(fnOnFinally()).then(function () {
+        return vResult;
+      }).unwrap();
+    }, function (vReason) {
+      return SyncPromise.resolve(fnOnFinally()).then(function () {
+        throw vReason;
+      }).unwrap();
+    });
+  }
+  return this.then(fnOnFinally, fnOnFinally);
+};
+SyncPromise.prototype.then = function (fnOnFulfilled, fnOnRejected) {
+  var fnCallback = this.isFulfilled() ? fnOnFulfilled : fnOnRejected, bCallbackIsFunction = typeof fnCallback === "function", bPending = this.isPending(), that = this;
+  if (bPending || bCallbackIsFunction) {
+    this.caught();
+  }
+  if (!bPending) {
+    return bCallbackIsFunction ? new SyncPromise(function (resolve, reject) {
+      resolve(fnCallback(that.getResult()));
+    }) : this;
+  }
+  return SyncPromise.resolve(this.getResult().then(fnOnFulfilled, fnOnRejected));
+};
+SyncPromise.prototype.toString = function () {
+  if (this.isPending()) {
+    return "SyncPromise: pending";
+  }
+  return String(this.getResult());
+};
+SyncPromise.prototype.unwrap = function () {
+  this.caught();
+  if (this.isRejected()) {
+    throw this.getResult();
+  }
+  return this.getResult();
+};
+SyncPromise.all = function (aValues) {
+  return new SyncPromise(function (resolve, reject) {
+    var bDone = false, iPending = 0;
+    function checkFulfilled() {
+      if (bDone && iPending === 0) {
+        resolve(aValues);
+      }
+    }
+    aValues = Array.prototype.slice.call(aValues);
+    aValues.forEach(function (vValue, i) {
+      if (vValue !== aValues[i + 1] && hasThen(vValue)) {
+        iPending += 1;
+        vValue.then(function (vResult0) {
+          do {
+            aValues[i] = vResult0;
+            i -= 1;
+          } while (i >= 0 && vValue === aValues[i]);
+          iPending -= 1;
+          checkFulfilled();
+        }, function (vReason) {
+          reject(vReason);
+        });
+      }
+    });
+    bDone = true;
+    checkFulfilled();
+  });
+};
+SyncPromise.isThenable = function (vValue) {
+  try {
+    return !!hasThen(vValue) && typeof vValue.then === "function";
+  } catch (e) {
+    return false;
+  }
+};
+SyncPromise.reject = function (vReason) {
+  return new SyncPromise(function (resolve, reject) {
+    reject(vReason);
+  });
+};
+SyncPromise.resolve = function (vResult) {
+  if (vResult === undefined) {
+    return oResolved;
+  }
+  if (vResult === null) {
+    return oResolvedNull;
+  }
+  if (vResult instanceof SyncPromise) {
+    return vResult;
+  }
+  return new SyncPromise(function (resolve, reject) {
+    resolve(vResult);
+  });
+};
+
+var rAmpersand = /&/g, rApplicationGroupID = /^\w+$/, sClassName$2 = "sap.ui.model.odata.v4.lib._Helper", rEquals = /\=/g, rEscapedCloseBracket = /%29/g, rEscapedOpenBracket = /%28/g, rEscapedTick = /%27/g, rGroupID = /^(\$auto(\.\w+)?|\$direct|\w+)$/, rHash = /#/g, rNotMetaContext = /\([^/]*|\/-?\d+/g, rPlus = /\+/g, rSingleQuote = /'/g, rSingleQuoteTwice = /''/g, rWhitespace = /\s+/g, _Helper;
+function preserveKeyPredicates(sUrl) {
+  return sUrl.replace(rEscapedTick, "'").replace(rEscapedOpenBracket, "(").replace(rEscapedCloseBracket, ")");
+}
+_Helper = {
+  addByPath: function (mMap, sPath, oItem) {
+    if (oItem) {
+      if (!mMap[sPath]) {
+        mMap[sPath] = [oItem];
+      } else if (!mMap[sPath].includes(oItem)) {
+        mMap[sPath].push(oItem);
+      }
+    }
+  },
+  addChildrenWithAncestor: function (aChildren, aAncestors, mChildren) {
+    if (aAncestors.length) {
+      aChildren.forEach(function (sPath) {
+        var aSegments;
+        if (aAncestors.includes(sPath)) {
+          mChildren[sPath] = true;
+          return;
+        }
+        aSegments = sPath.split("/");
+        aSegments.pop();
+        while (aSegments.length) {
+          if (aAncestors.indexOf(aSegments.join("/")) >= 0) {
+            mChildren[sPath] = true;
+            break;
+          }
+          aSegments.pop();
+        }
+      });
+    }
+  },
+  addPromise: function (oElement) {
+    return new SyncPromise(function (_fnResolve, fnReject) {
+      _Helper.setPrivateAnnotation(oElement, "reject", fnReject);
+    });
+  },
+  addToCount: function (mChangeListeners, sPath, aCollection, iDelta) {
+    if (aCollection.$count !== undefined) {
+      _Helper.setCount(mChangeListeners, sPath, aCollection, aCollection.$count + iDelta);
+    }
+  },
+  addToSelect: function (mQueryOptions, aSelectPaths) {
+    mQueryOptions.$select = mQueryOptions.$select || [];
+    aSelectPaths.forEach(function (sPath) {
+      if (!mQueryOptions.$select.includes(sPath)) {
+        mQueryOptions.$select.push(sPath);
+      }
+    });
+  },
+  adjustTargets: function (oMessage, oOperationMetadata, sParameterContextPath, sContextPath) {
+    var sAdditionalTargetsKey = _Helper.getAnnotationKey(oMessage, ".additionalTargets"), aTargets;
+    aTargets = [oMessage.target].concat(oMessage[sAdditionalTargetsKey]).map(function (sTarget) {
+      return sTarget && _Helper.getAdjustedTarget(sTarget, oOperationMetadata, sParameterContextPath, sContextPath);
+    }).filter(function (sTarget) {
+      return sTarget;
+    });
+    oMessage.target = aTargets[0];
+    if (sAdditionalTargetsKey) {
+      oMessage[sAdditionalTargetsKey] = aTargets.slice(1);
+    }
+  },
+  adjustTargetsInError: function (oError, oOperationMetadata, sParameterContextPath, sContextPath) {
+    if (!oError.error) {
+      return;
+    }
+    _Helper.adjustTargets(oError.error, oOperationMetadata, sParameterContextPath, sContextPath);
+    if (oError.error.details) {
+      oError.error.details.forEach(function (oMessage) {
+        _Helper.adjustTargets(oMessage, oOperationMetadata, sParameterContextPath, sContextPath);
+      });
+    }
+  },
+  aggregateExpandSelect: function (mAggregatedQueryOptions, mQueryOptions) {
+    if (mQueryOptions.$select) {
+      _Helper.addToSelect(mAggregatedQueryOptions, mQueryOptions.$select);
+    }
+    if (mQueryOptions.$expand) {
+      mAggregatedQueryOptions.$expand = mAggregatedQueryOptions.$expand || ({});
+      Object.keys(mQueryOptions.$expand).forEach(function (sPath) {
+        if (mAggregatedQueryOptions.$expand[sPath]) {
+          _Helper.aggregateExpandSelect(mAggregatedQueryOptions.$expand[sPath], mQueryOptions.$expand[sPath]);
+        } else {
+          mAggregatedQueryOptions.$expand[sPath] = mQueryOptions.$expand[sPath];
+        }
+      });
+    }
+  },
+  buildPath: function () {
+    var sPath = "", sSegment, i;
+    for (i = 0; i < arguments.length; i += 1) {
+      sSegment = arguments[i];
+      if (sSegment || sSegment === 0) {
+        if (sPath && sPath !== "/" && sSegment[0] !== "(") {
+          sPath += "/";
+        }
+        sPath += sSegment;
+      }
+    }
+    return sPath;
+  },
+  buildQuery: function (mParameters) {
+    var aKeys, aQuery;
+    if (!mParameters) {
+      return "";
+    }
+    aKeys = Object.keys(mParameters);
+    if (aKeys.length === 0) {
+      return "";
+    }
+    aQuery = [];
+    aKeys.forEach(function (sKey) {
+      var vValue = mParameters[sKey];
+      if (Array.isArray(vValue)) {
+        vValue.forEach(function (sItem) {
+          aQuery.push(_Helper.encodePair(sKey, sItem));
+        });
+      } else {
+        aQuery.push(_Helper.encodePair(sKey, vValue));
+      }
+    });
+    return "?" + aQuery.join("&");
+  },
+  buildSelect: function (aSelect) {
+    var oSelect = {};
+    if (!aSelect || aSelect.includes("*")) {
+      return true;
+    }
+    aSelect.forEach(function (sPath) {
+      var aSegments = sPath.split("/"), iLast = aSegments.length - 1, oSubSelect = oSelect;
+      aSegments.some(function (sSegment, i) {
+        if (i === iLast || aSegments[i + 1] === "*") {
+          oSubSelect[sSegment] = true;
+          return true;
+        }
+        if (oSubSelect[sSegment] === true) {
+          return true;
+        }
+        oSubSelect = oSubSelect[sSegment] = oSubSelect[sSegment] || ({});
+      });
+    });
+    return oSelect;
+  },
+  cancelNestedCreates: function (oElement, sMessage) {
+    Object.keys(oElement).forEach(function (sKey) {
+      var oError, vProperty = oElement[sKey];
+      if (vProperty && vProperty.$postBodyCollection) {
+        oError = new Error(sMessage);
+        oError.canceled = true;
+        vProperty.forEach(function (oChildElement) {
+          _Helper.getPrivateAnnotation(oChildElement, "reject")(oError);
+          _Helper.cancelNestedCreates(oChildElement, sMessage);
+        });
+      }
+    });
+  },
+  checkGroupId: function (sGroupId, bApplicationGroup, bAllowSingle, sErrorMessage) {
+    if (!bApplicationGroup && sGroupId === undefined || typeof sGroupId === "string" && (bApplicationGroup ? rApplicationGroupID : rGroupID).test(sGroupId) || bAllowSingle && sGroupId === "$single") {
+      return;
+    }
+    throw new Error((sErrorMessage || "Invalid group ID: ") + sGroupId);
+  },
+  clone: function clone(vValue, fnReplacer, bAsString) {
+    var sStringified;
+    if (vValue === undefined || vValue === Infinity || vValue === -Infinity || Number.isNaN(vValue)) {
+      return vValue;
+    }
+    sStringified = JSON.stringify(vValue, fnReplacer);
+    return bAsString ? sStringified : JSON.parse(sStringified);
+  },
+  cloneNo$: function cloneNo$(vValue) {
+    return _Helper.clone(vValue, function (sKey, vValue) {
+      return sKey[0] === "$" ? undefined : vValue;
+    });
+  },
+  convertExpandSelectToPaths: function (mQueryOptions) {
+    var aPaths = [];
+    function convert(mQueryOptions0, sPathPrefix) {
+      if (mQueryOptions0.$select) {
+        mQueryOptions0.$select.forEach(function (sSelect) {
+          aPaths.push(_Helper.buildPath(sPathPrefix, sSelect));
+        });
+      }
+      if (mQueryOptions0.$expand) {
+        Object.keys(mQueryOptions0.$expand).forEach(function (sExpandPath) {
+          convert(mQueryOptions0.$expand[sExpandPath], _Helper.buildPath(sPathPrefix, sExpandPath));
+        });
+      }
+    }
+    convert(mQueryOptions, "");
+    return aPaths;
+  },
+  copyPrivateAnnotation: function (oSource, sAnnotation, oTarget) {
+    if (_Helper.hasPrivateAnnotation(oSource, sAnnotation)) {
+      if (_Helper.hasPrivateAnnotation(oTarget, sAnnotation)) {
+        throw new Error("Must not overwrite: " + sAnnotation);
+      }
+      _Helper.setPrivateAnnotation(oTarget, sAnnotation, _Helper.getPrivateAnnotation(oSource, sAnnotation));
+    }
+  },
+  createError: function (jqXHR, sMessage, sRequestUrl, sResourcePath) {
+    var sBody = jqXHR.responseText, sContentType = jqXHR.getResponseHeader("Content-Type"), sPreference, oResult = new Error(sMessage + ": " + jqXHR.status + " " + jqXHR.statusText), sRetryAfter = jqXHR.getResponseHeader("Retry-After"), iRetryAfter;
+    oResult.status = jqXHR.status;
+    oResult.statusText = jqXHR.statusText;
+    oResult.requestUrl = sRequestUrl;
+    oResult.resourcePath = sResourcePath;
+    if (jqXHR.status === 0) {
+      oResult.message = "Network error";
+      return oResult;
+    }
+    if (sContentType) {
+      sContentType = sContentType.split(";")[0];
+    }
+    if (jqXHR.status === 412) {
+      sPreference = jqXHR.getResponseHeader("Preference-Applied");
+      if (sPreference && sPreference.replace(rWhitespace, "") === "handling=strict") {
+        oResult.strictHandlingFailed = true;
+      } else {
+        oResult.isConcurrentModification = true;
+      }
+    }
+    if (sRetryAfter) {
+      iRetryAfter = parseInt(sRetryAfter);
+      oResult.retryAfter = new Date(Number.isNaN(iRetryAfter) ? sRetryAfter : Date.now() + iRetryAfter * 1000);
+    }
+    if (sContentType === "application/json") {
+      try {
+        oResult.error = JSON.parse(sBody).error;
+        oResult.message = oResult.error.message;
+        if (typeof oResult.message === "object") {
+          oResult.message = oResult.error.message.value;
+        }
+      } catch (e) {
+        Log.warning(e.toString(), sBody, sClassName$2);
+      }
+    } else if (sContentType === "text/plain") {
+      oResult.message = sBody;
+    }
+    return oResult;
+  },
+  createGetMethod: function (sFetch, bThrow) {
+    return function () {
+      var oSyncPromise = this[sFetch].apply(this, arguments);
+      if (oSyncPromise.isFulfilled()) {
+        return oSyncPromise.getResult();
+      } else if (bThrow) {
+        if (oSyncPromise.isRejected()) {
+          oSyncPromise.caught();
+          throw oSyncPromise.getResult();
+        } else {
+          throw new Error("Result pending");
+        }
+      }
+    };
+  },
+  createMissing: function (oObject, aSegments) {
+    aSegments.reduce(function (oCurrent, sSegment, i) {
+      if (!((sSegment in oCurrent))) {
+        oCurrent[sSegment] = i + 1 < aSegments.length ? {} : null;
+      }
+      return oCurrent[sSegment];
+    }, oObject);
+  },
+  createRequestMethod: function (sFetch) {
+    return function () {
+      return Promise.resolve(this[sFetch].apply(this, arguments));
+    };
+  },
+  createTechnicalDetails: function (oMessage) {
+    var oClonedMessage, oError = oMessage["@$ui5.error"], oOriginalMessage = oMessage["@$ui5.originalMessage"] || oMessage, oTechnicalDetails = {};
+    if (oError && (oError.status || oError.cause)) {
+      oError = oError.cause || oError;
+      oTechnicalDetails.httpStatus = oError.status;
+      if (oError.isConcurrentModification) {
+        oTechnicalDetails.isConcurrentModification = true;
+      }
+      if (oError.retryAfter) {
+        oTechnicalDetails.retryAfter = oError.retryAfter;
+      }
+    }
+    if (!(oOriginalMessage instanceof Error)) {
+      Object.defineProperty(oTechnicalDetails, "originalMessage", {
+        enumerable: true,
+        get: function () {
+          if (!oClonedMessage) {
+            oClonedMessage = _Helper.publicClone(oOriginalMessage);
+          }
+          return oClonedMessage;
+        }
+      });
+    }
+    return oTechnicalDetails;
+  },
+  decomposeError: function (oError, aRequests, sServiceUrl) {
+    var aDetailContentIDs = oError.error.details && oError.error.details.map(function (oDetail) {
+      return _Helper.getContentID(oDetail);
+    }), sTopLevelContentID = _Helper.getContentID(oError.error);
+    return aRequests.map(function (oRequest, i) {
+      var oClone = new Error(oError.message);
+      function isRelevant(oMessage, sContentID) {
+        if (i === 0 && !sContentID) {
+          if (oMessage.target) {
+            oMessage.message = oMessage.target + ": " + oMessage.message;
+          }
+          delete oMessage.target;
+          return true;
+        }
+        return sContentID === oRequest.$ContentID;
+      }
+      oClone.error = _Helper.clone(oError.error);
+      oClone.requestUrl = sServiceUrl + oRequest.url;
+      oClone.resourcePath = oRequest.$resourcePath;
+      oClone.status = oError.status;
+      oClone.statusText = oError.statusText;
+      if (!isRelevant(oClone.error, sTopLevelContentID)) {
+        oClone.error.$ignoreTopLevel = true;
+      }
+      if (oError.strictHandlingFailed) {
+        oClone.strictHandlingFailed = true;
+      }
+      if (oClone.error.details) {
+        oClone.error.details = oClone.error.details.filter(function (oDetail, j) {
+          return isRelevant(oDetail, aDetailContentIDs[j]);
+        });
+      }
+      return oClone;
+    });
+  },
+  deepEqual: fnEqual,
+  deletePrivateAnnotation: function (oObject, sAnnotation) {
+    var oPrivateNamespace = oObject["@$ui5._"];
+    if (oPrivateNamespace) {
+      delete oPrivateNamespace[sAnnotation];
+    }
+  },
+  deleteProperty: function (oObject, sPath) {
+    var aSegments;
+    if (sPath.includes("/")) {
+      aSegments = sPath.split("/");
+      sPath = aSegments.pop();
+      oObject = _Helper.drillDown(oObject, aSegments);
+      if (!oObject) {
+        return;
+      }
+    }
+    delete oObject[sPath];
+  },
+  deleteUpdating: function (sPropertyPath, oEntity) {
+    var oData = oEntity;
+    sPropertyPath.split("/").some(function (sSegment) {
+      var vValue = oData[sSegment];
+      if (vValue === null || Array.isArray(vValue)) {
+        return true;
+      }
+      if (typeof vValue === "object") {
+        oData = vValue;
+        return false;
+      }
+      delete oData[sSegment + "@$ui5.updating"];
+    });
+  },
+  drillDown: function (oObject, vSegments) {
+    if (typeof vSegments === "string") {
+      vSegments = vSegments.split("/");
+    }
+    return vSegments.reduce(function (oCurrent, sSegment) {
+      return oCurrent && (sSegment in oCurrent) ? oCurrent[sSegment] : undefined;
+    }, oObject);
+  },
+  encode: function (sPart, bEncodeEquals) {
+    var sEncoded = encodeURI(sPart).replace(rAmpersand, "%26").replace(rHash, "%23").replace(rPlus, "%2B");
+    if (bEncodeEquals) {
+      sEncoded = sEncoded.replace(rEquals, "%3D");
+    }
+    return sEncoded;
+  },
+  encodePair: function (sKey, sValue) {
+    return _Helper.encode(sKey, true) + "=" + _Helper.encode(sValue, false);
+  },
+  extractMessages: function (oError) {
+    var aMessages = [];
+    function addMessage(oMessage, iNumericSeverity, bTechnical) {
+      var oRawMessage = {
+        additionalTargets: _Helper.getAdditionalTargets(oMessage),
+        code: oMessage.code,
+        message: oMessage.message,
+        numericSeverity: iNumericSeverity,
+        technical: bTechnical || oMessage.technical,
+        "@$ui5.error": oError,
+        "@$ui5.originalMessage": oMessage
+      };
+      Object.keys(oMessage).forEach(function (sProperty) {
+        if (sProperty[0] === "@") {
+          if (sProperty.endsWith(".numericSeverity")) {
+            oRawMessage.numericSeverity = oMessage[sProperty];
+          } else if (sProperty.endsWith(".longtextUrl") && oError.requestUrl && oMessage[sProperty]) {
+            oRawMessage.longtextUrl = _Helper.makeAbsolute(oMessage[sProperty], oError.requestUrl);
+          }
+        }
+      });
+      if (typeof oMessage.target === "string") {
+        if (oMessage.target[0] === "$" || !oError.resourcePath) {
+          oRawMessage.message = oMessage.target + ": " + oMessage.message;
+        } else {
+          oRawMessage.target = oMessage.target;
+        }
+      }
+      oRawMessage.transition = true;
+      aMessages.push(oRawMessage);
+    }
+    if (oError.error) {
+      if (!oError.error.$ignoreTopLevel) {
+        addMessage(oError.error, 4, true);
+      }
+      if (oError.error.details) {
+        oError.error.details.forEach(function (oMessage) {
+          addMessage(oMessage);
+        });
+      }
+    } else {
+      addMessage(oError, 4, true);
+    }
+    return aMessages;
+  },
+  extractMergeableQueryOptions: function (mQueryOptions) {
+    var mExtractedQueryOptions = {};
+    if (("$expand" in mQueryOptions)) {
+      mExtractedQueryOptions.$expand = mQueryOptions.$expand;
+      mQueryOptions.$expand = "~";
+    }
+    if (("$select" in mQueryOptions)) {
+      mExtractedQueryOptions.$select = mQueryOptions.$select;
+      mQueryOptions.$select = "~";
+    }
+    return mExtractedQueryOptions;
+  },
+  fetchPropertyAndType: function (fnFetchMetadata, sMetaPath) {
+    return fnFetchMetadata(sMetaPath).then(function (oProperty) {
+      if (oProperty && oProperty.$kind === "NavigationProperty") {
+        return fnFetchMetadata(sMetaPath + "/").then(function () {
+          return oProperty;
+        });
+      }
+      return oProperty;
+    });
+  },
+  filterPaths: function (aMetaPaths, aPathsToFilter) {
+    return aPathsToFilter.filter(function (sPathToFilter) {
+      var sMetaPathToFilter = _Helper.getMetaPath(sPathToFilter);
+      return aMetaPaths.every(function (sMetaPath) {
+        return !_Helper.hasPathPrefix(sMetaPathToFilter, sMetaPath);
+      });
+    });
+  },
+  fireChange: function (mChangeListeners, sPropertyPath, vValue, bForceUpdate) {
+    var aListeners = mChangeListeners[sPropertyPath], i;
+    if (aListeners) {
+      for (i = 0; i < aListeners.length; i += 1) {
+        aListeners[i].onChange(vValue, bForceUpdate);
+      }
+    }
+  },
+  fireChanges: function (mChangeListeners, sPath, oValue, bRemoved) {
+    Object.keys(oValue).forEach(function (sProperty) {
+      var sPropertyPath = _Helper.buildPath(sPath, sProperty), vValue = oValue[sProperty];
+      if (vValue && typeof vValue === "object") {
+        _Helper.fireChanges(mChangeListeners, sPropertyPath, vValue, bRemoved);
+      } else {
+        _Helper.fireChange(mChangeListeners, sPropertyPath, bRemoved ? undefined : vValue);
+      }
+    });
+    _Helper.fireChange(mChangeListeners, sPath, bRemoved ? undefined : oValue);
+  },
+  formatLiteral: function (vValue, sType) {
+    if (vValue === undefined) {
+      throw new Error("Illegal value: undefined");
+    }
+    if (vValue === null) {
+      return "null";
+    }
+    switch (sType) {
+      case "Edm.Binary":
+        return "binary'" + vValue + "'";
+      case "Edm.Boolean":
+      case "Edm.Byte":
+      case "Edm.Double":
+      case "Edm.Int16":
+      case "Edm.Int32":
+      case "Edm.SByte":
+      case "Edm.Single":
+        return String(vValue);
+      case "Edm.Date":
+      case "Edm.DateTimeOffset":
+      case "Edm.Decimal":
+      case "Edm.Guid":
+      case "Edm.Int64":
+      case "Edm.TimeOfDay":
+        return vValue;
+      case "Edm.Duration":
+        return "duration'" + vValue + "'";
+      case "Edm.String":
+        return "'" + String(vValue).replace(rSingleQuote, "''") + "'";
+      default:
+        throw new Error("Unsupported type: " + sType);
+    }
+  },
+  getAdditionalTargets: function (oMessage) {
+    return _Helper.getAnnotation(oMessage, ".additionalTargets");
+  },
+  getAdjustedTarget: function (sTarget, oOperationMetadata, sParameterContextPath, sContextPath) {
+    var bIsParameterName, sParameterName, aSegments;
+    aSegments = sTarget.split("/");
+    sParameterName = aSegments.shift();
+    if (sParameterName === "$Parameter") {
+      sTarget = aSegments.join("/");
+      sParameterName = aSegments.shift();
+    }
+    if (oOperationMetadata.$IsBound && sParameterName === oOperationMetadata.$Parameter[0].$Name) {
+      sTarget = _Helper.buildPath(sContextPath, aSegments.join("/"));
+      return sTarget;
+    }
+    bIsParameterName = oOperationMetadata.$Parameter.some(function (oParameter) {
+      return sParameterName === oParameter.$Name;
+    });
+    if (bIsParameterName) {
+      sTarget = sParameterContextPath + "/" + sTarget;
+      return sTarget;
+    }
+  },
+  getAnnotation: function (oMessage, sName) {
+    var sAnnotationKey = _Helper.getAnnotationKey(oMessage, sName);
+    return sAnnotationKey && oMessage[sAnnotationKey];
+  },
+  getAnnotationKey: function (oObject, sName, sProperty) {
+    var sAnnotationKey, bDuplicate, sPrefix = (sProperty || "") + "@";
+    Object.keys(oObject).forEach(function (sKey) {
+      if (sKey.startsWith(sPrefix) && sKey.endsWith(sName)) {
+        if (sAnnotationKey) {
+          Log.warning("Cannot distinguish " + sAnnotationKey + " from " + sKey, undefined, sClassName$2);
+          bDuplicate = true;
+        }
+        sAnnotationKey = sKey;
+      }
+    });
+    return bDuplicate ? undefined : sAnnotationKey;
+  },
+  getContentID: function (oMessage) {
+    return _Helper.getAnnotation(oMessage, ".ContentID");
+  },
+  getKeyFilter: function (oInstance, sMetaPath, mTypeForMetaPath, aKeyProperties) {
+    var aFilters = [], sKey, mKey2Value = _Helper.getKeyProperties(oInstance, sMetaPath, mTypeForMetaPath, aKeyProperties);
+    if (!mKey2Value) {
+      return undefined;
+    }
+    for (sKey in mKey2Value) {
+      aFilters.push(sKey + " eq " + mKey2Value[sKey]);
+    }
+    return aFilters.join(" and ");
+  },
+  getKeyPredicate: function (oInstance, sMetaPath, mTypeForMetaPath, aKeyProperties, bKeepSingleProperty) {
+    var mKey2Value = _Helper.getKeyProperties(oInstance, sMetaPath, mTypeForMetaPath, aKeyProperties, true);
+    if (!mKey2Value) {
+      return undefined;
+    }
+    aKeyProperties = Object.keys(mKey2Value).map(function (sAlias, _iIndex, aKeys) {
+      var vValue = encodeURIComponent(mKey2Value[sAlias]);
+      return bKeepSingleProperty || aKeys.length > 1 ? encodeURIComponent(sAlias) + "=" + vValue : vValue;
+    });
+    return "(" + aKeyProperties.join(",") + ")";
+  },
+  getKeyProperties: function (oInstance, sMetaPath, mTypeForMetaPath, aKeyProperties, bReturnAlias) {
+    var bFailed, mKey2Value = {};
+    aKeyProperties = aKeyProperties || mTypeForMetaPath[sMetaPath].$Key;
+    bFailed = aKeyProperties.some(function (vKey) {
+      var sKey, sKeyPath, oObject, sPropertyName, aSegments, oType, vValue;
+      if (typeof vKey === "string") {
+        sKey = sKeyPath = vKey;
+      } else {
+        sKey = Object.keys(vKey)[0];
+        sKeyPath = vKey[sKey];
+        if (!bReturnAlias) {
+          sKey = sKeyPath;
+        }
+      }
+      aSegments = sKeyPath.split("/");
+      sPropertyName = aSegments.pop();
+      oObject = _Helper.drillDown(oInstance, aSegments);
+      vValue = oObject[sPropertyName];
+      if (vValue === undefined || (sPropertyName + "@odata.type" in oObject)) {
+        return true;
+      }
+      oType = mTypeForMetaPath[_Helper.buildPath(sMetaPath, aSegments.join("/"))];
+      vValue = _Helper.formatLiteral(vValue, oType[sPropertyName].$Type);
+      mKey2Value[sKey] = vValue;
+    });
+    return bFailed ? undefined : mKey2Value;
+  },
+  getMetaPath: function (sPath) {
+    if (sPath[0] === "/") {
+      return sPath.replace(rNotMetaContext, "");
+    }
+    if (sPath[0] !== "(") {
+      sPath = "/" + sPath;
+    }
+    return sPath.replace(rNotMetaContext, "").slice(1);
+  },
+  getMissingPropertyPaths: function (vEntityOrCollection, mQueryOptions) {
+    return (mQueryOptions.$select || []).concat(Object.keys(mQueryOptions.$expand || ({}))).filter(function (sPath) {
+      return _Helper.isMissingProperty(vEntityOrCollection, sPath);
+    });
+  },
+  getPredicates: function (aContexts) {
+    var bMissingPredicate, aPredicates = aContexts.map(getPredicate);
+    function getPredicate(oContext) {
+      var sPredicate = _Helper.getPrivateAnnotation(oContext.getValue(), "predicate");
+      if (!sPredicate) {
+        bMissingPredicate = true;
+      }
+      return sPredicate;
+    }
+    return bMissingPredicate ? null : aPredicates;
+  },
+  getPredicateIndex: function (sPath) {
+    var iPredicateIndex = sPath ? sPath.indexOf("(", sPath.lastIndexOf("/")) : -1;
+    if (iPredicateIndex < 0 || !sPath.endsWith(")")) {
+      throw new Error("Not a list context path to an entity: " + sPath);
+    }
+    return iPredicateIndex;
+  },
+  getPrivateAnnotation: function (oObject, sAnnotation, vDefault) {
+    const vResult = oObject["@$ui5._"]?.[sAnnotation];
+    return vResult === undefined ? vDefault : vResult;
+  },
+  getQueryOptionsForPath: function (mQueryOptions, sPath) {
+    sPath = _Helper.getMetaPath(sPath);
+    if (sPath) {
+      sPath.split("/").some(function (sSegment) {
+        mQueryOptions = mQueryOptions && mQueryOptions.$expand && mQueryOptions.$expand[sSegment];
+        if (!mQueryOptions || mQueryOptions === true) {
+          mQueryOptions = {};
+          return true;
+        }
+      });
+    }
+    return mQueryOptions || ({});
+  },
+  getRelativePath: function (sPath, sBasePath) {
+    if (sBasePath.length) {
+      if (!sPath.startsWith(sBasePath)) {
+        return undefined;
+      }
+      sPath = sPath.slice(sBasePath.length);
+      if (sPath) {
+        if (sPath[0] === "/") {
+          return sPath.slice(1);
+        }
+        if (sPath[0] !== "(") {
+          return undefined;
+        }
+      }
+    }
+    return sPath;
+  },
+  hasPathPrefix: function (sPath, sBasePath) {
+    return _Helper.getRelativePath(sPath, sBasePath) !== undefined;
+  },
+  hasPrivateAnnotation: function (oObject, sAnnotation) {
+    var oPrivateNamespace = oObject["@$ui5._"];
+    return oPrivateNamespace ? (sAnnotation in oPrivateNamespace) : false;
+  },
+  informAll: function (mChangeListeners, sPath, vOld, vNew, bAllowUndefined) {
+    if (vNew === vOld) {
+      return;
+    }
+    if (vNew && typeof vNew === "object") {
+      Object.keys(vNew).forEach(function (sProperty) {
+        _Helper.informAll(mChangeListeners, _Helper.buildPath(sPath, sProperty), vOld && vOld[sProperty], vNew[sProperty], bAllowUndefined);
+      });
+    } else {
+      _Helper.fireChange(mChangeListeners, sPath, !bAllowUndefined && vNew === undefined ? null : vNew);
+      vNew = {};
+    }
+    if (vOld && typeof vOld === "object") {
+      Object.keys(vOld).forEach(function (sProperty) {
+        if (!Object.hasOwn(vNew, sProperty)) {
+          _Helper.informAll(mChangeListeners, _Helper.buildPath(sPath, sProperty), vOld[sProperty], undefined, bAllowUndefined);
+        }
+      });
+    }
+  },
+  inheritPathValue: function (aSegments, oSource, oTarget, bTolerateNull) {
+    aSegments.forEach(function (sSegment, i) {
+      var bMissing = !((sSegment in oTarget)) || bTolerateNull && oTarget[sSegment] === null;
+      if (i + 1 < aSegments.length) {
+        if (bMissing) {
+          oTarget[sSegment] = {};
+        }
+        oSource = oSource[sSegment];
+        oTarget = oTarget[sSegment];
+      } else if (bMissing) {
+        oTarget[sSegment] = oSource[sSegment];
+      }
+    });
+  },
+  intersectQueryOptions: function (mCacheQueryOptions, aPaths, fnFetchMetadata, sRootMetaPath, sPrefix, bWithMessages) {
+    var aExpands = [], mExpands = {}, sMessagesPath = bWithMessages && fnFetchMetadata(sRootMetaPath + "/@com.sap.vocabularies.Common.v1.Messages/$Path").getResult(), mResult, oRootMetaData, aSelects, mSelects = {};
+    function filterStructural(bSkipFirstSegment, sMetaPath) {
+      var aSegments = sMetaPath.split("/");
+      return aSegments.every(function (sSegment, i) {
+        return i === 0 && bSkipFirstSegment || sSegment === "$count" || fnFetchMetadata(sRootMetaPath + "/" + aSegments.slice(0, i + 1).join("/")).getResult().$kind === "Property";
+      });
+    }
+    if (aPaths.indexOf("") >= 0) {
+      throw new Error("Unsupported empty navigation property path");
+    }
+    if (aPaths.indexOf("*") >= 0) {
+      aSelects = (mCacheQueryOptions && mCacheQueryOptions.$select || []).slice();
+      if (sMessagesPath && !aSelects.includes(sMessagesPath)) {
+        aSelects.push(sMessagesPath);
+      }
+    } else if (mCacheQueryOptions && mCacheQueryOptions.$select && mCacheQueryOptions.$select.indexOf("*") < 0) {
+      _Helper.addChildrenWithAncestor(aPaths, mCacheQueryOptions.$select, mSelects);
+      _Helper.addChildrenWithAncestor(mCacheQueryOptions.$select, aPaths, mSelects);
+      if (sMessagesPath && aPaths.includes(sMessagesPath)) {
+        mSelects[sMessagesPath] = true;
+      }
+      aSelects = Object.keys(mSelects).filter(filterStructural.bind(null, true));
+    } else {
+      aSelects = aPaths.filter(filterStructural.bind(null, false));
+    }
+    if (mCacheQueryOptions && mCacheQueryOptions.$expand) {
+      aExpands = Object.keys(mCacheQueryOptions.$expand);
+      aExpands.forEach(function (sNavigationPropertyPath) {
+        var mChildQueryOptions, sMetaPath = sRootMetaPath + "/" + sNavigationPropertyPath, sPrefixedNavigationPropertyPath = _Helper.buildPath(sPrefix, sNavigationPropertyPath), mSet = {}, aStrippedPaths;
+        _Helper.addChildrenWithAncestor([sNavigationPropertyPath], aPaths, mSet);
+        if (!fnIsEmptyObject(mSet)) {
+          mExpands[sNavigationPropertyPath] = mCacheQueryOptions.$expand[sNavigationPropertyPath];
+          return;
+        }
+        aStrippedPaths = _Helper.stripPathPrefix(sNavigationPropertyPath, aPaths);
+        if (aStrippedPaths.length) {
+          if (fnFetchMetadata(sMetaPath).getResult().$isCollection) {
+            throw new Error("Unsupported collection-valued navigation property " + sMetaPath);
+          }
+          mChildQueryOptions = _Helper.intersectQueryOptions(mCacheQueryOptions.$expand[sNavigationPropertyPath] || ({}), aStrippedPaths, fnFetchMetadata, sMetaPath, sPrefixedNavigationPropertyPath);
+          if (mChildQueryOptions) {
+            mExpands[sNavigationPropertyPath] = mChildQueryOptions;
+          }
+        }
+      });
+    }
+    if (!aSelects.length && fnIsEmptyObject(mExpands)) {
+      return null;
+    }
+    mResult = Object.assign({}, mCacheQueryOptions, {
+      $select: aSelects
+    });
+    oRootMetaData = fnFetchMetadata(sRootMetaPath).getResult();
+    if (oRootMetaData.$kind === "NavigationProperty" && !oRootMetaData.$isCollection) {
+      _Helper.selectKeyProperties(mResult, fnFetchMetadata(sRootMetaPath + "/").getResult());
+    }
+    if (fnIsEmptyObject(mExpands)) {
+      delete mResult.$expand;
+    } else {
+      mResult.$expand = mExpands;
+    }
+    return mResult;
+  },
+  isDataAggregation: function (mParameters) {
+    return mParameters && mParameters.$$aggregation && !mParameters.$$aggregation.hierarchyQualifier;
+  },
+  isEmptyObject: fnIsEmptyObject,
+  isMissingProperty: function (vEntityOrCollection, sPath) {
+    var aSegments = sPath.split("/");
+    function isMissing(vValue, i) {
+      var vProperty;
+      if (Array.isArray(vValue)) {
+        return vValue.some(function (vItem) {
+          return isMissing(vItem, i);
+        });
+      }
+      vProperty = vValue[aSegments[i]];
+      if (vProperty && typeof vProperty === "object" && i + 1 < aSegments.length) {
+        return isMissing(vProperty, i + 1);
+      }
+      return vProperty === undefined;
+    }
+    if (sPath.includes("*")) {
+      throw new Error("Unsupported property path " + sPath);
+    }
+    return isMissing(vEntityOrCollection, 0);
+  },
+  isSafeInteger: function (iNumber) {
+    if (typeof iNumber !== "number" || !isFinite(iNumber)) {
+      return false;
+    }
+    iNumber = Math.abs(iNumber);
+    return iNumber <= 9007199254740991 && Math.floor(iNumber) === iNumber;
+  },
+  isSelected: function (sPropertyPath, mQueryOptions) {
+    var sPath, sRelativePath;
+    if (!mQueryOptions) {
+      return false;
+    }
+    if (mQueryOptions.$expand) {
+      for (sPath in mQueryOptions.$expand) {
+        sRelativePath = _Helper.getRelativePath(sPropertyPath, sPath);
+        if (sRelativePath) {
+          return _Helper.isSelected(sRelativePath, mQueryOptions.$expand[sPath]);
+        }
+      }
+    }
+    return !mQueryOptions.$select || mQueryOptions.$select.includes("*") || mQueryOptions.$select.some(function (sSelect) {
+      return _Helper.hasPathPrefix(sPropertyPath, sSelect);
+    });
+  },
+  makeAbsolute: function (sUrl, sBase) {
+    return preserveKeyPredicates(new URI(sUrl).absoluteTo(sBase).toString());
+  },
+  makeRelativeUrl: function (sUrl, sBase) {
+    return preserveKeyPredicates(new URI(sUrl).relativeTo(sBase).toString());
+  },
+  makeUpdateData: function (aPropertyPath, vValue, bUpdating) {
+    return aPropertyPath.reduceRight(function (vValue0, sSegment) {
+      var oResult = {};
+      oResult[sSegment] = vValue0;
+      if (bUpdating) {
+        oResult[sSegment + "@$ui5.updating"] = true;
+        bUpdating = false;
+      }
+      return oResult;
+    }, vValue);
+  },
+  merge: fnMerge,
+  mergeQueryOptions: function (mQueryOptions, sOrderby, aFilters) {
+    var mResult;
+    function set(sProperty, sValue) {
+      if (sValue && (!mQueryOptions || mQueryOptions[sProperty] !== sValue)) {
+        if (!mResult) {
+          mResult = mQueryOptions ? _Helper.clone(mQueryOptions) : {};
+        }
+        mResult[sProperty] = sValue;
+      }
+    }
+    set("$orderby", sOrderby);
+    if (aFilters) {
+      set("$filter", aFilters[0]);
+      set("$$filterBeforeAggregate", aFilters[1]);
+    }
+    return mResult || mQueryOptions;
+  },
+  namespace: function (sName) {
+    var iIndex;
+    sName = sName.split("/")[0].split("(")[0];
+    iIndex = sName.lastIndexOf(".");
+    return iIndex < 0 ? "" : sName.slice(0, iIndex);
+  },
+  parseLiteral: function (sLiteral, sType, sPath) {
+    function checkNaN(nValue) {
+      if (!isFinite(nValue)) {
+        throw new Error(sPath + ": Not a valid " + sType + " literal: " + sLiteral);
+      }
+      return nValue;
+    }
+    if (sLiteral === "null") {
+      return null;
+    }
+    switch (sType) {
+      case "Edm.Boolean":
+        return sLiteral === "true";
+      case "Edm.Byte":
+      case "Edm.Int16":
+      case "Edm.Int32":
+      case "Edm.SByte":
+        return checkNaN(parseInt(sLiteral));
+      case "Edm.Date":
+      case "Edm.DateTimeOffset":
+      case "Edm.Decimal":
+      case "Edm.Guid":
+      case "Edm.Int64":
+      case "Edm.TimeOfDay":
+        return sLiteral;
+      case "Edm.Double":
+      case "Edm.Single":
+        return sLiteral === "INF" || sLiteral === "-INF" || sLiteral === "NaN" ? sLiteral : checkNaN(parseFloat(sLiteral));
+      case "Edm.String":
+        return sLiteral.slice(1, -1).replace(rSingleQuoteTwice, "'");
+      default:
+        throw new Error(sPath + ": Unsupported type: " + sType);
+    }
+  },
+  publicClone: function (vValue, bRemoveClientAnnotations, bAsString) {
+    return _Helper.clone(vValue, function (sKey, vValue) {
+      if (bRemoveClientAnnotations ? !sKey.startsWith("@$ui5.") : sKey !== "@$ui5._") {
+        return vValue;
+      }
+    }, bAsString);
+  },
+  removeByPath: function (mMap, sPath, oItem) {
+    var aItems = mMap[sPath], iIndex;
+    if (aItems) {
+      iIndex = aItems.indexOf(oItem);
+      if (iIndex >= 0) {
+        if (aItems.length === 1) {
+          delete mMap[sPath];
+        } else {
+          aItems.splice(iIndex, 1);
+        }
+      }
+    }
+  },
+  resetInactiveEntity: function (mChangeListeners, sPath, oEntity) {
+    var oInitialData = _Helper.getPrivateAnnotation(oEntity, "initialData"), oPostBody = _Helper.getPrivateAnnotation(oEntity, "postBody"), oOldPostBody = Object.assign({}, oPostBody);
+    Object.keys(oPostBody).forEach(function (sKey) {
+      if ((sKey in oInitialData)) {
+        oEntity[sKey] = oPostBody[sKey] = _Helper.clone(oInitialData[sKey]);
+      } else {
+        delete oPostBody[sKey];
+        delete oEntity[sKey];
+      }
+    });
+    _Helper.informAll(mChangeListeners, sPath, oOldPostBody, oPostBody, true);
+    _Helper.updateAll(mChangeListeners, sPath, oEntity, {
+      "@$ui5.context.isInactive": true
+    });
+    _Helper.getPrivateAnnotation(oEntity, "context").setInactive();
+  },
+  resolveIfMatchHeader: function (mHeaders, bIgnoreETag) {
+    var vIfMatchValue = mHeaders && mHeaders["If-Match"];
+    if (vIfMatchValue && typeof vIfMatchValue === "object") {
+      vIfMatchValue = vIfMatchValue["@odata.etag"];
+      mHeaders = Object.assign({}, mHeaders);
+      if (vIfMatchValue === undefined) {
+        delete mHeaders["If-Match"];
+      } else {
+        mHeaders["If-Match"] = bIgnoreETag ? "*" : vIfMatchValue;
+      }
+    }
+    return mHeaders;
+  },
+  restoreUpdatingProperties: function (oOld, oNew) {
+    var oTempNew = oNew || ({});
+    Object.keys(oOld || ({})).forEach(function (sProperty) {
+      if (sProperty.startsWith("@")) {
+        return;
+      }
+      if (Array.isArray(oOld[sProperty])) {
+        return;
+      }
+      if (typeof oOld[sProperty] === "object") {
+        oTempNew[sProperty] = _Helper.restoreUpdatingProperties(oOld[sProperty], oTempNew[sProperty]);
+      }
+      if (oOld[sProperty + "@$ui5.updating"]) {
+        oTempNew[sProperty] = oOld[sProperty];
+        oTempNew[sProperty + "@$ui5.updating"] = oOld[sProperty + "@$ui5.updating"];
+        oNew = oTempNew;
+      }
+    });
+    return oNew;
+  },
+  selectKeyProperties: function (mQueryOptions, oType) {
+    if (oType && oType.$Key) {
+      _Helper.addToSelect(mQueryOptions, oType.$Key.map(function (vKey) {
+        if (typeof vKey === "object") {
+          return vKey[Object.keys(vKey)[0]];
+        }
+        return vKey;
+      }));
+    }
+  },
+  setAnnotation: function (oObject, sAnnotation, vValue) {
+    if (vValue !== undefined) {
+      oObject[sAnnotation] = vValue;
+    } else {
+      delete oObject[sAnnotation];
+    }
+  },
+  setCount: function (mChangeListeners, sPath, aCollection, vCount) {
+    if (typeof vCount === "string") {
+      vCount = parseInt(vCount);
+    }
+    _Helper.updateExisting(mChangeListeners, sPath, aCollection, {
+      $count: vCount
+    });
+  },
+  setLanguage: function (sUrl, sLanguage) {
+    if (sLanguage && !sUrl.includes("?sap-language=") && !sUrl.includes("&sap-language=")) {
+      sUrl += (sUrl.includes("?") ? "&" : "?") + "sap-language=" + _Helper.encode(sLanguage);
+    }
+    return sUrl;
+  },
+  setPrivateAnnotation: function (oObject, sAnnotation, vValue) {
+    var oPrivateNamespace = oObject["@$ui5._"];
+    if (!oPrivateNamespace) {
+      oPrivateNamespace = oObject["@$ui5._"] = {};
+    }
+    oPrivateNamespace[sAnnotation] = vValue;
+  },
+  stripPathPrefix: function (sPrefix, aPaths) {
+    var sPathPrefix = sPrefix + "/";
+    if (sPrefix === "") {
+      return aPaths;
+    }
+    return aPaths.filter(function (sPath) {
+      return sPath === sPrefix || sPath.startsWith(sPathPrefix);
+    }).map(function (sPath) {
+      return sPath.slice(sPathPrefix.length);
+    });
+  },
+  toArray: function (vElement) {
+    if (vElement === undefined || vElement === null) {
+      return [];
+    }
+    if (Array.isArray(vElement)) {
+      return vElement.slice();
+    }
+    return [vElement];
+  },
+  uid: fnUid,
+  updateAll: function (mChangeListeners, sPath, oTarget, oSource) {
+    Object.keys(oSource).forEach(function (sProperty) {
+      var sPropertyPath = _Helper.buildPath(sPath, sProperty), vSourceProperty = oSource[sProperty], vTargetProperty = oTarget[sProperty];
+      if (sProperty === "@$ui5._") {
+        _Helper.setPrivateAnnotation(oTarget, "predicate", _Helper.getPrivateAnnotation(oSource, "predicate"));
+      } else if (Array.isArray(vSourceProperty)) {
+        oTarget[sProperty] = vSourceProperty;
+      } else if (vSourceProperty && typeof vSourceProperty === "object") {
+        oTarget[sProperty] = _Helper.updateAll(mChangeListeners, sPropertyPath, vTargetProperty || ({}), vSourceProperty);
+      } else if (vTargetProperty !== vSourceProperty) {
+        oTarget[sProperty] = vSourceProperty;
+        if (vTargetProperty && typeof vTargetProperty === "object") {
+          _Helper.fireChanges(mChangeListeners, sPropertyPath, vTargetProperty, true);
+        } else {
+          _Helper.fireChange(mChangeListeners, sPropertyPath, vSourceProperty);
+        }
+      }
+    });
+    return oTarget;
+  },
+  updateExisting: function (mChangeListeners, sPath, oOldObject, oNewObject) {
+    if (!oNewObject) {
+      return;
+    }
+    Object.keys(oOldObject).forEach(function (sProperty) {
+      var sPropertyPath = _Helper.buildPath(sPath, sProperty), vOldProperty = oOldObject[sProperty], vNewProperty = oNewObject[sProperty];
+      if ((sProperty in oNewObject) || sProperty[0] === "#") {
+        if (Array.isArray(vNewProperty)) {
+          oOldObject[sProperty] = vNewProperty;
+        } else if (vNewProperty && typeof vNewProperty === "object") {
+          if (vOldProperty) {
+            _Helper.updateExisting(mChangeListeners, sPropertyPath, vOldProperty, vNewProperty);
+          } else {
+            oOldObject[sProperty] = vNewProperty;
+            _Helper.fireChanges(mChangeListeners, sPropertyPath, vNewProperty, false);
+          }
+        } else if (vOldProperty !== vNewProperty) {
+          oOldObject[sProperty] = vNewProperty;
+          if (vOldProperty && typeof vOldProperty === "object") {
+            _Helper.fireChanges(mChangeListeners, sPropertyPath, vOldProperty, true);
+          } else {
+            _Helper.fireChange(mChangeListeners, sPropertyPath, vNewProperty);
+          }
+        }
+      }
+    });
+    Object.keys(oNewObject).filter(function (sProperty) {
+      return sProperty[0] === "#";
+    }).filter(function (sAdvertisedAction) {
+      return !((sAdvertisedAction in oOldObject));
+    }).forEach(function (sNewAdvertisedAction) {
+      var vNewProperty = oNewObject[sNewAdvertisedAction], sPropertyPath = _Helper.buildPath(sPath, sNewAdvertisedAction);
+      oOldObject[sNewAdvertisedAction] = vNewProperty;
+      _Helper.fireChanges(mChangeListeners, sPropertyPath, vNewProperty, false);
+    });
+  },
+  updateNestedCreates: function (mChangeListeners, mQueryOptions, sPath, oTargetEntity, oCreatedEntity, mSelectForMetaPath) {
+    let bDeepCreate = false;
+    const mQueryOptionsForEntity = _Helper.getQueryOptionsForPath(mQueryOptions, sPath);
+    Object.keys(mQueryOptionsForEntity.$expand || ({})).forEach(function (sExpandPath) {
+      const oNestedTargetEntity = _Helper.drillDown(oTargetEntity, sExpandPath);
+      if (oNestedTargetEntity && !Array.isArray(oNestedTargetEntity)) {
+        bDeepCreate = true;
+      }
+    });
+    Object.keys(mSelectForMetaPath || ({})).filter(function (sMetaPath) {
+      return !sMetaPath.includes("/");
+    }).forEach(function (sSegment) {
+      const aNestedCreatedEntities = oCreatedEntity[sSegment];
+      if (!aNestedCreatedEntities) {
+        delete oTargetEntity[sSegment];
+        return;
+      }
+      oTargetEntity[sSegment] = aNestedCreatedEntities;
+      aNestedCreatedEntities.$count = undefined;
+      aNestedCreatedEntities.$created = 0;
+      aNestedCreatedEntities.$byPredicate = {};
+      if (mSelectForMetaPath[sSegment]) {
+        aNestedCreatedEntities.$transfer = true;
+      }
+      const sCollectionPath = sPath + "/" + sSegment;
+      _Helper.setCount(mChangeListeners, sCollectionPath, aNestedCreatedEntities, aNestedCreatedEntities.length);
+      const mSelectForChildMetaPath = {};
+      const sPrefix = sSegment + "/";
+      Object.keys(mSelectForMetaPath).forEach(function (sMetaPath) {
+        if (sMetaPath.startsWith(sPrefix)) {
+          mSelectForChildMetaPath[sMetaPath.slice(sPrefix.length)] = mSelectForMetaPath[sMetaPath];
+        }
+      });
+      aNestedCreatedEntities.forEach(function (oCreatedChildEntity) {
+        const sPredicate = _Helper.getPrivateAnnotation(oCreatedChildEntity, "predicate");
+        aNestedCreatedEntities.$byPredicate[sPredicate] = oCreatedChildEntity;
+        _Helper.updateNestedCreates(mChangeListeners, mQueryOptions, sCollectionPath + sPredicate, oCreatedChildEntity, oCreatedChildEntity, mSelectForChildMetaPath);
+      });
+      bDeepCreate = true;
+    });
+    return bDeepCreate;
+  },
+  updateNonExisting: function (oTarget, oSource) {
+    Object.keys(oSource).forEach(function (sKey) {
+      var vSourceValue = oSource[sKey], vTargetValue;
+      if ((sKey in oTarget)) {
+        vTargetValue = oTarget[sKey];
+        if (vSourceValue && vTargetValue && typeof vSourceValue === "object" && !Array.isArray(vSourceValue)) {
+          _Helper.updateNonExisting(vTargetValue, vSourceValue);
+        }
+      } else {
+        oTarget[sKey] = vSourceValue;
+      }
+    });
+  },
+  updateSelected: function (mChangeListeners, sBasePath, oOldValue, oNewValue, aSelect, fnCheckKeyPredicate, bOkIfMissing) {
+    function getSelect(vSelect, sProperty) {
+      var iAt;
+      if (vSelect === true) {
+        return true;
+      }
+      if (vSelect[sProperty]) {
+        return vSelect[sProperty];
+      }
+      iAt = sProperty.indexOf("@");
+      if (iAt === 0 || iAt > 0 && vSelect[sProperty.slice(0, iAt)]) {
+        return true;
+      }
+    }
+    function update(sPath, vSelect, oTarget, oSource) {
+      Object.keys(oTarget).forEach(function (sProperty) {
+        if (!((sProperty in oSource)) && sProperty.includes("@") && !sProperty.startsWith("@$ui5.") && getSelect(vSelect, sProperty) && !sProperty.endsWith("@$ui5.updating")) {
+          delete oTarget[sProperty];
+          _Helper.fireChange(mChangeListeners, _Helper.buildPath(sPath, sProperty), undefined);
+        }
+      });
+      Object.keys(oSource).forEach(function (sProperty) {
+        var sPropertyPath = _Helper.buildPath(sPath, sProperty), vSelected = getSelect(vSelect, sProperty), sSourcePredicate, vSourceProperty = oSource[sProperty], sTargetPredicate, vTargetProperty = oTarget[sProperty];
+        if (!vSelected) {
+          return;
+        }
+        if (sProperty === "@$ui5._") {
+          sSourcePredicate = _Helper.getPrivateAnnotation(oSource, "predicate");
+          if (fnCheckKeyPredicate && fnCheckKeyPredicate(sPath)) {
+            sTargetPredicate = _Helper.getPrivateAnnotation(oTarget, "predicate");
+            if (sSourcePredicate !== sTargetPredicate) {
+              throw new Error("Key predicate of '" + sPath + "' changed from " + sTargetPredicate + " to " + sSourcePredicate);
+            }
+          } else {
+            _Helper.setPrivateAnnotation(oTarget, "predicate", sSourcePredicate);
+          }
+        } else if (Array.isArray(vSourceProperty)) {
+          if (!(vTargetProperty && vTargetProperty.$postBodyCollection)) {
+            oTarget[sProperty] = vSourceProperty;
+          }
+        } else if (vSourceProperty && typeof vSourceProperty === "object" && !sProperty.includes("@")) {
+          oTarget[sProperty] = update(sPropertyPath, vSelected, vTargetProperty || ({}), vSourceProperty);
+        } else if (vTargetProperty !== vSourceProperty && !oTarget[sProperty + "@$ui5.updating"]) {
+          oTarget[sProperty] = vSourceProperty;
+          if (vTargetProperty && typeof vTargetProperty === "object") {
+            _Helper.fireChanges(mChangeListeners, sPropertyPath, vTargetProperty, true);
+          } else if (vSelected === true) {
+            _Helper.fireChange(mChangeListeners, sPropertyPath, vSourceProperty);
+          }
+        }
+      });
+      if (bOkIfMissing) {
+        return oTarget;
+      }
+      Object.keys(vSelect).forEach(function (sProperty) {
+        if (!((sProperty in oTarget)) && sProperty !== "*") {
+          oTarget[sProperty + "@$ui5.noData"] = true;
+          _Helper.fireChange(mChangeListeners, _Helper.buildPath(sPath, sProperty), undefined, true);
+        }
+      });
+      return oTarget;
+    }
+    update(sBasePath, _Helper.buildSelect(aSelect), oOldValue, oNewValue);
+  },
+  updateTransientPaths: function (mMap, sTransientPredicate, sPredicate) {
+    var sPath;
+    for (sPath in mMap) {
+      if (sPath.includes(sTransientPredicate)) {
+        mMap[sPath.replace(sTransientPredicate, sPredicate)] = mMap[sPath];
+        delete mMap[sPath];
+      }
+    }
+  },
+  copySelected: function (oSource, oTarget) {
+    if (oSource["@$ui5.context.isSelected"] === true) {
+      oTarget["@$ui5.context.isSelected"] = true;
+    }
+  },
+  wrapChildQueryOptions: function (sBaseMetaPath, sChildMetaPath, mChildQueryOptions, fnFetchMetadata) {
+    var sExpandSelectPath = "", aMetaPathSegments = sChildMetaPath.split("/"), oProperty, sPropertyMetaPath = sBaseMetaPath, mQueryOptions = {}, mQueryOptionsForPathPrefix = mQueryOptions, i;
+    if (sChildMetaPath === "") {
+      return mChildQueryOptions;
+    }
+    for (i = 0; i < aMetaPathSegments.length; i += 1) {
+      sPropertyMetaPath = _Helper.buildPath(sPropertyMetaPath, aMetaPathSegments[i]);
+      sExpandSelectPath = _Helper.buildPath(sExpandSelectPath, aMetaPathSegments[i]);
+      if (aMetaPathSegments[i].endsWith("*")) {
+        oProperty = null;
+        continue;
+      }
+      oProperty = fnFetchMetadata(sPropertyMetaPath).getResult();
+      if (oProperty.$kind === "NavigationProperty") {
+        mQueryOptionsForPathPrefix.$expand = {};
+        if (i === aMetaPathSegments.length - 1) {
+          mChildQueryOptions = Object.assign({}, mChildQueryOptions);
+          mChildQueryOptions.$select = mChildQueryOptions.$select && mChildQueryOptions.$select.slice();
+        }
+        mQueryOptionsForPathPrefix = mQueryOptionsForPathPrefix.$expand[sExpandSelectPath] = i === aMetaPathSegments.length - 1 ? mChildQueryOptions : {};
+        _Helper.selectKeyProperties(mQueryOptionsForPathPrefix, fnFetchMetadata(sPropertyMetaPath + "/").getResult());
+        sExpandSelectPath = "";
+      } else if (oProperty.$kind !== "Property") {
+        return undefined;
+      }
+    }
+    if (!oProperty || oProperty.$kind === "Property") {
+      if (!fnIsEmptyObject(mChildQueryOptions)) {
+        Log.error("Failed to enhance query options for auto-$expand/$select as the" + " child binding has query options, but its path '" + sChildMetaPath + "' points to a structural property", JSON.stringify(mChildQueryOptions), sClassName$2);
+        return undefined;
+      }
+      _Helper.addToSelect(mQueryOptionsForPathPrefix, [sExpandSelectPath]);
+    }
+    if (("$apply" in mChildQueryOptions)) {
+      Log.debug("Cannot wrap $apply into $expand: " + sChildMetaPath, JSON.stringify(mChildQueryOptions), sClassName$2);
+      return undefined;
+    }
+    return mQueryOptions;
+  }
+};
+var _Helper$1 = _Helper;
+
+var sClassName$1 = "sap.ui.model.odata.v4.lib._MetadataConverter";
+function _MetadataConverter() {
+  this.aliases = {};
+  this.oAnnotatable = null;
+  this.entityContainer = null;
+  this.entitySet = null;
+  this.namespace = null;
+  this.oOperation = null;
+  this.reference = null;
+  this.schema = null;
+  this.type = null;
+  this.result = null;
+  this.url = null;
+  this.xmlns = null;
+}
+_MetadataConverter.prototype.rCollection = /^Collection\((.*)\)$/;
+_MetadataConverter.prototype.sEdmNamespace = "http://docs.oasis-open.org/odata/ns/edm";
+_MetadataConverter.prototype.sEdmxNamespace = "http://docs.oasis-open.org/odata/ns/edmx";
+_MetadataConverter.prototype.addToResult = function (sQualifiedName, vValue) {
+  if ((sQualifiedName in this.result)) {
+    Log.warning("Duplicate qualified name " + sQualifiedName, undefined, sClassName$1);
+  }
+  this.result[sQualifiedName] = vValue;
+};
+_MetadataConverter.prototype.annotatable = function (vTarget, sPrefix, sQualifier) {
+  var oAnnotatable, oAnnotations, sPath;
+  if (typeof vTarget === "string") {
+    oAnnotatable = this.oAnnotatable;
+    if (oAnnotatable) {
+      vTarget = _Helper$1.buildPath(oAnnotatable.path, vTarget);
+    }
+    sPath = vTarget;
+    oAnnotations = this.schema.$Annotations;
+    if (oAnnotations && oAnnotations[vTarget]) {
+      vTarget = oAnnotations[vTarget];
+    }
+  }
+  this.oAnnotatable = {
+    parent: this.oAnnotatable,
+    path: sPath,
+    prefix: sPrefix || "",
+    qualifiedName: undefined,
+    qualifier: sQualifier,
+    target: vTarget
+  };
+};
+_MetadataConverter.prototype.convertXMLMetadata = function (oDocument, sUrl, bIgnoreAnnotations) {
+  var oElement;
+  oElement = oDocument.documentElement;
+  if (oElement.localName !== "Edmx" || oElement.namespaceURI !== this.sRootNamespace) {
+    throw new Error(sUrl + ": expected <Edmx> in namespace '" + this.sRootNamespace + "'");
+  }
+  this.result = {};
+  this.url = sUrl;
+  this.bIgnoreAnnotations = bIgnoreAnnotations;
+  this.traverse(oElement, this.oAliasConfig);
+  this.traverse(oElement, this.oFullConfig, true);
+  this.finalize();
+  return this.result;
+};
+_MetadataConverter.prototype.getAnnotationValue = function (sType, sValue) {
+  var vValue, aValues, i;
+  switch (sType) {
+    case "AnnotationPath":
+    case "NavigationPropertyPath":
+    case "Path":
+    case "PropertyPath":
+      sValue = this.resolveAliasInPath(sValue);
+    case "Binary":
+    case "Date":
+    case "DateTimeOffset":
+    case "Decimal":
+    case "Duration":
+    case "Guid":
+    case "TimeOfDay":
+    case "UrlRef":
+      vValue = {};
+      vValue["$" + sType] = sValue;
+      return vValue;
+    case "Bool":
+      return sValue === "true";
+    case "EnumMember":
+      aValues = sValue.trim().replace(/ +/g, " ").split(" ");
+      for (i = 0; i < aValues.length; i += 1) {
+        aValues[i] = this.resolveAliasInPath(aValues[i]);
+      }
+      return {
+        $EnumMember: aValues.join(" ")
+      };
+    case "Float":
+      if (sValue === "NaN" || sValue === "INF" || sValue === "-INF") {
+        return {
+          $Float: sValue
+        };
+      }
+      return parseFloat(sValue);
+    case "Int":
+      vValue = parseInt(sValue);
+      return _Helper$1.isSafeInteger(vValue) ? vValue : {
+        $Int: sValue
+      };
+    case "String":
+      return sValue;
+    default:
+      return undefined;
+  }
+};
+_MetadataConverter.prototype.getInlineAnnotationValue = function (oElement) {
+  var oAttribute, oAttributeList = oElement.attributes, vValue, i;
+  for (i = oAttributeList.length - 1; i >= 0; i -= 1) {
+    oAttribute = oAttributeList.item(i);
+    vValue = this.getAnnotationValue(oAttribute.name, oAttribute.value);
+    if (vValue !== undefined) {
+      return vValue;
+    }
+  }
+  return true;
+};
+_MetadataConverter.prototype.getOrCreateArray = function (oParent, sProperty) {
+  var oResult = oParent[sProperty];
+  if (!oResult) {
+    oResult = oParent[sProperty] = [];
+  }
+  return oResult;
+};
+_MetadataConverter.prototype.getOrCreateObject = function (oParent, sProperty) {
+  var oResult = oParent[sProperty];
+  if (!oResult) {
+    oResult = oParent[sProperty] = {};
+  }
+  return oResult;
+};
+_MetadataConverter.prototype.postProcessAnnotation = function (oElement, aResult) {
+  var oAnnotatable = this.oAnnotatable.parent;
+  if (!this.bIgnoreAnnotations) {
+    oAnnotatable.target[oAnnotatable.qualifiedName] = aResult.length ? aResult[0] : this.getInlineAnnotationValue(oElement);
+  }
+};
+_MetadataConverter.prototype.postProcessApply = function (oElement, aResult) {
+  var oResult = this.oAnnotatable.target;
+  oResult.$Apply = aResult;
+  oResult.$Function = this.resolveAlias(oElement.getAttribute("Function"));
+  return oResult;
+};
+_MetadataConverter.prototype.postProcessCastOrIsOf = function (oElement, aResult) {
+  var sName = oElement.localName, oResult = this.oAnnotatable.target;
+  oResult["$" + sName] = aResult[0];
+  this.processTypedCollection(oElement.getAttribute("Type"), oResult);
+  this.processFacetAttributes(oElement, oResult);
+  return oResult;
+};
+_MetadataConverter.prototype.postProcessCollection = function (_oElement, aResult) {
+  return aResult;
+};
+_MetadataConverter.prototype.postProcessLabeledElement = function (oElement, aResult) {
+  var oResult = this.oAnnotatable.target;
+  oResult.$LabeledElement = aResult.length ? aResult[0] : this.getInlineAnnotationValue(oElement);
+  oResult.$Name = oElement.getAttribute("Name");
+  return oResult;
+};
+_MetadataConverter.prototype.postProcessLabeledElementReference = function (oElement, _aRes) {
+  return {
+    $LabeledElementReference: this.resolveAlias(oElement.textContent)
+  };
+};
+_MetadataConverter.prototype.postProcessLeaf = function (oElement, _aResult) {
+  return this.getAnnotationValue(oElement.localName, oElement.textContent);
+};
+_MetadataConverter.prototype.postProcessNot = function (_oElement, aResult) {
+  var oResult = this.oAnnotatable.target;
+  oResult.$Not = aResult[0];
+  return oResult;
+};
+_MetadataConverter.prototype.postProcessNull = function (_oElement, _aResult) {
+  var oAnnotatable = this.oAnnotatable, vResult = null;
+  if (oAnnotatable.qualifiedName) {
+    vResult = oAnnotatable.target;
+    vResult.$Null = null;
+  }
+  return vResult;
+};
+_MetadataConverter.prototype.postProcessOperation = function (oElement, aResult) {
+  var oResult = this.oAnnotatable.target;
+  oResult["$" + oElement.localName] = aResult;
+  return oResult;
+};
+_MetadataConverter.prototype.postProcessPropertyValue = function (oElement, aResult) {
+  return {
+    property: oElement.getAttribute("Property"),
+    value: aResult.length ? aResult[0] : this.getInlineAnnotationValue(oElement)
+  };
+};
+_MetadataConverter.prototype.postProcessRecord = function (oElement, aResult) {
+  var oPropertyValue, oResult = this.oAnnotatable.target, oType = oElement.getAttribute("Type"), i;
+  if (oType) {
+    oResult.$Type = this.resolveAlias(oType);
+  }
+  for (i = 0; i < aResult.length; i += 1) {
+    oPropertyValue = aResult[i];
+    oResult[oPropertyValue.property] = oPropertyValue.value;
+  }
+  return oResult;
+};
+_MetadataConverter.prototype.postProcessUrlRef = function (_oElement, aResult) {
+  return {
+    $UrlRef: aResult[0]
+  };
+};
+_MetadataConverter.prototype.processAlias = function (oElement) {
+  var sAlias = oElement.getAttribute("Alias");
+  if (sAlias) {
+    this.aliases[sAlias] = oElement.getAttribute("Namespace") + ".";
+  }
+};
+_MetadataConverter.prototype.processAnnotatableExpression = function (_oElement) {
+  this.annotatable({});
+};
+_MetadataConverter.prototype.processAnnotation = function (oElement) {
+  var oAnnotatable = this.oAnnotatable, oAnnotations, sQualifiedName = oAnnotatable.prefix + "@" + this.resolveAlias(oElement.getAttribute("Term")), sQualifier = oAnnotatable.qualifier || oElement.getAttribute("Qualifier");
+  if (sQualifier) {
+    sQualifiedName += "#" + sQualifier;
+  }
+  if (typeof oAnnotatable.target === "string") {
+    oAnnotations = this.getOrCreateObject(this.schema, "$Annotations");
+    if (this.bIgnoreAnnotations) {
+      return;
+    }
+    oAnnotatable.target = oAnnotations[oAnnotatable.target] = {};
+  }
+  oAnnotatable.qualifiedName = sQualifiedName;
+  this.annotatable(oAnnotatable.target, sQualifiedName);
+};
+_MetadataConverter.prototype.processAnnotations = function (oElement) {
+  this.annotatable(this.resolveAliasInPath(oElement.getAttribute("Target"), true), undefined, oElement.getAttribute("Qualifier"));
+};
+_MetadataConverter.prototype.processAttributes = function (oElement, oTarget, oConfig) {
+  var sProperty, sValue;
+  for (sProperty in oConfig) {
+    sValue = oConfig[sProperty](oElement.getAttribute(sProperty));
+    if (sValue !== undefined && sValue !== null) {
+      oTarget["$" + sProperty] = sValue;
+    }
+  }
+};
+_MetadataConverter.prototype.processInclude = function (oElement) {
+  var oInclude = this.getOrCreateArray(this.reference, "$Include");
+  oInclude.push(oElement.getAttribute("Namespace") + ".");
+};
+_MetadataConverter.prototype.processIncludeAnnotations = function (oElement) {
+  var oReference = this.reference, oIncludeAnnotation = {
+    $TermNamespace: oElement.getAttribute("TermNamespace") + "."
+  }, aIncludeAnnotations = this.getOrCreateArray(oReference, "$IncludeAnnotations");
+  this.processAttributes(oElement, oIncludeAnnotation, {
+    TargetNamespace: function setValue(sValue) {
+      return sValue ? sValue + "." : sValue;
+    },
+    Qualifier: this.setValue
+  });
+  aIncludeAnnotations.push(oIncludeAnnotation);
+};
+_MetadataConverter.prototype.processPropertyValue = function (oElement) {
+  this.annotatable(this.oAnnotatable.target, oElement.getAttribute("Property"));
+};
+_MetadataConverter.prototype.processReference = function (oElement) {
+  var oReference = this.getOrCreateObject(this.result, "$Reference");
+  this.reference = oReference[oElement.getAttribute("Uri")] = {};
+  this.annotatable(this.reference);
+};
+_MetadataConverter.prototype.resolveAlias = function (sName) {
+  var iDot = sName ? sName.indexOf(".") : -1, sNamespace;
+  if (iDot >= 0 && !sName.includes(".", iDot + 1)) {
+    sNamespace = this.aliases[sName.slice(0, iDot)];
+    if (sNamespace) {
+      return sNamespace + sName.slice(iDot + 1);
+    }
+  }
+  return sName;
+};
+_MetadataConverter.prototype.resolveAliasInParentheses = function (bHandleParentheses, sSegment) {
+  var iParentheses = bHandleParentheses ? sSegment.indexOf("(") : -1;
+  if (iParentheses >= 0) {
+    return this.resolveAlias(sSegment.slice(0, iParentheses)) + "(" + sSegment.slice(iParentheses + 1, -1).split(",").map(this.resolveAliasInParentheses.bind(this, bHandleParentheses)).join(",") + ")";
+  }
+  return this.resolveAlias(sSegment);
+};
+_MetadataConverter.prototype.resolveAliasInPath = function (sPath, bHandleParentheses) {
+  var iAt, sTerm = "";
+  if (!sPath.includes(".")) {
+    return sPath;
+  }
+  iAt = sPath.indexOf("@");
+  if (iAt >= 0) {
+    sTerm = "@" + this.resolveAlias(sPath.slice(iAt + 1));
+    sPath = sPath.slice(0, iAt);
+  }
+  return sPath.split("/").map(this.resolveAliasInParentheses.bind(this, bHandleParentheses)).join("/") + sTerm;
+};
+_MetadataConverter.prototype.setIfFalse = function (sValue) {
+  return sValue === "false" ? false : undefined;
+};
+_MetadataConverter.prototype.setIfTrue = function (sValue) {
+  return sValue === "true" ? true : undefined;
+};
+_MetadataConverter.prototype.setNumber = function (sValue) {
+  return sValue ? parseInt(sValue) : undefined;
+};
+_MetadataConverter.prototype.setValue = function (sValue) {
+  return sValue;
+};
+_MetadataConverter.prototype.traverse = function (oElement, oConfig, bUseProcessElementHook) {
+  var oAnnotatable = this.oAnnotatable, oChildConfig, oChildList = oElement.childNodes, oChildNode, vChildResult, aIncludes, sName, sPreviousNamespace = this.xmlns, vResult, aResult = [], sXmlNamespace = oConfig.__xmlns || this.xmlns, i, j;
+  if (sXmlNamespace && sXmlNamespace !== oElement.namespaceURI) {
+    return undefined;
+  }
+  this.xmlns = sXmlNamespace;
+  if (bUseProcessElementHook) {
+    this.processElement(oElement, oConfig.__processor);
+  } else if (oConfig.__processor) {
+    oConfig.__processor.call(this, oElement);
+  }
+  for (i = 0; i < oChildList.length; i += 1) {
+    oChildNode = oChildList.item(i);
+    if (oChildNode.nodeType === 1) {
+      sName = oChildNode.localName;
+      oChildConfig = oConfig[sName];
+      if (!oChildConfig && oConfig.__include) {
+        aIncludes = oConfig.__include;
+        for (j = 0; j < aIncludes.length; j += 1) {
+          oChildConfig = aIncludes[j][sName];
+          if (oChildConfig) {
+            break;
+          }
+        }
+      }
+      if (oChildConfig) {
+        vChildResult = this.traverse(oChildNode, oChildConfig, bUseProcessElementHook);
+        if (vChildResult !== undefined && oConfig.__postProcessor) {
+          aResult.push(vChildResult);
+        }
+      }
+    }
+  }
+  if (oConfig.__postProcessor) {
+    vResult = oConfig.__postProcessor.call(this, oElement, aResult);
+  }
+  this.oAnnotatable = oAnnotatable;
+  this.xmlns = sPreviousNamespace;
+  return vResult;
+};
+(function ($$) {
+  var aAnnotatableExpressionInclude, oAnnotationExpressionConfig, oAnnotationLeafConfig, aExpressionInclude, oOperatorConfig;
+  oAnnotationLeafConfig = {
+    AnnotationPath: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    Binary: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    Bool: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    Date: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    DateTimeOffset: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    Decimal: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    Duration: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    EnumMember: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    Float: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    Guid: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    Int: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    LabeledElementReference: {
+      __postProcessor: $$.postProcessLabeledElementReference
+    },
+    NavigationPropertyPath: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    Path: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    PropertyPath: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    String: {
+      __postProcessor: $$.postProcessLeaf
+    },
+    TimeOfDay: {
+      __postProcessor: $$.postProcessLeaf
+    }
+  };
+  aExpressionInclude = [oAnnotationLeafConfig];
+  $$.oAnnotationConfig = {
+    Annotation: {
+      __xmlns: $$.sEdmNamespace,
+      __processor: $$.processAnnotation,
+      __postProcessor: $$.postProcessAnnotation,
+      __include: aExpressionInclude
+    }
+  };
+  aAnnotatableExpressionInclude = [oAnnotationLeafConfig, $$.oAnnotationConfig];
+  oOperatorConfig = {
+    __processor: $$.processAnnotatableExpression,
+    __postProcessor: $$.postProcessOperation,
+    __include: aAnnotatableExpressionInclude
+  };
+  oAnnotationExpressionConfig = {
+    And: oOperatorConfig,
+    Apply: {
+      __processor: $$.processAnnotatableExpression,
+      __postProcessor: $$.postProcessApply,
+      __include: aAnnotatableExpressionInclude
+    },
+    Cast: {
+      __processor: $$.processAnnotatableExpression,
+      __postProcessor: $$.postProcessCastOrIsOf,
+      __include: aAnnotatableExpressionInclude
+    },
+    Collection: {
+      __postProcessor: $$.postProcessCollection,
+      __include: aExpressionInclude
+    },
+    Eq: oOperatorConfig,
+    Ge: oOperatorConfig,
+    Gt: oOperatorConfig,
+    If: oOperatorConfig,
+    IsOf: {
+      __processor: $$.processAnnotatableExpression,
+      __postProcessor: $$.postProcessCastOrIsOf,
+      __include: aAnnotatableExpressionInclude
+    },
+    LabeledElement: {
+      __processor: $$.processAnnotatableExpression,
+      __postProcessor: $$.postProcessLabeledElement,
+      __include: aAnnotatableExpressionInclude
+    },
+    Le: oOperatorConfig,
+    Lt: oOperatorConfig,
+    Ne: oOperatorConfig,
+    Null: {
+      __processor: $$.processAnnotatableExpression,
+      __postProcessor: $$.postProcessNull,
+      __include: [$$.oAnnotationConfig]
+    },
+    Not: {
+      __processor: $$.processAnnotatableExpression,
+      __postProcessor: $$.postProcessNot,
+      __include: aAnnotatableExpressionInclude
+    },
+    Or: oOperatorConfig,
+    Record: {
+      __processor: $$.processAnnotatableExpression,
+      __postProcessor: $$.postProcessRecord,
+      __include: [$$.oAnnotationConfig],
+      PropertyValue: {
+        __processor: $$.processPropertyValue,
+        __postProcessor: $$.postProcessPropertyValue,
+        __include: aAnnotatableExpressionInclude
+      }
+    },
+    UrlRef: {
+      __postProcessor: $$.postProcessUrlRef,
+      __include: aExpressionInclude
+    }
+  };
+  $$.oAnnotationsConfig = {
+    Annotations: {
+      __processor: $$.processAnnotations,
+      __include: [$$.oAnnotationConfig]
+    }
+  };
+  aExpressionInclude.push(oAnnotationExpressionConfig);
+  aAnnotatableExpressionInclude.push(oAnnotationExpressionConfig);
+  $$.oAnnotationConfig.Annotation.Annotation = $$.oAnnotationConfig.Annotation;
+  $$.oReferenceInclude = {
+    Reference: {
+      __xmlns: $$.sEdmxNamespace,
+      __processor: $$.processReference,
+      __include: [$$.oAnnotationConfig],
+      Include: {
+        __processor: $$.processInclude
+      },
+      IncludeAnnotations: {
+        __processor: $$.processIncludeAnnotations
+      }
+    }
+  };
+})(_MetadataConverter.prototype);
+
+var sClassName = "sap.ui.model.odata.v4.lib._V2MetadataConverter", rHttpMethods = /^(?:DELETE|GET|MERGE|PATCH|POST|PUT)$/, sEdmxNamespace = "http://schemas.microsoft.com/ado/2007/06/edmx", sMicrosoftNamespace = "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata", sSapNamespace = "http://www.sap.com/Protocols/SAPData", mV2toV4 = {
+  creatable: {
+    property: "Insertable",
+    term: "@Org.OData.Capabilities.V1.InsertRestrictions"
+  },
+  deletable: {
+    property: "Deletable",
+    term: "@Org.OData.Capabilities.V1.DeleteRestrictions"
+  },
+  "deletable-path": {
+    property: "Deletable",
+    term: "@Org.OData.Capabilities.V1.DeleteRestrictions"
+  },
+  "field-control": {
+    term: "@com.sap.vocabularies.Common.v1.FieldControl"
+  },
+  heading: {
+    term: "@com.sap.vocabularies.Common.v1.Heading"
+  },
+  label: {
+    term: "@com.sap.vocabularies.Common.v1.Label"
+  },
+  precision: {
+    term: "@Org.OData.Measures.V1.Scale"
+  },
+  quickinfo: {
+    term: "@com.sap.vocabularies.Common.v1.QuickInfo"
+  },
+  "requires-filter": {
+    property: "RequiresFilter",
+    term: "@Org.OData.Capabilities.V1.FilterRestrictions"
+  },
+  searchable: {
+    property: "Searchable",
+    term: "@Org.OData.Capabilities.V1.SearchRestrictions"
+  },
+  text: {
+    term: "@com.sap.vocabularies.Common.v1.Text"
+  },
+  topable: {
+    term: "@Org.OData.Capabilities.V1.TopSupported"
+  },
+  updatable: {
+    property: "Updatable",
+    term: "@Org.OData.Capabilities.V1.UpdateRestrictions"
+  },
+  "updatable-path": {
+    property: "Updatable",
+    term: "@Org.OData.Capabilities.V1.UpdateRestrictions"
+  }
+}, mV2toV4ComplexSemantics = {
+  bday: {
+    TermName: "Contact"
+  },
+  city: {
+    Path: "adr",
+    TermName: "Contact",
+    V4Attribute: "locality"
+  },
+  country: {
+    Path: "adr",
+    TermName: "Contact"
+  },
+  email: {
+    Path: "address",
+    TermName: "Contact",
+    V4Attribute: "uri",
+    typeMapping: {
+      home: "home",
+      pref: "preferred",
+      work: "work"
+    },
+    v4EnumType: "com.sap.vocabularies.Communication.v1.ContactInformationType",
+    v4PropertyAnnotation: "@com.sap.vocabularies.Communication.v1.IsEmailAddress"
+  },
+  familyname: {
+    Path: "n",
+    TermName: "Contact",
+    V4Attribute: "surname"
+  },
+  givenname: {
+    Path: "n",
+    TermName: "Contact",
+    V4Attribute: "given"
+  },
+  honorific: {
+    Path: "n",
+    TermName: "Contact",
+    V4Attribute: "prefix"
+  },
+  middlename: {
+    Path: "n",
+    TermName: "Contact",
+    V4Attribute: "additional"
+  },
+  name: {
+    TermName: "Contact",
+    V4Attribute: "fn"
+  },
+  nickname: {
+    TermName: "Contact"
+  },
+  note: {
+    TermName: "Contact"
+  },
+  org: {
+    TermName: "Contact"
+  },
+  "org-role": {
+    TermName: "Contact",
+    V4Attribute: "role"
+  },
+  "org-unit": {
+    TermName: "Contact",
+    V4Attribute: "orgunit"
+  },
+  photo: {
+    TermName: "Contact"
+  },
+  pobox: {
+    Path: "adr",
+    TermName: "Contact"
+  },
+  region: {
+    Path: "adr",
+    TermName: "Contact"
+  },
+  street: {
+    Path: "adr",
+    TermName: "Contact"
+  },
+  suffix: {
+    Path: "n",
+    TermName: "Contact"
+  },
+  tel: {
+    Path: "tel",
+    TermName: "Contact",
+    V4Attribute: "uri",
+    typeMapping: {
+      cell: "cell",
+      fax: "fax",
+      home: "home",
+      pref: "preferred",
+      video: "video",
+      voice: "voice",
+      work: "work"
+    },
+    v4EnumType: "com.sap.vocabularies.Communication.v1.PhoneType",
+    v4PropertyAnnotation: "@com.sap.vocabularies.Communication.v1.IsPhoneNumber"
+  },
+  title: {
+    TermName: "Contact"
+  },
+  zip: {
+    Path: "adr",
+    TermName: "Contact",
+    V4Attribute: "code"
+  },
+  class: {
+    TermName: "Event"
+  },
+  dtend: {
+    TermName: "Event"
+  },
+  dtstart: {
+    TermName: "Event"
+  },
+  duration: {
+    TermName: "Event"
+  },
+  fbtype: {
+    TermName: "Event"
+  },
+  location: {
+    TermName: "Event"
+  },
+  status: {
+    TermName: "Event"
+  },
+  transp: {
+    TermName: "Event"
+  },
+  wholeday: {
+    TermName: "Event"
+  },
+  body: {
+    TermName: "Message"
+  },
+  from: {
+    TermName: "Message"
+  },
+  received: {
+    TermName: "Message"
+  },
+  sender: {
+    TermName: "Message"
+  },
+  subject: {
+    TermName: "Message"
+  },
+  completed: {
+    TermName: "Task"
+  },
+  due: {
+    TermName: "Task"
+  },
+  "percent-complete": {
+    TermName: "Task",
+    V4Attribute: "percentcomplete"
+  },
+  priority: {
+    TermName: "Task"
+  }
+}, mV2toV4SimpleSemantics = {
+  fiscalyear: "@com.sap.vocabularies.Common.v1.IsFiscalYear",
+  fiscalyearperiod: "@com.sap.vocabularies.Common.v1.IsFiscalYearPeriod",
+  year: "@com.sap.vocabularies.Common.v1.IsCalendarYear",
+  yearmonth: "@com.sap.vocabularies.Common.v1.IsCalendarYearMonth",
+  yearmonthday: "@com.sap.vocabularies.Common.v1.IsCalendarDate",
+  yearquarter: "@com.sap.vocabularies.Common.v1.IsCalendarYearQuarter",
+  yearweek: "@com.sap.vocabularies.Common.v1.IsCalendarYearWeek",
+  url: "@Org.OData.Core.V1.IsURL"
+};
+function Annotatable(oConverter, sTarget) {
+  var oParent = oConverter.oAnnotatable;
+  if (oParent) {
+    sTarget = _Helper$1.buildPath(oParent.sPath, sTarget);
+  }
+  this.oConverter = oConverter;
+  this.sPath = sTarget;
+  this.oParent = oParent;
+  this.mSapAttributes = oConverter.mSapAttributes;
+  this.mAnnotationsForTarget = null;
+}
+Annotatable.prototype.annotate = function (sTerm, vValue) {
+  this.getTarget()[sTerm] = vValue;
+};
+Annotatable.prototype.consume = function (sName) {
+  return this.oConverter.consumeSapAnnotation(sName);
+};
+Annotatable.prototype.convert = function (sV2Name, vValue) {
+  var oAnnotation, mAnnotationInfo;
+  if (vValue === undefined || vValue === "") {
+    return;
+  }
+  mAnnotationInfo = mV2toV4[sV2Name];
+  if (mAnnotationInfo.property) {
+    oAnnotation = this.getOrCreateAnnotationRecord(mAnnotationInfo.term);
+    oAnnotation[mAnnotationInfo.property] = vValue;
+  } else {
+    this.annotate(mAnnotationInfo.term, vValue);
+  }
+};
+Annotatable.prototype.getOrCreateAnnotationRecord = function (sTerm) {
+  return this.oConverter.getOrCreateObject(this.getTarget(), sTerm);
+};
+Annotatable.prototype.getTarget = function () {
+  if (!this.mAnnotationsForTarget) {
+    this.mAnnotationsForTarget = this.oConverter.convertedV2Annotations[this.sPath] = {};
+  }
+  return this.mAnnotationsForTarget;
+};
+Annotatable.prototype.peek = function (sName) {
+  return this.oConverter.mSapAnnotations[sName];
+};
+function _V2MetadataConverter() {
+  this.association = null;
+  this.associations = {};
+  this.associationSet = null;
+  this.associationSets = [];
+  this.aBoundOperations = [];
+  this.constraintRole = null;
+  this.convertedV2Annotations = {};
+  this.defaultEntityContainer = null;
+  this.mEntityContainersOfSchema = {};
+  this.mEntityType2EntitySetAnnotation = {};
+  this.mProperty2Semantics = {};
+  this.sPropertyName = null;
+  this.navigationProperties = [];
+  this.mSapAnnotations = {};
+  this.sTypeName = null;
+  this.mProperty2Unit = {};
+  _MetadataConverter.call(this);
+}
+_V2MetadataConverter.prototype = Object.create(_MetadataConverter.prototype);
+_V2MetadataConverter.prototype.collectSapAnnotations = function (oElement) {
+  var oAttribute, oAttributeList = oElement.attributes, i, n;
+  this.mSapAnnotations = {};
+  for ((i = 0, n = oAttributeList.length); i < n; i += 1) {
+    oAttribute = oAttributeList.item(i);
+    if (oAttribute.namespaceURI === sSapNamespace && oAttribute.localName !== "content-version") {
+      this.mSapAnnotations[oAttribute.localName] = oAttribute.value;
+    }
+  }
+};
+_V2MetadataConverter.prototype.consumeSapAnnotation = function (sName) {
+  var sValue = this.mSapAnnotations[sName];
+  delete this.mSapAnnotations[sName];
+  return sValue;
+};
+_V2MetadataConverter.prototype.convertEntitySetAnnotation = function (oAnnotatable, sName) {
+  var sConflictingV2Annotation, sValue;
+  switch (sName) {
+    case "creatable":
+    case "deletable":
+    case "updatable":
+      if (oAnnotatable.peek(sName) === "false") {
+        oAnnotatable.convert(sName, false);
+      }
+      break;
+    case "deletable-path":
+    case "updatable-path":
+      sConflictingV2Annotation = sName.slice(0, 9);
+      sValue = oAnnotatable.consume(sName);
+      if (oAnnotatable.peek(sConflictingV2Annotation)) {
+        oAnnotatable.convert(sName, false);
+        Log.warning("Inconsistent metadata in '" + this.url + "'", "Use either 'sap:" + sConflictingV2Annotation + "' or 'sap:" + sConflictingV2Annotation + "-path'" + " at entity set '" + oAnnotatable.sPath + "'", sClassName);
+      } else {
+        oAnnotatable.convert(sName, {
+          $Path: sValue
+        });
+      }
+      break;
+    case "label":
+      this.convertLabel(oAnnotatable);
+      break;
+    case "pageable":
+      sValue = oAnnotatable.consume(sName);
+      if (sValue === "false") {
+        oAnnotatable.annotate("@Org.OData.Capabilities.V1.SkipSupported", false);
+        oAnnotatable.annotate("@Org.OData.Capabilities.V1.TopSupported", false);
+      }
+      break;
+    case "requires-filter":
+      sValue = oAnnotatable.consume(sName);
+      if (sValue === "true") {
+        oAnnotatable.convert(sName, true);
+      }
+      break;
+    case "topable":
+      sValue = oAnnotatable.consume(sName);
+      if (sValue === "false") {
+        oAnnotatable.convert(sName, false);
+      }
+      break;
+  }
+};
+_V2MetadataConverter.prototype.convertLabel = function (oAnnotatable) {
+  oAnnotatable.convert("label", oAnnotatable.consume("label"));
+};
+_V2MetadataConverter.prototype.convertPropertyAnnotation = function (oAnnotatable, sName) {
+  var sValue;
+  switch (sName) {
+    case "heading":
+    case "label":
+    case "quickinfo":
+      oAnnotatable.convert(sName, oAnnotatable.consume(sName));
+      break;
+    case "field-control":
+    case "precision":
+    case "text":
+      oAnnotatable.convert(sName, {
+        $Path: oAnnotatable.consume(sName)
+      });
+      break;
+    case "aggregation-role":
+      sValue = oAnnotatable.consume(sName);
+      if (sValue === "dimension") {
+        oAnnotatable.annotate("@com.sap.vocabularies.Analytics.v1.Dimension", true);
+      } else if (sValue === "measure") {
+        oAnnotatable.annotate("@com.sap.vocabularies.Analytics.v1.Measure", true);
+      }
+      break;
+    case "display-format":
+      sValue = oAnnotatable.consume(sName);
+      if (sValue === "NonNegative") {
+        oAnnotatable.annotate("@com.sap.vocabularies.Common.v1.IsDigitSequence", true);
+      } else if (sValue === "UpperCase") {
+        oAnnotatable.annotate("@com.sap.vocabularies.Common.v1.IsUpperCase", true);
+      }
+      break;
+    case "semantics":
+      this.convertPropertySemanticsAnnotation(oAnnotatable);
+      break;
+    case "unit":
+      this.mProperty2Unit[oAnnotatable.sPath] = oAnnotatable.consume("unit");
+      break;
+    case "visible":
+      sValue = oAnnotatable.consume(sName);
+      if (sValue === "false") {
+        oAnnotatable.annotate("@com.sap.vocabularies.UI.v1.Hidden", true);
+        oAnnotatable.annotate("@com.sap.vocabularies.Common.v1.FieldControl", {
+          $EnumMember: "com.sap.vocabularies.Common.v1.FieldControlType/Hidden"
+        });
+      }
+      break;
+  }
+};
+_V2MetadataConverter.prototype.convertPropertySemanticsAnnotation = function (oAnnotatable) {
+  var oAnnotations, sEnum, oPath, aResult, oSemantics, aValue = oAnnotatable.peek("semantics").split(";"), sValue = aValue[0], oV2toV4ComplexSemantic = mV2toV4ComplexSemantics[sValue];
+  if (sValue === "unit-of-measure" || sValue === "currency-code") {
+    this.mProperty2Semantics[oAnnotatable.sPath] = oAnnotatable.consume("semantics");
+  } else if (mV2toV4SimpleSemantics[sValue]) {
+    oAnnotatable.annotate(mV2toV4SimpleSemantics[sValue], true);
+    oAnnotatable.consume("semantics");
+  } else if (oV2toV4ComplexSemantic) {
+    oPath = {
+      $Path: this.sPropertyName
+    };
+    oAnnotations = oAnnotatable.oParent.getOrCreateAnnotationRecord("@com.sap.vocabularies.Communication.v1." + oV2toV4ComplexSemantic.TermName);
+    if (oV2toV4ComplexSemantic.Path) {
+      oSemantics = this.getOrCreateObject(oAnnotations, oV2toV4ComplexSemantic.Path);
+      oSemantics[oV2toV4ComplexSemantic.V4Attribute || sValue] = oPath;
+      if (oV2toV4ComplexSemantic.v4PropertyAnnotation) {
+        oAnnotatable.annotate(oV2toV4ComplexSemantic.v4PropertyAnnotation, true);
+        if (aValue[1]) {
+          aResult = [];
+          sEnum = aValue[1].split("=")[1];
+          sEnum.split(",").forEach(function (sType) {
+            var sTargetType = oV2toV4ComplexSemantic.typeMapping[sType];
+            if (sTargetType) {
+              aResult.push(oV2toV4ComplexSemantic.v4EnumType + "/" + sTargetType);
+            } else {
+              Log.warning("Unsupported semantic type: " + sType, undefined, sClassName);
+            }
+          });
+          if (aResult.length) {
+            oSemantics.type = {
+              EnumMember: aResult.join(" ")
+            };
+          }
+        }
+        oAnnotations[oV2toV4ComplexSemantic.Path] = [oSemantics];
+      } else {
+        oAnnotations[oV2toV4ComplexSemantic.Path] = oSemantics;
+      }
+    } else {
+      oAnnotations[oV2toV4ComplexSemantic.V4Attribute || sValue] = oPath;
+    }
+    oAnnotatable.consume("semantics");
+  }
+};
+_V2MetadataConverter.prototype.finalize = function () {
+  this.result.$Version = "4.0";
+  this.setDefaultEntityContainer();
+  this.updateNavigationPropertiesAndCreateBindings();
+  this.processBoundOperations();
+  this.processUnitConversion();
+};
+_V2MetadataConverter.prototype.mergeAnnotations = function (mConvertedV2Annotations, mV4Annotations) {
+  var sAnnotatablePath;
+  for (sAnnotatablePath in mConvertedV2Annotations) {
+    if ((sAnnotatablePath in mV4Annotations)) {
+      mV4Annotations[sAnnotatablePath] = Object.assign(mConvertedV2Annotations[sAnnotatablePath], mV4Annotations[sAnnotatablePath]);
+    } else {
+      mV4Annotations[sAnnotatablePath] = mConvertedV2Annotations[sAnnotatablePath];
+    }
+  }
+};
+_V2MetadataConverter.prototype.postProcessSchema = function (_oElement, _aResult) {
+  var mAnnotations, oEntityContainer, sEntityContainerName, oEntitySet, sEntitySetName, sTarget;
+  for (sEntityContainerName in this.mEntityContainersOfSchema) {
+    oEntityContainer = this.mEntityContainersOfSchema[sEntityContainerName];
+    for (sEntitySetName in oEntityContainer) {
+      oEntitySet = oEntityContainer[sEntitySetName];
+      if (oEntitySet.$kind !== "EntitySet") {
+        continue;
+      }
+      sTarget = sEntityContainerName + "/" + sEntitySetName;
+      mAnnotations = _Helper$1.merge(this.convertedV2Annotations[sTarget] || ({}), this.mEntityType2EntitySetAnnotation[oEntitySet.$Type]);
+      if (!_Helper$1.isEmptyObject(mAnnotations)) {
+        this.convertedV2Annotations[sTarget] = mAnnotations;
+      }
+    }
+  }
+  if (this.bIgnoreAnnotations) {
+    if (!_Helper$1.isEmptyObject(this.convertedV2Annotations)) {
+      this.schema.$Annotations = {};
+    }
+  } else if (this.schema.$Annotations) {
+    this.mergeAnnotations(this.convertedV2Annotations, this.schema.$Annotations);
+  } else if (!_Helper$1.isEmptyObject(this.convertedV2Annotations)) {
+    this.schema.$Annotations = this.convertedV2Annotations;
+  }
+  this.convertedV2Annotations = {};
+  this.mEntityContainersOfSchema = {};
+};
+_V2MetadataConverter.prototype.processAssociation = function (oElement) {
+  var sName = this.namespace + oElement.getAttribute("Name");
+  this.associations[sName] = this.association = {
+    referentialConstraint: null,
+    roles: {}
+  };
+};
+_V2MetadataConverter.prototype.processAssociationEnd = function (oElement) {
+  var sName = oElement.getAttribute("Role");
+  this.association.roles[sName] = {
+    multiplicity: oElement.getAttribute("Multiplicity"),
+    propertyName: undefined,
+    typeName: this.resolveAlias(oElement.getAttribute("Type"))
+  };
+};
+_V2MetadataConverter.prototype.processAssociationSet = function (oElement) {
+  var oAssociationSet = {
+    associationName: this.resolveAlias(oElement.getAttribute("Association")),
+    ends: [],
+    entityContainer: this.entityContainer
+  };
+  this.associationSet = oAssociationSet;
+  this.associationSets.push(oAssociationSet);
+  this.consumeSapAnnotation("creatable");
+  this.consumeSapAnnotation("deletable");
+  this.consumeSapAnnotation("updatable");
+};
+_V2MetadataConverter.prototype.processAssociationSetEnd = function (oElement) {
+  this.associationSet.ends.push({
+    entitySetName: oElement.getAttribute("EntitySet"),
+    roleName: oElement.getAttribute("Role")
+  });
+};
+_V2MetadataConverter.prototype.processComplexType = function (oElement) {
+  this.processType(oElement, {
+    $kind: "ComplexType"
+  });
+};
+_V2MetadataConverter.prototype.processDataServices = function (oElement) {
+  if (oElement.getAttributeNS(sMicrosoftNamespace, "DataServiceVersion") !== "2.0") {
+    throw new Error(this.url + ": expected DataServiceVersion=\"2.0\": " + serializeSingleElement(oElement));
+  }
+};
+_V2MetadataConverter.prototype.processDependent = function (oElement) {
+  var oConstraint = this.association.referentialConstraint;
+  this.constraintRole = oConstraint.dependent = {
+    roleName: oElement.getAttribute("Role")
+  };
+};
+_V2MetadataConverter.prototype.processElement = function (oElement, fnProcessor) {
+  this.collectSapAnnotations(oElement);
+  if (fnProcessor) {
+    fnProcessor.call(this, oElement);
+  }
+  this.warnUnsupportedSapAnnotations(oElement);
+};
+_V2MetadataConverter.prototype.processEntityContainer = function (oElement) {
+  var sQualifiedName = this.namespace + oElement.getAttribute("Name");
+  this.mEntityContainersOfSchema[sQualifiedName] = this.entityContainer = {
+    $kind: "EntityContainer"
+  };
+  this.addToResult(sQualifiedName, this.entityContainer);
+  if (oElement.getAttributeNS(sMicrosoftNamespace, "IsDefaultEntityContainer") === "true") {
+    this.defaultEntityContainer = sQualifiedName;
+  }
+  this.v2annotatable(sQualifiedName);
+};
+_V2MetadataConverter.prototype.processEntitySet = function (oElement) {
+  var oAnnotatable, sName = oElement.getAttribute("Name");
+  this.entityContainer[sName] = this.entitySet = {
+    $kind: "EntitySet",
+    $Type: this.resolveAlias(oElement.getAttribute("EntityType"))
+  };
+  oAnnotatable = this.v2annotatable(sName, this.convertEntitySetAnnotation);
+  oAnnotatable.consume("creatable");
+  oAnnotatable.consume("deletable");
+  oAnnotatable.consume("updatable");
+  if (oAnnotatable.consume("searchable") !== "true") {
+    oAnnotatable.convert("searchable", false);
+  }
+};
+_V2MetadataConverter.prototype.processEntityType = function (oElement) {
+  var oType = {
+    $kind: "EntityType"
+  }, that = this;
+  this.processType(oElement, oType);
+  this.processAttributes(oElement, oType, {
+    Abstract: this.setIfTrue,
+    BaseType: function (sType) {
+      return sType ? that.resolveAlias(sType) : undefined;
+    }
+  });
+  this.convertLabel(this.oAnnotatable);
+};
+_V2MetadataConverter.prototype.processEntityTypeKeyPropertyRef = function (oElement) {
+  var sName = oElement.getAttribute("Name");
+  this.getOrCreateArray(this.type, "$Key").push(sName);
+};
+_V2MetadataConverter.prototype.processFacetAttributes = function (oElement, oResult) {
+  var that = this;
+  this.processAttributes(oElement, oResult, {
+    DefaultValue: this.setValue,
+    MaxLength: function (sValue) {
+      return sValue === "Max" ? undefined : that.setNumber(sValue);
+    },
+    Nullable: this.setIfFalse,
+    Precision: this.setNumber,
+    Scale: this.setNumber,
+    Unicode: this.setIfFalse
+  });
+  if (oElement.getAttribute("FixedLength") === "false") {
+    oResult.$Scale = "variable";
+  }
+};
+_V2MetadataConverter.prototype.processFunctionImport = function (oElement) {
+  var sAnnotationActionFor, sHttpMethod = oElement.getAttributeNS(sMicrosoftNamespace, "HttpMethod"), sKind = sHttpMethod !== "GET" ? "Action" : "Function", sLabel, sName = oElement.getAttribute("Name"), oOperation = {
+    $kind: sKind
+  }, oOperationImport = {
+    $kind: sKind + "Import"
+  }, sQualifiedName = this.namespace + sName, sReturnType = oElement.getAttribute("ReturnType"), oReturnType;
+  oOperationImport["$" + sKind] = sQualifiedName;
+  this.processAttributes(oElement, oOperationImport, {
+    EntitySet: this.setValue
+  });
+  if (sReturnType) {
+    oOperation.$ReturnType = oReturnType = {};
+    this.processTypedCollection(sReturnType, oReturnType);
+  }
+  if (!rHttpMethods.test(sHttpMethod)) {
+    Log.warning("Unsupported HttpMethod at FunctionImport '" + sName + "', removing this FunctionImport", undefined, sClassName);
+    this.consumeSapAnnotation("action-for");
+    this.consumeSapAnnotation("applicable-path");
+  } else {
+    if (sHttpMethod !== "GET" && sHttpMethod !== "POST") {
+      oOperation.$v2HttpMethod = sHttpMethod;
+    }
+    this.addToResult(sQualifiedName, [oOperation]);
+    sAnnotationActionFor = this.consumeSapAnnotation("action-for");
+    if (sAnnotationActionFor) {
+      oOperation.$IsBound = true;
+      oOperation.$Parameter = [{
+        $Name: null,
+        $Nullable: false,
+        $Type: this.resolveAlias(sAnnotationActionFor)
+      }];
+      this.aBoundOperations.push(oOperation);
+      this.consumeSapAnnotation("applicable-path");
+      sLabel = this.consumeSapAnnotation("label");
+      if (sLabel) {
+        oOperation[mV2toV4["label"].term] = sLabel;
+      }
+    } else {
+      this.entityContainer[sName] = oOperationImport;
+      this.v2annotatable(sName);
+      this.convertLabel(this.oAnnotatable);
+    }
+  }
+  this.oOperation = oOperation;
+};
+_V2MetadataConverter.prototype.processParameter = function (oElement) {
+  var sLabel, oOperation = this.oOperation, oParameter = {
+    $Name: oElement.getAttribute("Name")
+  };
+  this.processFacetAttributes(oElement, oParameter);
+  this.processTypedCollection(oElement.getAttribute("Type"), oParameter);
+  this.getOrCreateArray(oOperation, "$Parameter").push(oParameter);
+  sLabel = this.consumeSapAnnotation("label");
+  if (sLabel) {
+    oParameter[mV2toV4["label"].term] = sLabel;
+  }
+};
+_V2MetadataConverter.prototype.processPrincipal = function (oElement) {
+  var oConstraint = this.association.referentialConstraint;
+  this.constraintRole = oConstraint.principal = {
+    roleName: oElement.getAttribute("Role")
+  };
+};
+_V2MetadataConverter.prototype.processReferentialConstraint = function (_oElement) {
+  this.association.referentialConstraint = {};
+};
+_V2MetadataConverter.prototype.processReferentialConstraintPropertyRef = function (oElement) {
+  this.constraintRole.propertyRef = oElement.getAttribute("Name");
+};
+_V2MetadataConverter.prototype.processSchema = function (oElement) {
+  var sSchemaVersion = this.consumeSapAnnotation("schema-version");
+  this.namespace = oElement.getAttribute("Namespace") + ".";
+  this.schema = {
+    $kind: "Schema"
+  };
+  this.addToResult(this.namespace, this.schema);
+  if (sSchemaVersion) {
+    this.schema["@Org.Odata.Core.V1.SchemaVersion"] = sSchemaVersion;
+  }
+};
+_V2MetadataConverter.prototype.processType = function (oElement, oType) {
+  var sQualifiedName = this.namespace + oElement.getAttribute("Name");
+  this.sTypeName = sQualifiedName;
+  this.type = oType;
+  this.addToResult(sQualifiedName, oType);
+  this.v2annotatable(sQualifiedName);
+};
+_V2MetadataConverter.prototype.processTypedCollection = function (sType, oProperty) {
+  var aMatches = this.rCollection.exec(sType);
+  if (aMatches) {
+    oProperty.$isCollection = true;
+    sType = aMatches[1];
+  }
+  if (!sType.includes(".")) {
+    sType = "Edm." + sType;
+  }
+  switch (sType) {
+    case "Edm.DateTime":
+      oProperty.$v2Type = sType;
+      if (this.mSapAnnotations["display-format"] === "Date") {
+        sType = "Edm.Date";
+        delete oProperty.$Precision;
+      } else {
+        sType = "Edm.DateTimeOffset";
+      }
+      break;
+    case "Edm.Float":
+      oProperty.$v2Type = sType;
+      sType = "Edm.Single";
+      break;
+    case "Edm.Time":
+      oProperty.$v2Type = sType;
+      sType = "Edm.TimeOfDay";
+      break;
+    default:
+      sType = this.resolveAlias(sType);
+  }
+  oProperty.$Type = sType;
+};
+_V2MetadataConverter.prototype.processTypeNavigationProperty = function (oElement) {
+  var sCreatable = this.consumeSapAnnotation("creatable"), sCreatablePath = this.consumeSapAnnotation("creatable-path"), sFilterable = this.consumeSapAnnotation("filterable"), oFilterablePath, vHere, sName = oElement.getAttribute("Name"), oNavigationPropertyPath, oProperty = {
+    $kind: "NavigationProperty"
+  }, that = this;
+  function pushPropertyPath(sTerm, sProperty, oAnnotation) {
+    vHere = that.getOrCreateObject(that.mEntityType2EntitySetAnnotation, that.sTypeName);
+    vHere = that.getOrCreateObject(vHere, sTerm);
+    vHere = that.getOrCreateArray(vHere, sProperty);
+    vHere.push(oAnnotation);
+  }
+  this.type[sName] = oProperty;
+  this.navigationProperties.push({
+    associationName: this.resolveAlias(oElement.getAttribute("Relationship")),
+    fromRoleName: oElement.getAttribute("FromRole"),
+    property: oProperty,
+    propertyName: sName,
+    toRoleName: oElement.getAttribute("ToRole")
+  });
+  this.v2annotatable(sName);
+  if (sCreatable) {
+    oNavigationPropertyPath = {
+      $NavigationPropertyPath: sName
+    };
+    if (sCreatablePath) {
+      Log.warning("Inconsistent metadata in '" + this.url + "'", "Use either 'sap:creatable' or 'sap:creatable-path' at navigation property '" + this.oAnnotatable.sPath + "'", sClassName);
+    } else if (sCreatable === "true") {
+      oNavigationPropertyPath = null;
+    }
+  } else if (sCreatablePath) {
+    oNavigationPropertyPath = {
+      $If: [{
+        $Not: {
+          $Path: sCreatablePath
+        }
+      }, {
+        $NavigationPropertyPath: sName
+      }]
+    };
+  }
+  if (oNavigationPropertyPath) {
+    pushPropertyPath("@Org.OData.Capabilities.V1.InsertRestrictions", "NonInsertableNavigationProperties", oNavigationPropertyPath);
+  }
+  if (sFilterable === "false") {
+    oFilterablePath = {
+      NavigationProperty: {
+        $NavigationPropertyPath: sName
+      },
+      FilterRestrictions: {
+        Filterable: false
+      }
+    };
+    pushPropertyPath("@Org.OData.Capabilities.V1.NavigationRestrictions", "RestrictedProperties", oFilterablePath);
+  }
+};
+_V2MetadataConverter.prototype.processTypeProperty = function (oElement) {
+  var oAnnotatable, sEnumMember, sFilterRestriction, vHere, sName = oElement.getAttribute("Name"), oProperty = {
+    $kind: "Property"
+  }, that = this;
+  function pushPropertyPath(sTerm, sProperty, sAnnotation) {
+    if (that.type.$kind === "EntityType") {
+      vHere = that.getOrCreateObject(that.mEntityType2EntitySetAnnotation, that.sTypeName);
+      vHere = that.getOrCreateObject(vHere, sTerm);
+      vHere = that.getOrCreateArray(vHere, sProperty);
+      vHere.push({
+        $PropertyPath: sName
+      });
+    } else {
+      Log.warning("Unsupported SAP annotation at a complex type in '" + that.url + "'", "sap:" + sAnnotation + " at property '" + oAnnotatable.sPath + "'", sClassName);
+    }
+  }
+  this.sPropertyName = sName;
+  this.type[sName] = oProperty;
+  this.processFacetAttributes(oElement, oProperty);
+  this.processTypedCollection(oElement.getAttribute("Type"), oProperty);
+  oAnnotatable = this.v2annotatable(sName, this.convertPropertyAnnotation);
+  if (oAnnotatable.consume("updatable") === "false") {
+    if (oAnnotatable.consume("creatable") === "false") {
+      oAnnotatable.annotate("@Org.OData.Core.V1.Computed", true);
+    } else {
+      oAnnotatable.annotate("@Org.OData.Core.V1.Immutable", true);
+    }
+  }
+  if (oAnnotatable.consume("filterable") === "false") {
+    pushPropertyPath("@Org.OData.Capabilities.V1.FilterRestrictions", "NonFilterableProperties", "filterable");
+  }
+  sFilterRestriction = oAnnotatable.consume("filter-restriction");
+  if (sFilterRestriction) {
+    switch (sFilterRestriction) {
+      case "interval":
+        sEnumMember = "SingleInterval";
+        break;
+      case "multi-value":
+        sEnumMember = "MultiValue";
+        break;
+      case "single-value":
+        sEnumMember = "SingleValue";
+        break;
+      default:
+        Log.warning("Inconsistent metadata in '" + this.url + "'", "Unsupported sap:filter-restriction=\"" + sFilterRestriction + "\" at property '" + oAnnotatable.sPath + "'", sClassName);
+    }
+    if (sEnumMember) {
+      if (this.type.$kind === "EntityType") {
+        vHere = this.getOrCreateObject(this.mEntityType2EntitySetAnnotation, this.sTypeName);
+        vHere = this.getOrCreateArray(vHere, "@com.sap.vocabularies.Common.v1.FilterExpressionRestrictions");
+        vHere.push({
+          AllowedExpressions: {
+            EnumMember: "com.sap.vocabularies.Common.v1.FilterExpressionType/" + sEnumMember
+          },
+          Property: {
+            $PropertyPath: sName
+          }
+        });
+      } else {
+        Log.warning("Unsupported SAP annotation at a complex type in '" + this.url + "'", "sap:filter-restriction at property '" + oAnnotatable.sPath + "'", sClassName);
+      }
+    }
+  }
+  if (oAnnotatable.consume("required-in-filter") === "true") {
+    pushPropertyPath("@Org.OData.Capabilities.V1.FilterRestrictions", "RequiredProperties", "required-in-filter");
+  }
+  if (oAnnotatable.consume("sortable") === "false") {
+    pushPropertyPath("@Org.OData.Capabilities.V1.SortRestrictions", "NonSortableProperties", "sortable");
+  }
+};
+_V2MetadataConverter.prototype.processBoundOperations = function () {
+  var that = this;
+  this.aBoundOperations.forEach(function (oOperation) {
+    var oEntityType = that.result[oOperation.$Parameter[0].$Type];
+    oEntityType.$Key.forEach(function (sKeyName) {
+      oOperation.$Parameter.some(function (oParameter, i) {
+        if (oParameter.$Name === sKeyName) {
+          oOperation.$Parameter.splice(i, 1);
+          return true;
+        }
+      });
+    });
+  });
+};
+_V2MetadataConverter.prototype.processUnitConversion = function () {
+  var that = this;
+  Object.keys(this.mProperty2Unit).forEach(function (sPropertyPath) {
+    var vHere, oType, sTypeName = sPropertyPath.split("/")[0], sUnitAnnotation, sUnitPath = that.mProperty2Unit[sPropertyPath], aUnitPathSegments = sUnitPath.split("/"), oUnitProperty, sUnitSemantics, i, n = aUnitPathSegments.length;
+    for (i = 0; i < n; i += 1) {
+      oType = that.result[sTypeName];
+      oUnitProperty = oType[aUnitPathSegments[i]];
+      if (!oUnitProperty) {
+        Log.warning("Path '" + sUnitPath + "' for sap:unit cannot be resolved", sPropertyPath, sClassName);
+        return;
+      }
+      if (i < n - 1) {
+        sTypeName = oUnitProperty.$Type;
+      }
+    }
+    sUnitSemantics = that.mProperty2Semantics[sTypeName + "/" + aUnitPathSegments[n - 1]];
+    if (!sUnitSemantics) {
+      Log.warning("Unsupported sap:semantics at sap:unit='" + sUnitPath + "'; expected 'currency-code' or 'unit-of-measure'", sPropertyPath, sClassName);
+      return;
+    }
+    sUnitAnnotation = sUnitSemantics === "currency-code" ? "ISOCurrency" : "Unit";
+    sUnitAnnotation = "@Org.OData.Measures.V1." + sUnitAnnotation;
+    vHere = that.getOrCreateObject(that.result[_Helper$1.namespace(sPropertyPath) + "."], "$Annotations");
+    if (that.bIgnoreAnnotations) {
+      return;
+    }
+    vHere = that.getOrCreateObject(vHere, sPropertyPath);
+    if (!((sUnitAnnotation in vHere))) {
+      vHere[sUnitAnnotation] = {
+        $Path: sUnitPath
+      };
+    }
+  });
+};
+function serializeSingleElement(oElement) {
+  var oAttribute, oAttributesList = oElement.attributes, sText = "<" + oElement.nodeName, i, n;
+  for ((i = 0, n = oAttributesList.length); i < n; i += 1) {
+    oAttribute = oAttributesList.item(i);
+    sText += " " + oAttribute.name + "=\"" + oAttribute.value + "\"";
+  }
+  return sText + (oElement.childNodes.length ? ">" : "/>");
+}
+_V2MetadataConverter.prototype.setDefaultEntityContainer = function () {
+  var sDefaultEntityContainer = this.defaultEntityContainer, aEntityContainers, oResult = this.result;
+  if (sDefaultEntityContainer) {
+    oResult.$EntityContainer = sDefaultEntityContainer;
+  } else {
+    aEntityContainers = Object.keys(oResult).filter(function (sQualifiedName) {
+      return oResult[sQualifiedName].$kind === "EntityContainer";
+    });
+    if (aEntityContainers.length === 1) {
+      oResult.$EntityContainer = aEntityContainers[0];
+    }
+  }
+};
+_V2MetadataConverter.prototype.updateNavigationPropertiesAndCreateBindings = function () {
+  var that = this;
+  this.navigationProperties.forEach(function (oNavigationPropertyData) {
+    var oAssociation = that.associations[oNavigationPropertyData.associationName], oConstraint = oAssociation.referentialConstraint, oNavigationProperty = oNavigationPropertyData.property, oToRole = oAssociation.roles[oNavigationPropertyData.toRoleName];
+    oNavigationProperty.$Type = oToRole.typeName;
+    oToRole.propertyName = oNavigationPropertyData.propertyName;
+    if (oToRole.multiplicity === "1") {
+      oNavigationProperty.$Nullable = false;
+    }
+    if (oToRole.multiplicity === "*") {
+      oNavigationProperty.$isCollection = true;
+    }
+    if (oConstraint && oConstraint.principal.roleName === oNavigationPropertyData.toRoleName) {
+      oNavigationProperty.$ReferentialConstraint = {};
+      oNavigationProperty.$ReferentialConstraint[oConstraint.dependent.propertyRef] = oConstraint.principal.propertyRef;
+    }
+  });
+  this.associationSets.forEach(function (oAssociationSet) {
+    var oAssociation = that.associations[oAssociationSet.associationName], oEntityContainer = oAssociationSet.entityContainer;
+    function createNavigationPropertyBinding(oAssociationSetFrom, oAssociationSetTo) {
+      var oEntitySet = oEntityContainer[oAssociationSetFrom.entitySetName], oToRole = oAssociation.roles[oAssociationSetTo.roleName];
+      if (oToRole.propertyName) {
+        oEntitySet.$NavigationPropertyBinding = oEntitySet.$NavigationPropertyBinding || ({});
+        oEntitySet.$NavigationPropertyBinding[oToRole.propertyName] = oAssociationSetTo.entitySetName;
+      }
+    }
+    createNavigationPropertyBinding(oAssociationSet.ends[0], oAssociationSet.ends[1]);
+    createNavigationPropertyBinding(oAssociationSet.ends[1], oAssociationSet.ends[0]);
+  });
+};
+_V2MetadataConverter.prototype.v2annotatable = function (sName, fnProcessV2Annotatable) {
+  var oAnnotatable = new Annotatable(this, sName);
+  this.oAnnotatable = oAnnotatable;
+  if (fnProcessV2Annotatable) {
+    fnProcessV2Annotatable = fnProcessV2Annotatable.bind(this);
+    Object.keys(this.mSapAnnotations).forEach(function (sName) {
+      fnProcessV2Annotatable(oAnnotatable, sName);
+    });
+  }
+  return oAnnotatable;
+};
+_V2MetadataConverter.prototype.warnUnsupportedSapAnnotations = function (oElement) {
+  Object.keys(this.mSapAnnotations).forEach(function (sName) {
+    Log.warning("Unsupported annotation 'sap:" + sName + "'", serializeSingleElement(oElement), sClassName);
+  });
+};
+(function ($$) {
+  var oStructuredTypeConfig;
+  $$.sRootNamespace = sEdmxNamespace;
+  $$.oAliasConfig = {
+    Reference: {
+      __xmlns: _MetadataConverter.sEdmxNamespace,
+      Include: {
+        __processor: $$.processAlias
+      }
+    },
+    DataServices: {
+      Schema: {
+        __processor: $$.processAlias
+      }
+    }
+  };
+  oStructuredTypeConfig = {
+    NavigationProperty: {
+      __processor: $$.processTypeNavigationProperty
+    },
+    Property: {
+      __processor: $$.processTypeProperty
+    }
+  };
+  $$.oFullConfig = {
+    __include: [$$.oReferenceInclude],
+    DataServices: {
+      __processor: $$.processDataServices,
+      Schema: {
+        __postProcessor: $$.postProcessSchema,
+        __processor: $$.processSchema,
+        __include: [$$.oAnnotationsConfig],
+        Association: {
+          __processor: $$.processAssociation,
+          End: {
+            __processor: $$.processAssociationEnd
+          },
+          ReferentialConstraint: {
+            __processor: $$.processReferentialConstraint,
+            Dependent: {
+              __processor: $$.processDependent,
+              PropertyRef: {
+                __processor: $$.processReferentialConstraintPropertyRef
+              }
+            },
+            Principal: {
+              __processor: $$.processPrincipal,
+              PropertyRef: {
+                __processor: $$.processReferentialConstraintPropertyRef
+              }
+            }
+          }
+        },
+        ComplexType: {
+          __processor: $$.processComplexType,
+          __include: [oStructuredTypeConfig]
+        },
+        EntityContainer: {
+          __processor: $$.processEntityContainer,
+          AssociationSet: {
+            __processor: $$.processAssociationSet,
+            End: {
+              __processor: $$.processAssociationSetEnd
+            }
+          },
+          EntitySet: {
+            __processor: $$.processEntitySet
+          },
+          FunctionImport: {
+            __processor: $$.processFunctionImport,
+            Parameter: {
+              __processor: $$.processParameter
+            }
+          }
+        },
+        EntityType: {
+          __processor: $$.processEntityType,
+          __include: [oStructuredTypeConfig],
+          Key: {
+            PropertyRef: {
+              __processor: $$.processEntityTypeKeyPropertyRef
+            }
+          }
+        }
+      }
+    }
+  };
+})(_V2MetadataConverter.prototype);
+
+function _V4MetadataConverter() {
+  this.enumType = null;
+  this.enumTypeMemberCounter = 0;
+  this.navigationProperty = null;
+  _MetadataConverter.call(this);
+}
+_V4MetadataConverter.prototype = Object.create(_MetadataConverter.prototype);
+_V4MetadataConverter.prototype.finalize = function () {
+  if (this.result.$Version !== "4.0") {
+    throw new Error(this.url + ": Unsupported OData version " + this.result.$Version);
+  }
+};
+_V4MetadataConverter.prototype.processActionOrFunction = function (oElement) {
+  var sKind = oElement.localName, oOperation = {
+    $kind: sKind
+  }, aOverloads, oParametersCollection, sQualifiedName = this.namespace + oElement.getAttribute("Name"), sSignature = "", that = this;
+  function getType(oParameter) {
+    var oType = {};
+    that.processTypedCollection(oParameter.getAttribute("Type"), oType);
+    return oType.$isCollection ? "Collection(" + oType.$Type + ")" : oType.$Type;
+  }
+  this.processAttributes(oElement, oOperation, {
+    IsBound: this.setIfTrue,
+    EntitySetPath: this.setValue,
+    IsComposable: this.setIfTrue
+  });
+  aOverloads = this.getOrCreateArray(this.result, sQualifiedName);
+  if (!Array.isArray(aOverloads)) {
+    aOverloads = [];
+    this.addToResult(sQualifiedName, aOverloads);
+  }
+  aOverloads.push(oOperation);
+  this.oOperation = oOperation;
+  if (oOperation.$IsBound) {
+    oParametersCollection = oElement.getElementsByTagName("Parameter");
+    sSignature = oElement.localName === "Action" ? getType(oParametersCollection[0]) : Array.prototype.map.call(oParametersCollection, getType).join(",");
+  }
+  this.annotatable(sQualifiedName + "(" + sSignature + ")");
+};
+_V4MetadataConverter.prototype.processComplexType = function (oElement) {
+  this.processType(oElement, {
+    $kind: "ComplexType"
+  });
+};
+_V4MetadataConverter.prototype.processEdmx = function (oElement) {
+  this.processAttributes(oElement, this.result, {
+    Version: this.setValue
+  });
+};
+_V4MetadataConverter.prototype.processElement = function (oElement, fnProcessor) {
+  if (fnProcessor) {
+    fnProcessor.call(this, oElement);
+  }
+};
+_V4MetadataConverter.prototype.processEntityContainer = function (oElement) {
+  var sQualifiedName = this.namespace + oElement.getAttribute("Name");
+  this.entityContainer = {
+    $kind: "EntityContainer"
+  };
+  this.addToResult(sQualifiedName, this.entityContainer);
+  this.addToResult("$EntityContainer", sQualifiedName);
+  this.annotatable(sQualifiedName);
+};
+_V4MetadataConverter.prototype.processEntitySet = function (oElement) {
+  var sName = oElement.getAttribute("Name");
+  this.entityContainer[sName] = this.entitySet = {
+    $kind: "EntitySet",
+    $Type: this.resolveAlias(oElement.getAttribute("EntityType"))
+  };
+  this.processAttributes(oElement, this.entitySet, {
+    IncludeInServiceDocument: this.setIfFalse
+  });
+  this.annotatable(sName);
+};
+_V4MetadataConverter.prototype.processEntityType = function (oElement) {
+  this.processType(oElement, {
+    $kind: "EntityType"
+  });
+};
+_V4MetadataConverter.prototype.processEntityTypeKeyPropertyRef = function (oElement) {
+  var sAlias = oElement.getAttribute("Alias"), vKey, sName = oElement.getAttribute("Name");
+  if (sAlias) {
+    vKey = {};
+    vKey[sAlias] = sName;
+  } else {
+    vKey = sName;
+  }
+  this.getOrCreateArray(this.type, "$Key").push(vKey);
+};
+_V4MetadataConverter.prototype.processEnumType = function (oElement) {
+  var sQualifiedName = this.namespace + oElement.getAttribute("Name"), oEnumType = {
+    $kind: "EnumType"
+  };
+  this.processAttributes(oElement, oEnumType, {
+    IsFlags: this.setIfTrue,
+    UnderlyingType: function (sValue) {
+      return sValue !== "Edm.Int32" ? sValue : undefined;
+    }
+  });
+  this.enumType = oEnumType;
+  this.addToResult(sQualifiedName, oEnumType);
+  this.enumTypeMemberCounter = 0;
+  this.annotatable(sQualifiedName);
+};
+_V4MetadataConverter.prototype.processEnumTypeMember = function (oElement) {
+  var sName = oElement.getAttribute("Name"), sValue = oElement.getAttribute("Value"), vValue;
+  if (sValue) {
+    vValue = parseInt(sValue);
+    if (!_Helper$1.isSafeInteger(vValue)) {
+      vValue = sValue;
+    }
+  } else {
+    vValue = this.enumTypeMemberCounter;
+    this.enumTypeMemberCounter += 1;
+  }
+  this.enumType[sName] = vValue;
+  this.annotatable(sName);
+};
+_V4MetadataConverter.prototype.processFacetAttributes = function (oElement, oResult) {
+  var that = this;
+  this.processAttributes(oElement, oResult, {
+    MaxLength: function (sValue) {
+      return sValue === "max" ? undefined : that.setNumber(sValue);
+    },
+    Precision: this.setNumber,
+    Scale: function (sValue) {
+      return sValue === "variable" ? sValue : that.setNumber(sValue);
+    },
+    SRID: this.setValue,
+    Unicode: this.setIfFalse
+  });
+};
+_V4MetadataConverter.prototype.processImport = function (oElement) {
+  var sKind = oElement.localName, oImport = {
+    $kind: sKind
+  }, sName = oElement.getAttribute("Name"), that = this;
+  sKind = sKind.replace("Import", "");
+  oImport["$" + sKind] = this.resolveAlias(oElement.getAttribute(sKind));
+  this.processAttributes(oElement, oImport, {
+    EntitySet: function (sValue) {
+      return that.resolveTargetPath(sValue);
+    },
+    IncludeInServiceDocument: this.setIfTrue
+  });
+  this.entityContainer[sName] = oImport;
+  this.annotatable(sName);
+};
+_V4MetadataConverter.prototype.processNavigationPropertyBinding = function (oElement) {
+  var oNavigationPropertyBinding = this.getOrCreateObject(this.entitySet, "$NavigationPropertyBinding");
+  oNavigationPropertyBinding[oElement.getAttribute("Path")] = this.resolveTargetPath(oElement.getAttribute("Target"));
+};
+_V4MetadataConverter.prototype.processParameter = function (oElement) {
+  var oActionOrFunction = this.oOperation, oParameter = {};
+  this.processTypedCollection(oElement.getAttribute("Type"), oParameter);
+  this.processAttributes(oElement, oParameter, {
+    Name: this.setValue,
+    Nullable: this.setIfFalse
+  });
+  this.processFacetAttributes(oElement, oParameter);
+  this.getOrCreateArray(oActionOrFunction, "$Parameter").push(oParameter);
+  this.annotatable(oParameter.$Name);
+};
+_V4MetadataConverter.prototype.processReturnType = function (oElement) {
+  var oActionOrFunction = this.oOperation, oReturnType = {};
+  this.processTypedCollection(oElement.getAttribute("Type"), oReturnType);
+  this.processAttributes(oElement, oReturnType, {
+    Nullable: this.setIfFalse
+  });
+  this.processFacetAttributes(oElement, oReturnType);
+  oActionOrFunction.$ReturnType = oReturnType;
+  this.annotatable("$ReturnType");
+};
+_V4MetadataConverter.prototype.processSchema = function (oElement) {
+  this.namespace = oElement.getAttribute("Namespace") + ".";
+  this.schema = {
+    $kind: "Schema"
+  };
+  this.addToResult(this.namespace, this.schema);
+  this.annotatable(this.schema);
+};
+_V4MetadataConverter.prototype.processSingleton = function (oElement) {
+  var sName = oElement.getAttribute("Name");
+  this.entityContainer[sName] = this.entitySet = {
+    $kind: "Singleton",
+    $Type: this.resolveAlias(oElement.getAttribute("Type"))
+  };
+  this.annotatable(sName);
+};
+_V4MetadataConverter.prototype.processTerm = function (oElement) {
+  var sQualifiedName = this.namespace + oElement.getAttribute("Name"), oTerm = {
+    $kind: "Term"
+  }, that = this;
+  this.processTypedCollection(oElement.getAttribute("Type"), oTerm);
+  this.processAttributes(oElement, oTerm, {
+    Nullable: this.setIfFalse,
+    BaseTerm: function (sValue) {
+      return sValue ? that.resolveAlias(sValue) : undefined;
+    }
+  });
+  this.processFacetAttributes(oElement, oTerm);
+  this.addToResult(sQualifiedName, oTerm);
+  this.annotatable(sQualifiedName);
+};
+_V4MetadataConverter.prototype.processType = function (oElement, oType) {
+  var sQualifiedName = this.namespace + oElement.getAttribute("Name"), that = this;
+  this.processAttributes(oElement, oType, {
+    OpenType: that.setIfTrue,
+    HasStream: that.setIfTrue,
+    Abstract: that.setIfTrue,
+    BaseType: function (sType) {
+      return sType ? that.resolveAlias(sType) : undefined;
+    }
+  });
+  this.type = oType;
+  this.addToResult(sQualifiedName, oType);
+  this.annotatable(sQualifiedName);
+};
+_V4MetadataConverter.prototype.processTypedCollection = function (sType, oProperty) {
+  var aMatches = this.rCollection.exec(sType);
+  if (aMatches) {
+    oProperty.$isCollection = true;
+    sType = aMatches[1];
+  }
+  oProperty.$Type = this.resolveAlias(sType);
+};
+_V4MetadataConverter.prototype.processTypeDefinition = function (oElement) {
+  var sQualifiedName = this.namespace + oElement.getAttribute("Name"), oTypeDefinition = {
+    $kind: "TypeDefinition",
+    $UnderlyingType: oElement.getAttribute("UnderlyingType")
+  };
+  this.addToResult(sQualifiedName, oTypeDefinition);
+  this.processFacetAttributes(oElement, oTypeDefinition);
+  this.annotatable(sQualifiedName);
+};
+_V4MetadataConverter.prototype.processTypeNavigationProperty = function (oElement) {
+  var sName = oElement.getAttribute("Name"), oProperty = {
+    $kind: "NavigationProperty"
+  };
+  this.processTypedCollection(oElement.getAttribute("Type"), oProperty);
+  this.processAttributes(oElement, oProperty, {
+    Nullable: this.setIfFalse,
+    Partner: this.setValue,
+    ContainsTarget: this.setIfTrue
+  });
+  this.type[sName] = this.navigationProperty = oProperty;
+  this.annotatable(sName);
+};
+_V4MetadataConverter.prototype.processTypeNavigationPropertyOnDelete = function (oElement) {
+  this.navigationProperty.$OnDelete = oElement.getAttribute("Action");
+  this.annotatable(this.navigationProperty, "$OnDelete");
+};
+_V4MetadataConverter.prototype.processTypeNavigationPropertyReferentialConstraint = function (oElement) {
+  var sProperty = oElement.getAttribute("Property"), oReferentialConstraint = this.getOrCreateObject(this.navigationProperty, "$ReferentialConstraint");
+  oReferentialConstraint[sProperty] = oElement.getAttribute("ReferencedProperty");
+  this.annotatable(oReferentialConstraint, sProperty);
+};
+_V4MetadataConverter.prototype.processTypeProperty = function (oElement) {
+  var sName = oElement.getAttribute("Name"), oProperty = {
+    $kind: "Property"
+  };
+  this.processTypedCollection(oElement.getAttribute("Type"), oProperty);
+  this.processAttributes(oElement, oProperty, {
+    Nullable: this.setIfFalse,
+    DefaultValue: this.setValue
+  });
+  this.processFacetAttributes(oElement, oProperty);
+  this.type[sName] = oProperty;
+  this.annotatable(sName);
+};
+_V4MetadataConverter.prototype.resolveTargetPath = function (sPath) {
+  var iSlash;
+  if (!sPath) {
+    return sPath;
+  }
+  sPath = this.resolveAliasInPath(sPath);
+  iSlash = sPath.indexOf("/");
+  if (iSlash >= 0 && !sPath.includes("/", iSlash + 1)) {
+    if (sPath.slice(0, iSlash) === this.result.$EntityContainer) {
+      return sPath.slice(iSlash + 1);
+    }
+  }
+  return sPath;
+};
+(function ($$) {
+  var oActionOrFunctionConfig, oEntitySetConfig, oStructuredTypeConfig;
+  $$.sRootNamespace = $$.sEdmxNamespace;
+  $$.oAliasConfig = {
+    __xmlns: $$.sEdmxNamespace,
+    Reference: {
+      Include: {
+        __processor: $$.processAlias
+      }
+    },
+    DataServices: {
+      Schema: {
+        __xmlns: $$.sEdmNamespace,
+        __processor: $$.processAlias
+      }
+    }
+  };
+  oStructuredTypeConfig = {
+    Property: {
+      __processor: $$.processTypeProperty,
+      __include: [$$.oAnnotationConfig]
+    },
+    NavigationProperty: {
+      __processor: $$.processTypeNavigationProperty,
+      __include: [$$.oAnnotationConfig],
+      OnDelete: {
+        __processor: $$.processTypeNavigationPropertyOnDelete,
+        __include: [$$.oAnnotationConfig]
+      },
+      ReferentialConstraint: {
+        __processor: $$.processTypeNavigationPropertyReferentialConstraint,
+        __include: [$$.oAnnotationConfig]
+      }
+    }
+  };
+  oEntitySetConfig = {
+    NavigationPropertyBinding: {
+      __processor: $$.processNavigationPropertyBinding
+    }
+  };
+  oActionOrFunctionConfig = {
+    Parameter: {
+      __processor: $$.processParameter,
+      __include: [$$.oAnnotationConfig]
+    },
+    ReturnType: {
+      __processor: $$.processReturnType,
+      __include: [$$.oAnnotationConfig]
+    }
+  };
+  $$.oFullConfig = {
+    __xmlns: $$.sEdmxNamespace,
+    __processor: $$.processEdmx,
+    __include: [$$.oReferenceInclude],
+    DataServices: {
+      Schema: {
+        __xmlns: $$.sEdmNamespace,
+        __processor: $$.processSchema,
+        __include: [$$.oAnnotationsConfig, $$.oAnnotationConfig],
+        Action: {
+          __processor: $$.processActionOrFunction,
+          __include: [oActionOrFunctionConfig, $$.oAnnotationConfig]
+        },
+        Function: {
+          __processor: $$.processActionOrFunction,
+          __include: [oActionOrFunctionConfig, $$.oAnnotationConfig]
+        },
+        EntityType: {
+          __processor: $$.processEntityType,
+          __include: [oStructuredTypeConfig, $$.oAnnotationConfig],
+          Key: {
+            PropertyRef: {
+              __processor: $$.processEntityTypeKeyPropertyRef
+            }
+          }
+        },
+        ComplexType: {
+          __processor: $$.processComplexType,
+          __include: [oStructuredTypeConfig, $$.oAnnotationConfig]
+        },
+        EntityContainer: {
+          __processor: $$.processEntityContainer,
+          __include: [$$.oAnnotationConfig],
+          ActionImport: {
+            __processor: $$.processImport,
+            __include: [$$.oAnnotationConfig]
+          },
+          EntitySet: {
+            __processor: $$.processEntitySet,
+            __include: [oEntitySetConfig, $$.oAnnotationConfig]
+          },
+          FunctionImport: {
+            __processor: $$.processImport,
+            __include: [$$.oAnnotationConfig]
+          },
+          Singleton: {
+            __processor: $$.processSingleton,
+            __include: [oEntitySetConfig, $$.oAnnotationConfig]
+          }
+        },
+        EnumType: {
+          __processor: $$.processEnumType,
+          __include: [$$.oAnnotationConfig],
+          Member: {
+            __processor: $$.processEnumTypeMember,
+            __include: [$$.oAnnotationConfig]
+          }
+        },
+        Term: {
+          __processor: $$.processTerm,
+          __include: [$$.oAnnotationConfig]
+        },
+        TypeDefinition: {
+          __processor: $$.processTypeDefinition,
+          __include: [$$.oAnnotationConfig]
+        }
+      }
+    }
+  };
+})(_V4MetadataConverter.prototype);
+
+export { Applier, ApplyUtil, Change, RegistrationBuild$1 as RegistrationBuild, URI, _V2MetadataConverter as V2MetadataConverter, _V4MetadataConverter as V4MetadataConverter };