@ui5/task-adaptation 1.4.0 → 1.4.1

package/dist/bundle.js

@@ -1909,7 +1909,13 @@ function splitEscapePath(sPropertyPath) {
   const aPath = sReplaceEscapeWithDummy.split("/");
   return aPath.map(element => element.replaceAll("*", "/"));
 }
-function setPropValueByPath(oEntityProp, oRoot) {
+function deleteProperty(aPath, oRoot) {
+  for (let i = 0; i < aPath.length - 1; i++) {
+    oRoot = oRoot[aPath[i]];
+  }
+  delete oRoot[aPath[aPath.length - 1]];
+}
+function setOrDeletePropValueByPath(oEntityProp, oRoot) {
   let aPath;
   if (oEntityProp.propertyPath.includes("\\")) {
     aPath = splitEscapePath(oEntityProp.propertyPath);
@@ -1923,15 +1929,19 @@ function setPropValueByPath(oEntityProp, oRoot) {
   if (!valueByPath && oEntityProp.operation === "UPDATE") {
     throw new Error("Path does not contain a value. 'UPDATE' operation is not appropriate.");
   }
-  ObjectPath.set(aPath, oEntityProp.propertyValue, oRoot);
+  if (oEntityProp.operation === "DELETE") {
+    deleteProperty(aPath, oRoot);
+  } else {
+    ObjectPath.set(aPath, oEntityProp.propertyValue, oRoot);
+  }
 }
 function changePropertyValueByPath (vChanges, oRootPath) {
   if (Array.isArray(vChanges)) {
     vChanges.forEach(function (oEntityProp) {
-      setPropValueByPath(oEntityProp, oRootPath);
+      setOrDeletePropValueByPath(oEntityProp, oRootPath);
     });
   } else {
-    setPropValueByPath(vChanges, oRootPath);
+    setOrDeletePropValueByPath(vChanges, oRootPath);
   }
 }
 
@@ -1945,10 +1955,85 @@ var Layer = {
   BASE: "BASE"
 };
 
-function checkChange(oEntityPropertyChange, aSupportedProperties, aSupportedOperations, oSupportedPropertyPattern) {
+function checkObjectProperties(oChangeObject, aObjects, aMandatoryProperties, aSupportedProperties, oSupportedPropertyPattern, oSupportedPropertyTypes) {
+  aObjects.forEach(function (sObject) {
+    const oSetOfProperties = new Set(Object.keys(oChangeObject[sObject]));
+    if (aMandatoryProperties) {
+      aMandatoryProperties.forEach(function (sMandatoryProperty) {
+        if (!oSetOfProperties.has(sMandatoryProperty)) {
+          const sText = aMandatoryProperties.length > 1 ? "properties are" : "property is";
+          throw new Error(`Mandatory property '${sMandatoryProperty}' is missing. Mandatory ${sText} ${aMandatoryProperties.join("|")}.`);
+        }
+      });
+    }
+    if (aSupportedProperties) {
+      const notSupportedProperties = [];
+      oSetOfProperties.forEach(function (sProperty) {
+        if (!aSupportedProperties.includes(sProperty)) {
+          notSupportedProperties.push(sProperty);
+        }
+      });
+      if (notSupportedProperties.length > 0) {
+        const sText1 = notSupportedProperties.length > 1 ? `Properties ${notSupportedProperties.join("|")} are not supported. ` : `Property ${notSupportedProperties.join("|")} is not supported. `;
+        const sText2 = aSupportedProperties.length > 1 ? `Supported properties are ${aSupportedProperties.join("|")}.` : `Supported property is $${aSupportedProperties.join("|")}.`;
+        throw new Error(sText1 + sText2);
+      }
+    }
+    if (oSupportedPropertyTypes) {
+      oSetOfProperties.forEach(function (sProperty) {
+        if (oSupportedPropertyTypes[sProperty]) {
+          if (String(typeof oChangeObject[sObject][sProperty]) !== oSupportedPropertyTypes[sProperty]) {
+            throw new Error(`The property '${sProperty}' is type of '${typeof oChangeObject[sObject][sProperty]}'. Supported type for property '${sProperty}' is '${oSupportedPropertyTypes[sProperty]}'`);
+          }
+        }
+      });
+    }
+    if (oSupportedPropertyPattern) {
+      oSetOfProperties.forEach(function (sProperty) {
+        if (oSupportedPropertyPattern[sProperty]) {
+          const regex = new RegExp(oSupportedPropertyPattern[sProperty]);
+          if (!regex.test(oChangeObject[sObject][sProperty])) {
+            throw new Error(`The property has disallowed values. Supported values for '${sProperty}' should adhere to regular expression ${regex}.`);
+          }
+        }
+      });
+    }
+  });
+}
+function getAndCheckContentObject(oChangeContent, sKey, sChangeType, aMandatoryProperties, aSupportedProperties, oSupportedPropertyPattern, oSupportedPropertyTypes) {
+  const aObjectKeyNames = Object.keys(oChangeContent);
+  if (aObjectKeyNames.length > 1) {
+    throw new Error("It is not allowed to add more than one object under change object 'content'.");
+  }
+  if (aObjectKeyNames.length < 1) {
+    throw new Error(`The change object 'content' cannot be empty. Please provide the necessary property, as outlined in the change schema for '${sChangeType}'.`);
+  }
+  if (aObjectKeyNames[0] !== sKey) {
+    throw new Error(`The provided property '${aObjectKeyNames[0]}' is not supported. Supported property for change '${sChangeType}' is '${sKey}'.`);
+  }
+  const aObjectKeys = Object.keys(oChangeContent[sKey]);
+  if (aObjectKeys.length > 1) {
+    if (sKey === "dataSource") {
+      if (aObjectKeys.length !== 2) {
+        throw new Error(`It is not allowed to add more than two data sources to manifest.`);
+      }
+    } else {
+      throw new Error(`It is not allowed to add more than one ${sKey}: ${aObjectKeys.join(", ")}.`);
+    }
+  }
+  if (aObjectKeys.length < 1) {
+    throw new Error(`There is no ${sKey} provided. Please provide an ${sKey}.`);
+  }
+  if (aObjectKeys.includes("")) {
+    throw new Error(`The ID of your ${sKey} is empty.`);
+  }
+  checkObjectProperties(oChangeContent[sKey], aObjectKeys, aMandatoryProperties, aSupportedProperties, oSupportedPropertyPattern, oSupportedPropertyTypes);
+  return sKey !== "dataSource" ? aObjectKeys[aObjectKeys.length - 1] : aObjectKeys;
+}
+function checkChange(oEntityPropertyChange, aSupportedProperties, aSupportedOperations, oSupportedPropertyPattern, aNotAllowedToBeDeleteProperties, oSupportedPropertyTypes) {
   const aEntityPropertyChanges = Array.isArray(oEntityPropertyChange) ? oEntityPropertyChange : [oEntityPropertyChange];
   aEntityPropertyChanges.forEach(function (oChange) {
-    formatEntityCheck(oChange, aSupportedProperties, aSupportedOperations);
+    formatEntityCheck(oChange, aSupportedProperties, aSupportedOperations, aNotAllowedToBeDeleteProperties, oSupportedPropertyTypes);
     checkPropertyValuePattern(oChange, oSupportedPropertyPattern);
   });
 }
@@ -1966,31 +2051,58 @@ function getClearedGenericPath(aSupportedProperties) {
   return aPropertiesClearedGenericPath;
 }
 function isGenericPropertyPathSupported(aSupportedProperties, sPropertyPath) {
-  var aClearedGenericPath = getClearedGenericPath(aSupportedProperties);
-  return aClearedGenericPath.some(function (path) {
-    return sPropertyPath.startsWith(path);
+  const aClearedGenericPath = getClearedGenericPath(aSupportedProperties);
+  let bIsGenericPathSupported = false;
+  aClearedGenericPath.forEach(function (path) {
+    if (sPropertyPath.startsWith(path)) {
+      const sPathWithoutRoot = sPropertyPath.replace(path, "");
+      if (sPathWithoutRoot.startsWith("/") || sPathWithoutRoot === "") {
+        bIsGenericPathSupported = true;
+      }
+    }
   });
+  return bIsGenericPathSupported;
 }
-function formatEntityCheck(oChangeEntity, aSupportedProperties, aSupportedOperations) {
+function formatEntityCheck(oChangeEntity, aSupportedProperties, aSupportedOperations, aNotAllowedToBeDeleteProperties, oSupportedPropertyTypes) {
   if (!oChangeEntity.propertyPath) {
     throw new Error("Invalid change format: The mandatory 'propertyPath' is not defined. Please define the mandatory property 'propertyPath'");
   }
   if (!oChangeEntity.operation) {
     throw new Error("Invalid change format: The mandatory 'operation' is not defined. Please define the mandatory property 'operation'");
   }
-  if (oChangeEntity.operation.toUpperCase() !== "DELETE") {
+  const sOpertationUpperCase = oChangeEntity.operation.toUpperCase();
+  if (sOpertationUpperCase === "DELETE") {
+    if (aNotAllowedToBeDeleteProperties) {
+      if (aNotAllowedToBeDeleteProperties.includes(oChangeEntity.propertyPath)) {
+        throw new Error(`The property '${oChangeEntity.propertyPath}' was attempted to be deleted. The mandatory properties ${aNotAllowedToBeDeleteProperties.join("|")} cannot be deleted.`);
+      }
+    }
+    if (oChangeEntity.hasOwnProperty("propertyValue")) {
+      throw new Error(`The property 'propertyValue' must not be provided in a 'DELETE' operation. Please remove 'propertyValue'.`);
+    }
+  }
+  if (sOpertationUpperCase !== "DELETE") {
     if (!oChangeEntity.hasOwnProperty("propertyValue")) {
       throw new Error("Invalid change format: The mandatory 'propertyValue' is not defined. Please define the mandatory property 'propertyValue'");
     }
+    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 (oSupportedPropertyTypes) {
+      const aPropertyPath = oChangeEntity.propertyPath.split("/");
+      const sProperty = aPropertyPath[aPropertyPath.length - 1];
+      if (oSupportedPropertyTypes[sProperty]) {
+        if (String(typeof oChangeEntity.propertyValue) !== oSupportedPropertyTypes[sProperty]) {
+          throw new Error(`The property '${sProperty}' is type of '${typeof oChangeEntity.propertyValue}'. Supported type for property '${sProperty}' is '${oSupportedPropertyTypes[sProperty]}'.`);
+        }
+      }
+    }
   }
-  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 (!aSupportedOperations.includes(oChangeEntity.operation)) {
-    throw new Error(`Operation ${oChangeEntity.operation} is not supported. The supported 'operation' is ${aSupportedOperations.join("|")}`);
+  if (!aSupportedOperations.includes(sOpertationUpperCase)) {
+    throw new Error(`Operation ${sOpertationUpperCase} is not supported. The supported 'operation' is ${aSupportedOperations.join("|")}`);
   }
 }
-function checkEntityPropertyChange(oChange, aSupportedProperties, aSupportedOperations, oSupportedPropertyPattern) {
+function checkEntityPropertyChange(oChange, aSupportedProperties, aSupportedOperations, oSupportedPropertyPattern, aNotAllowedToBeDeleteProperties, oSupportedPropertyTypes) {
   var sId = Object.keys(oChange).filter(function (sKey) {
     return sKey.endsWith("Id");
   }).shift();
@@ -2000,7 +2112,7 @@ function checkEntityPropertyChange(oChange, aSupportedProperties, aSupportedOper
   if (!oChange.entityPropertyChange) {
     throw new Error(`Changes for "${oChange[sId]}" are not provided.`);
   }
-  checkChange(oChange.entityPropertyChange, aSupportedProperties, aSupportedOperations, oSupportedPropertyPattern);
+  checkChange(oChange.entityPropertyChange, aSupportedProperties, aSupportedOperations, oSupportedPropertyPattern, aNotAllowedToBeDeleteProperties, oSupportedPropertyTypes);
 }
 var layer_prefixes = {};
 layer_prefixes[Layer.CUSTOMER] = "customer.";
@@ -2031,11 +2143,13 @@ function getNamespacePrefixForLayer(sLayer) {
   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]}`);
+  if (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 = {
@@ -2043,17 +2157,18 @@ var DescriptorChangeCheck = {
   checkIdNamespaceCompliance,
   getNamespacePrefixForLayer,
   getClearedGenericPath,
-  isGenericPropertyPathSupported
+  isGenericPropertyPathSupported,
+  getAndCheckContentObject
 };
 
-var SUPPORTED_OPERATIONS$2 = ["UPDATE", "UPSERT"];
-var SUPPORTED_PROPERTIES$2 = ["uri", "settings/maxAge"];
-var PROPERTIES_PATTERNS$2 = {};
+var SUPPORTED_OPERATIONS$3 = ["UPDATE", "UPSERT"];
+var SUPPORTED_PROPERTIES$6 = ["uri", "settings/maxAge"];
+var PROPERTIES_PATTERNS$5 = {};
 var ChangeDataSource = {
   applyChange(oManifest, oChange) {
     var oDataSources = oManifest["sap.app"].dataSources;
     var oChangeContent = oChange.getContent();
-    DescriptorChangeCheck.checkEntityPropertyChange(oChangeContent, SUPPORTED_PROPERTIES$2, SUPPORTED_OPERATIONS$2, PROPERTIES_PATTERNS$2);
+    DescriptorChangeCheck.checkEntityPropertyChange(oChangeContent, SUPPORTED_PROPERTIES$6, SUPPORTED_OPERATIONS$3, PROPERTIES_PATTERNS$5);
     if (oDataSources) {
       var oDataSource = oDataSources[oChangeContent.dataSourceId];
       if (oDataSource) {
@@ -2141,6 +2256,34 @@ var AddComponentUsages = {
   }
 };
 
+const SUPPORTED_OPERATIONS$2 = ["UPDATE", "UPSERT", "DELETE", "INSERT"];
+const SUPPORTED_PROPERTIES$5 = ["settings/*"];
+const SUPPORTED_TYPES$1 = {
+  settings: typeof ({})
+};
+const RESOURCE_MODEL = "sap.ui.model.resource.ResourceModel";
+const ChangeModel = {
+  applyChange(oManifest, oChange) {
+    const oModels = oManifest["sap.ui5"].models;
+    const oChangeContent = oChange.getContent();
+    DescriptorChangeCheck.checkEntityPropertyChange(oChangeContent, SUPPORTED_PROPERTIES$5, SUPPORTED_OPERATIONS$2, null, null, SUPPORTED_TYPES$1);
+    if (oModels) {
+      const oModel = oModels[oChangeContent.modelId];
+      if (oModel) {
+        if (oModel.type === RESOURCE_MODEL) {
+          throw new Error(`Model '${oChangeContent.modelId}' is of type '${RESOURCE_MODEL}'. Changing models of type '${RESOURCE_MODEL}' are not supported.`);
+        }
+        changePropertyValueByPath(oChangeContent.entityPropertyChange, oModel);
+      } else {
+        throw new Error(`Nothing to update. Model with ID "${oChangeContent.modelId}" does not exist in the manifest.json.`);
+      }
+    } else {
+      throw new Error("sap.ui5/models section have not been found in manifest.json.");
+    }
+    return oManifest;
+  }
+};
+
 var rVersion = /^[0-9]+(?:\.([0-9]+)(?:\.([0-9]+))?)?(.*)$/;
 function Version(vMajor, iMinor, iPatch, sSuffix) {
   if (vMajor instanceof Version) {
@@ -2350,7 +2493,7 @@ var AddNewModel = {
 };
 
 var SUPPORTED_INSERT_POSITION = ["BEGINNING", "END"];
-function isDataSourceIdExistingInManifest(oManifestDataSources, sDataSourceId) {
+function isDataSourceIdExistingInManifest$1(oManifestDataSources, sDataSourceId) {
   return Object.keys(oManifestDataSources).indexOf(sDataSourceId) >= 0;
 }
 function isDataSourceTypeOData(oManifestDataSources, sDataSource) {
@@ -2368,7 +2511,7 @@ function isAnnotationPartOfAnnotationsArray(aChangeAnnotations, sAnnotation) {
 function checkingDataSourceId(oManifestDataSources, sChangeDataSourceId) {
   if (sChangeDataSourceId) {
     if (Object.keys(oManifestDataSources).length > 0) {
-      if (!isDataSourceIdExistingInManifest(oManifestDataSources, sChangeDataSourceId)) {
+      if (!isDataSourceIdExistingInManifest$1(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`);
       }
       if (!isDataSourceTypeOData(oManifestDataSources, sChangeDataSourceId)) {
@@ -2433,7 +2576,7 @@ function mergeAnnotationArray(oManifestDataSourceId, aChangeAnnotations, sChange
 function mergeAnnotationDataSources(oManifestDataSources, oChangeDataSource) {
   Object.assign(oManifestDataSources, oChangeDataSource);
 }
-function postChecks(oManifestDataSources, oChangeDataSource, aChangeAnnotations) {
+function postChecks$1(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)`);
@@ -2450,7 +2593,7 @@ var AddAnnotationsToOData = {
     checkingAnnotationArray(aChangeAnnotations);
     checkingAnnotationsInsertPosition(sChangeAnnotationsInsertPosition);
     checkingAnnotationDataSource(oChangeDataSource, aChangeAnnotations, oChange);
-    postChecks(oManifest["sap.app"].dataSources, oChangeDataSource, aChangeAnnotations);
+    postChecks$1(oManifest["sap.app"].dataSources, oChangeDataSource, aChangeAnnotations);
     merge$1(oManifest["sap.app"].dataSources, sChangeDataSourceId, aChangeAnnotations, sChangeAnnotationsInsertPosition, oChangeDataSource);
     return oManifest;
   }
@@ -2464,7 +2607,7 @@ function checkManifestPath(oManifest) {
     throw new Error("No sap.app/crossNavigation/inbounds path exists in the manifest");
   }
 }
-function getAndCheckInboundId$1(oChangeContent) {
+function getAndCheckInboundId(oChangeContent) {
   var sInbounds = oChangeContent.inboundId;
   if (sInbounds === "") {
     throw new Error("The ID of your inbound is empty");
@@ -2482,7 +2625,7 @@ function merge(oManifest, sInboundId) {
 var RemoveAllInboundsExceptOne = {
   applyChange(oManifest, oChange) {
     checkManifestPath(oManifest);
-    var sInboundId = getAndCheckInboundId$1(oChange.getContent());
+    var sInboundId = getAndCheckInboundId(oChange.getContent());
     if (oManifest["sap.app"].crossNavigation.inbounds[sInboundId]) {
       merge(oManifest, sInboundId);
     } else {
@@ -2492,19 +2635,20 @@ var RemoveAllInboundsExceptOne = {
   }
 };
 
-var SUPPORTED_OPERATIONS$1 = ["UPDATE", "UPSERT"];
-var SUPPORTED_PROPERTIES$1 = ["semanticObject", "action", "title", "subTitle", "icon", "signature/parameters/*"];
-var PROPERTIES_PATTERNS$1 = {
+const SUPPORTED_OPERATIONS$1 = ["UPDATE", "UPSERT", "DELETE", "INSERT"];
+const SUPPORTED_PROPERTIES$4 = ["semanticObject", "action", "hideLauncher", "icon", "title", "shortTitle", "subTitle", "info", "indicatorDataSource", "deviceTypes", "displayMode", "signature/parameters/*"];
+const NOT_ALLOWED_TO_DELETE_PROPERTIES$1 = ["semanticObject", "action"];
+const PROPERTIES_PATTERNS$4 = {
   semanticObject: "^[\\w\\*]{0,30}$",
   action: "^[\\w\\*]{0,60}$"
 };
-var ChangeInbound = {
+const ChangeInbound = {
   applyChange(oManifest, oChange) {
-    var oCrossNavigation = oManifest["sap.app"].crossNavigation;
-    var oChangeContent = oChange.getContent();
-    DescriptorChangeCheck.checkEntityPropertyChange(oChangeContent, SUPPORTED_PROPERTIES$1, SUPPORTED_OPERATIONS$1, PROPERTIES_PATTERNS$1);
+    const oCrossNavigation = oManifest["sap.app"].crossNavigation;
+    const oChangeContent = oChange.getContent();
+    DescriptorChangeCheck.checkEntityPropertyChange(oChangeContent, SUPPORTED_PROPERTIES$4, SUPPORTED_OPERATIONS$1, PROPERTIES_PATTERNS$4, NOT_ALLOWED_TO_DELETE_PROPERTIES$1);
     if (oCrossNavigation && oCrossNavigation.inbounds) {
-      var oInbound = oCrossNavigation.inbounds[oChangeContent.inboundId];
+      const oInbound = oCrossNavigation.inbounds[oChangeContent.inboundId];
       if (oInbound) {
         changePropertyValueByPath(oChangeContent.entityPropertyChange, oInbound);
       } else {
@@ -2517,9 +2661,10 @@ var ChangeInbound = {
   }
 };
 
-const SUPPORTED_OPERATIONS = ["UPDATE", "UPSERT"];
-const SUPPORTED_PROPERTIES = ["semanticObject", "action", "additionalParameters", "parameters/*"];
-const PROPERTIES_PATTERNS = {
+const SUPPORTED_OPERATIONS = ["UPDATE", "UPSERT", "DELETE", "INSERT"];
+const SUPPORTED_PROPERTIES$3 = ["semanticObject", "action", "additionalParameters", "parameters/*"];
+const NOT_ALLOWED_TO_DELETE_PROPERTIES = ["semanticObject", "action"];
+const PROPERTIES_PATTERNS$3 = {
   semanticObject: "^[\\w\\*]{0,30}$",
   action: "^[\\w\\*]{0,60}$",
   additionalParameters: "^(ignored|allowed|notallowed)$"
@@ -2528,7 +2673,7 @@ const ChangeOutbound = {
   applyChange(oManifest, oChange) {
     const oCrossNavigation = oManifest["sap.app"].crossNavigation;
     const oChangeContent = oChange.getContent();
-    DescriptorChangeCheck.checkEntityPropertyChange(oChangeContent, SUPPORTED_PROPERTIES, SUPPORTED_OPERATIONS, PROPERTIES_PATTERNS);
+    DescriptorChangeCheck.checkEntityPropertyChange(oChangeContent, SUPPORTED_PROPERTIES$3, SUPPORTED_OPERATIONS, PROPERTIES_PATTERNS$3, NOT_ALLOWED_TO_DELETE_PROPERTIES);
     if (oCrossNavigation && oCrossNavigation.outbounds) {
       const oOutbound = oCrossNavigation.outbounds[oChangeContent.outboundId];
       if (oOutbound) {
@@ -2543,26 +2688,19 @@ const ChangeOutbound = {
   }
 };
 
-function getAndCheckInboundId(oChangeContent) {
-  var aInbounds = Object.keys(oChangeContent.inbound);
-  if (aInbounds.length > 1) {
-    throw new Error("It is not allowed to add more than one inbound");
-  }
-  if (aInbounds.length < 1) {
-    throw new Error("Inbound does not exist");
-  }
-  if (aInbounds[0] === "") {
-    throw new Error("The ID of your inbound is empty");
-  }
-  return aInbounds[aInbounds.length - 1];
-}
-var AddNewInbound = {
+const MANDATORY_PROPERTIES$2 = ["semanticObject", "action"];
+const SUPPORTED_PROPERTIES$2 = [...MANDATORY_PROPERTIES$2, "hideLauncher", "icon", "title", "shortTitle", "subTitle", "info", "indicatorDataSource", "deviceTypes", "displayMode", "signature"];
+const PROPERTIES_PATTERNS$2 = {
+  semanticObject: "^[\\w\\*]{0,30}$",
+  action: "^[\\w\\*]{0,60}$"
+};
+const AddNewInbound = {
   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];
+    const oChangeContent = oChange.getContent();
+    const sInboundId = DescriptorChangeCheck.getAndCheckContentObject(oChangeContent, "inbound", oChange.getChangeType(), MANDATORY_PROPERTIES$2, SUPPORTED_PROPERTIES$2, PROPERTIES_PATTERNS$2);
+    const oInboundInManifest = oManifest["sap.app"].crossNavigation.inbounds[sInboundId];
     if (!oInboundInManifest) {
       DescriptorChangeCheck.checkIdNamespaceCompliance(sInboundId, oChange);
       oManifest["sap.app"].crossNavigation.inbounds[sInboundId] = oChangeContent.inbound[sInboundId];
@@ -2573,6 +2711,119 @@ var AddNewInbound = {
   }
 };
 
+const MANDATORY_PROPERTIES$1 = ["semanticObject", "action"];
+const SUPPORTED_PROPERTIES$1 = [...MANDATORY_PROPERTIES$1, "additionalParameters", "parameters"];
+const PROPERTIES_PATTERNS$1 = {
+  semanticObject: "^[\\w\\*]{0,30}$",
+  action: "^[\\w\\*]{0,60}$",
+  additionalParameters: "^(ignored|allowed|notallowed)$"
+};
+const AddNewOutbound = {
+  applyChange(oManifest, oChange) {
+    oManifest["sap.app"].crossNavigation ||= {};
+    oManifest["sap.app"].crossNavigation.outbounds ||= {};
+    const oChangeContent = oChange.getContent();
+    const sOutboundId = DescriptorChangeCheck.getAndCheckContentObject(oChangeContent, "outbound", oChange.getChangeType(), MANDATORY_PROPERTIES$1, SUPPORTED_PROPERTIES$1, PROPERTIES_PATTERNS$1);
+    const oOutboundInManifest = oManifest["sap.app"].crossNavigation.outbounds[sOutboundId];
+    if (!oOutboundInManifest) {
+      DescriptorChangeCheck.checkIdNamespaceCompliance(sOutboundId, oChange);
+      oManifest["sap.app"].crossNavigation.outbounds[sOutboundId] = oChangeContent.outbound[sOutboundId];
+    } else {
+      throw new Error(`Outbound with ID "${sOutboundId}" already exist.`);
+    }
+    return oManifest;
+  }
+};
+
+const MANDATORY_PROPERTIES = ["uri"];
+const SUPPORTED_PROPERTIES = [...MANDATORY_PROPERTIES, "type", "settings", "customType"];
+const PROPERTIES_PATTERNS = {
+  type: "^(OData|ODataAnnotation|INA|XML|JSON|FHIR|WebSocket|http)$",
+  customType: "^false$"
+};
+const SUPPORTED_TYPES = {
+  uri: typeof "string",
+  type: typeof "string",
+  settings: typeof ({}),
+  dataSourceCustom: typeof false,
+  annotations: typeof []
+};
+function isDataSourceIdExistingInManifest(oManifestDataSources, sDataSourceId) {
+  return Object.keys(oManifestDataSources).includes(sDataSourceId);
+}
+function getDataSourceType(oDataSource) {
+  return oDataSource.type || "OData";
+}
+function getDataSourceNameByType(oChangeDataSource, sType) {
+  const [sDataSourceName] = Object.entries(oChangeDataSource).find(([, oDataSource]) => getDataSourceType(oDataSource) === sType) || [];
+  return sDataSourceName;
+}
+function checkDefinedAnnotationsExistInManifest(oManifestDataSources, sDataSourceOfTypeOData, aToBeCheckedInManifestAnnotations) {
+  aToBeCheckedInManifestAnnotations.forEach(function (sAnnotation) {
+    if (!isDataSourceIdExistingInManifest(oManifestDataSources, sAnnotation)) {
+      throw new Error(`Referenced annotation '${sAnnotation}' in the annotation array of data source '${sDataSourceOfTypeOData}' does not exist in the manifest.`);
+    }
+  });
+}
+function checksWhenAddingTwoDataSources(oManifestDataSources, oChangeDataSource) {
+  const sDataSourceOfTypeOData = getDataSourceNameByType(oChangeDataSource, "OData");
+  const sDataSourceOfTypeODataAnnotation = getDataSourceNameByType(oChangeDataSource, "ODataAnnotation");
+  if (!(sDataSourceOfTypeOData && sDataSourceOfTypeODataAnnotation)) {
+    throw new Error(`When adding two data sources it is only allwoed to add a data source with type 'OData' and the other one must be of type 'ODataAnnotation'.`);
+  }
+  if (!oChangeDataSource[sDataSourceOfTypeOData]?.settings?.annotations?.includes(sDataSourceOfTypeODataAnnotation)) {
+    throw new Error(`Data source '${sDataSourceOfTypeOData}' does not include annotation '${sDataSourceOfTypeODataAnnotation}' under 'settings/annotations' array.`);
+  }
+  const aToBeCheckedInManifestAnnotations = oChangeDataSource[sDataSourceOfTypeOData].settings.annotations.filter(function (sAnnotation) {
+    return sAnnotation !== sDataSourceOfTypeODataAnnotation;
+  });
+  checkDefinedAnnotationsExistInManifest(oManifestDataSources, sDataSourceOfTypeOData, aToBeCheckedInManifestAnnotations);
+}
+function checksWhenAddingOneDataSource(oManifestDataSources, oChangeDataSource) {
+  const sDataSourceOfTypeOData = getDataSourceNameByType(oChangeDataSource, "OData");
+  if (oChangeDataSource[sDataSourceOfTypeOData].settings?.annotations) {
+    checkDefinedAnnotationsExistInManifest(oManifestDataSources, sDataSourceOfTypeOData, oChangeDataSource[sDataSourceOfTypeOData].settings.annotations);
+  }
+}
+function postChecks(oManifestDataSources, oChangeDataSource, aDataSources) {
+  aDataSources.forEach(function (sDataSource) {
+    if (isDataSourceIdExistingInManifest(oManifestDataSources, sDataSource)) {
+      throw new Error(`There is already a dataSource '${sDataSource}' existing in the manifest.`);
+    }
+    checkIfAnnotationsPropertyIsAnArray(oChangeDataSource, sDataSource);
+  });
+  if (aDataSources.length === 1) {
+    checksWhenAddingOneDataSource(oManifestDataSources, oChangeDataSource);
+  }
+  if (aDataSources.length === 2) {
+    checksWhenAddingTwoDataSources(oManifestDataSources, oChangeDataSource);
+  }
+}
+function checkIfAnnotationsPropertyIsAnArray(oChangeDataSource, sDataSource) {
+  const sDataSourceType = getDataSourceType(oChangeDataSource[sDataSource]);
+  if (oChangeDataSource[sDataSource].settings?.annotations) {
+    if (sDataSourceType !== "OData") {
+      throw new Error(`Data source '${sDataSource}' which is of type '${sDataSourceType}' contains the annotations array. Only data sources with type 'OData' could contain the 'settings/annotations' array.`);
+    }
+    if (!Array.isArray(oChangeDataSource[sDataSource].settings.annotations)) {
+      throw new Error(`Property 'annotations' must be of type 'array'.`);
+    }
+  }
+}
+const AddNewDataSource = {
+  applyChange(oManifest, oChange) {
+    oManifest["sap.app"].dataSources ||= {};
+    const oChangeContent = oChange.getContent();
+    const aDataSources = DescriptorChangeCheck.getAndCheckContentObject(oChangeContent, "dataSource", oChange.getChangeType(), MANDATORY_PROPERTIES, SUPPORTED_PROPERTIES, PROPERTIES_PATTERNS, SUPPORTED_TYPES);
+    aDataSources.forEach(function (sDataSource) {
+      DescriptorChangeCheck.checkIdNamespaceCompliance(sDataSource, oChange);
+    });
+    postChecks(oManifest["sap.app"].dataSources, oChangeContent.dataSource, aDataSources);
+    Object.assign(oManifest["sap.app"].dataSources, oChangeContent.dataSource);
+    return oManifest;
+  }
+};
+
 const regex$1 = new RegExp("^([a-zA-Z0-9]{2,3})(-[a-zA-Z0-9]{1,6})*$");
 const SetAch = {
   applyChange(oManifest, oChange) {
@@ -3379,6 +3630,7 @@ var FeLogger = BaseObject.extend("sap.suite.ui.generic.template.genericUtilities
 });
 
 var oLogger$2 = new FeLogger("manifestMerger.MergerUil").getLogger();
+var GLOBAL_MANIFEST_CHANGE_COMPONENT$1 = "sap.suite.ui.generic.template";
 var mergerUtil = {
   iterateAndFind: function iterateFind(oPages, sEntityKey, sPageComponent, sChildPageId, sParentKey) {
     var oPageStructure;
@@ -3421,12 +3673,12 @@ var mergerUtil = {
     if (!oChangeContent["parentPage"]) {
       throw new Error("Mandatory 'parentPage' parameter is not provided.");
     }
-    if (!oChangeContent.parentPage.entitySet) {
-      throw new Error("Mandatory 'parentPage.entitySet' parameter is not provided.");
-    }
     if (!oChangeContent.parentPage.component) {
       throw new Error("Mandatory 'parentPage.component' parameter is not provided.");
     }
+    if (!oChangeContent.parentPage.entitySet && oChangeContent.parentPage.component !== GLOBAL_MANIFEST_CHANGE_COMPONENT$1) {
+      throw new Error("Mandatory 'parentPage.entitySet' parameter is not provided.");
+    }
     if (sMergerType === "ADD") {
       if (!oChangeContent.childPage.id) {
         throw new Error(" Add mandatory parameter 'childPage.id' ");
@@ -3457,7 +3709,7 @@ var mergerUtil = {
         if (!oEntityPropertyChange.operation || oEntityPropertyChange.operation !== "UPSERT") {
           throw new Error("Invalid change format: The mandatory 'operation' is not defined or is not valid type. Please define the mandatory property 'operation' with type 'UPSERT");
         }
-        if (!oEntityPropertyChange.propertyValue) {
+        if (oEntityPropertyChange.propertyValue === undefined) {
           throw new Error("Invalid change format: The mandatory 'propertyValue' is not defined. Please define the mandatory property 'propertyValue'");
         }
       }
@@ -3497,6 +3749,7 @@ var addNewObjectPage = {
 };
 
 var oLogger = new FeLogger("manifestMerger.ChangePageConfiguration").getLogger();
+var GLOBAL_MANIFEST_CHANGE_COMPONENT = "sap.suite.ui.generic.template";
 var changePageConfiguration = {
   applyChange: function (oManifest, oChange) {
     oLogger.info("modifyPageConfiguration use case");
@@ -3504,27 +3757,37 @@ var changePageConfiguration = {
     mergerUtil.consistencyCheck(oChangeContent, "MODIFY");
     var sParentEntitySet = oChangeContent.parentPage.entitySet;
     var sParentComponent = oChangeContent.parentPage.component;
-    var oPageStructure = mergerUtil.iterateAndFind(oManifest["sap.ui.generic.app"], sParentEntitySet, sParentComponent);
+    var oPageStructure;
+    if (sParentComponent === GLOBAL_MANIFEST_CHANGE_COMPONENT) {
+      oPageStructure = oManifest["sap.ui.generic.app"];
+    } else {
+      oPageStructure = mergerUtil.iterateAndFind(oManifest["sap.ui.generic.app"], sParentEntitySet, sParentComponent);
+    }
     var oPropertyChange = oChangeContent.entityPropertyChange;
-    var aPropertyKeys = Object.keys(oPropertyChange.propertyValue);
-    aPropertyKeys.forEach(function (sCurrentKey) {
+    if (typeof oPropertyChange.propertyValue !== "object" || oPropertyChange.propertyValue === null) {
       var aPropertyPath = oPropertyChange.propertyPath.split("/");
-      aPropertyPath.push(sCurrentKey);
-      var vVal = ObjectPath.get(aPropertyPath, oPageStructure);
-      if (vVal && typeof vVal === "object") {
-        var oPropertyPathContent = ObjectPath.create(aPropertyPath, oPageStructure);
-        Object.assign(oPropertyPathContent, oPropertyChange.propertyValue[sCurrentKey]);
-      } else {
-        ObjectPath.set(aPropertyPath, oPropertyChange.propertyValue[sCurrentKey], oPageStructure);
-      }
-    });
+      ObjectPath.set(aPropertyPath, oPropertyChange.propertyValue, oPageStructure);
+    } else {
+      var aPropertyKeys = Object.keys(oPropertyChange.propertyValue);
+      aPropertyKeys.forEach(function (sCurrentKey) {
+        var aPropertyPath = oPropertyChange.propertyPath.split("/");
+        aPropertyPath.push(sCurrentKey);
+        var vVal = ObjectPath.get(aPropertyPath, oPageStructure);
+        if (vVal && typeof vVal === "object") {
+          var oPropertyPathContent = ObjectPath.create(aPropertyPath, oPageStructure);
+          Object.assign(oPropertyPathContent, oPropertyChange.propertyValue[sCurrentKey]);
+        } else {
+          ObjectPath.set(aPropertyPath, oPropertyChange.propertyValue[sCurrentKey], oPageStructure);
+        }
+      });
+    }
     return oManifest;
   }
 };
 
-var _exports = {};
+var _exports$1 = {};
 let pageConfigurationChanges = {};
-function applyChange(manifest, change) {
+function applyChange$1(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;
@@ -3532,21 +3795,21 @@ function applyChange(manifest, change) {
     Log.error("Change content is not a valid");
     return manifest;
   }
-  return changeConfiguration(manifest, pageId, propertyChange.propertyPath, propertyChange.propertyValue);
+  return changeConfiguration$1(manifest, pageId, propertyChange.propertyPath, propertyChange.propertyValue);
 }
-_exports.applyChange = applyChange;
-function changeConfiguration(manifest, pageId, path, value, lateChange) {
+_exports$1.applyChange = applyChange$1;
+function changeConfiguration$1(manifest, pageId, path, value, lateChange) {
   const pageSAPfe = "sap.fe";
-  let propertyPath;
+  let propertyPath = retrievePropertyPath(path);
   let pageSettings;
   if (pageId === pageSAPfe) {
-    propertyPath = [pageSAPfe, path];
+    propertyPath = [pageSAPfe, ...propertyPath];
     pageSettings = manifest;
   } else {
     pageSettings = getPageSettings(manifest, pageId);
-    propertyPath = retrievePropertyPath(path);
   }
   if (pageSettings) {
+    manageSpecificFormat(propertyPath, pageSettings);
     ObjectPath.set(propertyPath, value, pageSettings);
     if (lateChange) {
       pageConfigurationChanges[pageId] = pageConfigurationChanges[pageId] || [];
@@ -3557,7 +3820,16 @@ function changeConfiguration(manifest, pageId, path, value, lateChange) {
   }
   return manifest;
 }
-_exports.changeConfiguration = changeConfiguration;
+_exports$1.changeConfiguration = changeConfiguration$1;
+function manageSpecificFormat(propertyPath, pageSettings) {
+  if (propertyPath.length > 1) {
+    for (let i = 0; i < propertyPath.length - 1; i++) {
+      if (typeof ObjectPath.get(propertyPath.slice(0, i + 1), pageSettings) !== "object") {
+        ObjectPath.set(propertyPath.slice(0, i + 1), {}, pageSettings);
+      }
+    }
+  }
+}
 function retrievePropertyPath(path) {
   let propertyPath = path.split("/");
   if (propertyPath[0] === "controlConfiguration") {
@@ -3595,11 +3867,85 @@ function applyPageConfigurationChanges(manifest, viewData, appComponent, pageId)
   }
   return viewData;
 }
-_exports.applyPageConfigurationChanges = applyPageConfigurationChanges;
+_exports$1.applyPageConfigurationChanges = applyPageConfigurationChanges;
 function cleanPageConfigurationChanges() {
   pageConfigurationChanges = {};
 }
-_exports.cleanPageConfigurationChanges = cleanPageConfigurationChanges;
+_exports$1.cleanPageConfigurationChanges = cleanPageConfigurationChanges;
+
+var _exports = {};
+function applyChange(manifest, change) {
+  const changeContent = change.getContent();
+  const sourcePage = changeContent === null || changeContent === void 0 ? void 0 : changeContent.sourcePage;
+  const targetPage = changeContent === null || changeContent === void 0 ? void 0 : changeContent.targetPage;
+  if (!(sourcePage !== null && sourcePage !== void 0 && sourcePage.id) || !(targetPage !== null && targetPage !== void 0 && targetPage.id)) {
+    Log.error("Change content is not valid, missing source or target page ID.");
+    return manifest;
+  }
+  return changeConfiguration(manifest, sourcePage, targetPage);
+}
+_exports.applyChange = applyChange;
+function changeConfiguration(manifest, sourcePage, targetPage) {
+  var _manifest$sapUi, _manifest$sapUi$routi, _manifest$sapUi2, _manifest$sapUi2$rout, _sourcePageTarget$opt, _sourcePageTarget$opt2;
+  if (!validateChange(manifest, sourcePage, targetPage)) {
+    return manifest;
+  }
+  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) ?? ({});
+  targets[targetPage.id] = {
+    type: targetPage.type,
+    name: targetPage.name,
+    options: {
+      settings: targetPage.settings
+    },
+    id: targetPage.id
+  };
+  const routes = ((_manifest$sapUi2 = manifest["sap.ui5"]) === null || _manifest$sapUi2 === void 0 ? void 0 : (_manifest$sapUi2$rout = _manifest$sapUi2.routing) === null || _manifest$sapUi2$rout === void 0 ? void 0 : _manifest$sapUi2$rout.routes) ?? [];
+  routes.push({
+    pattern: targetPage.routePattern,
+    name: targetPage.id,
+    target: targetPage.id
+  });
+  const sourcePageTarget = targets[sourcePage.id];
+  const sourcePageNavigation = ((_sourcePageTarget$opt = sourcePageTarget.options) === null || _sourcePageTarget$opt === void 0 ? void 0 : (_sourcePageTarget$opt2 = _sourcePageTarget$opt.settings) === null || _sourcePageTarget$opt2 === void 0 ? void 0 : _sourcePageTarget$opt2.navigation) ?? ({});
+  sourcePageTarget.options.settings.navigation = {
+    ...sourcePageNavigation,
+    [sourcePage.navigationSource]: {
+      detail: {
+        route: targetPage.id
+      }
+    }
+  };
+  ObjectPath.set(["sap.ui5", "routing", "targets"], targets, manifest);
+  ObjectPath.set(["sap.ui5", "routing", "routes"], routes, manifest);
+  return manifest;
+}
+function validateChange(manifest, sourcePage, targetPage) {
+  var _manifest$sapUi3, _manifest$sapUi3$rout, _manifest$sapUi4, _manifest$sapUi4$rout;
+  const targets = ((_manifest$sapUi3 = manifest["sap.ui5"]) === null || _manifest$sapUi3 === void 0 ? void 0 : (_manifest$sapUi3$rout = _manifest$sapUi3.routing) === null || _manifest$sapUi3$rout === void 0 ? void 0 : _manifest$sapUi3$rout.targets) ?? ({});
+  if (targets[targetPage.id]) {
+    Log.error("Target page or route Id already exists in the manifest please check the target page Id in the manifest.");
+    return false;
+  }
+  if (!targets[sourcePage.id]) {
+    Log.error("Source page does not exist in the manifest targets please check the source page Id in the manifest.");
+    return false;
+  }
+  if (!targets[sourcePage.id].name.startsWith("sap.fe")) {
+    Log.error("Source page is not a Fiori elements application please check the source page name in the manifest.");
+    return false;
+  }
+  if (targets[sourcePage.id].options.settings.navigation && targets[sourcePage.id].options.settings.navigation[sourcePage.navigationSource]) {
+    Log.error("Source page already has target navigation please check the source page navigation in the manifest.");
+    return false;
+  }
+  const routes = ((_manifest$sapUi4 = manifest["sap.ui5"]) === null || _manifest$sapUi4 === void 0 ? void 0 : (_manifest$sapUi4$rout = _manifest$sapUi4.routing) === null || _manifest$sapUi4$rout === void 0 ? void 0 : _manifest$sapUi4$rout.routes) ?? [];
+  const sourcePageExists = routes.some(route => route.name === sourcePage.id);
+  if (!sourcePageExists) {
+    Log.error("Source page does not exist in the manifest routes please check the source page name in the manifest.");
+    return false;
+  }
+  return true;
+}
 
 var Registration = {
   appdescr_ui5_addLibraries: () => Promise.resolve(AddLibrary),
@@ -3610,13 +3956,15 @@ 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(_exports)
+  appdescr_fe_changePageConfiguration: () => Promise.resolve(_exports$1),
+  appdescr_fe_addNewPage: () => Promise.resolve(_exports)
 };
 
-var RegistrationBuild = {
+const RegistrationBuild = {
   appdescr_app_changeDataSource: () => Promise.resolve(ChangeDataSource),
   appdescr_ui5_addNewModelEnhanceWith: () => Promise.resolve(AddNewModelEnhanceWith),
   appdescr_ui5_addComponentUsages: () => Promise.resolve(AddComponentUsages),
+  appdescr_ui5_changeModel: () => Promise.resolve(ChangeModel),
   appdescr_ui5_setMinUI5Version: () => Promise.resolve(SetMinUI5Version),
   appdescr_fiori_setRegistrationIds: () => Promise.resolve(SetRegistrationIds),
   appdescr_ui5_setFlexExtensionPointEnabled: () => Promise.resolve(SetFlexExtensionPointEnabled),
@@ -3626,13 +3974,506 @@ var RegistrationBuild = {
   appdescr_app_changeInbound: () => Promise.resolve(ChangeInbound),
   appdescr_app_changeOutbound: () => Promise.resolve(ChangeOutbound),
   appdescr_app_addNewInbound: () => Promise.resolve(AddNewInbound),
+  appdescr_app_addNewOutbound: () => Promise.resolve(AddNewOutbound),
+  appdescr_app_addNewDataSource: () => Promise.resolve(AddNewDataSource),
   appdescr_app_setAch: () => Promise.resolve(SetAch),
   appdescr_app_addTechnicalAttributes: () => Promise.resolve(AddTechnicalAttributes),
   appdescr_fiori_setAbstract: () => Promise.resolve(SetAbstract),
   appdescr_fiori_setCloudDevAdaptationStatus: () => Promise.resolve(SetCloudDevAdaptationStatus)
 };
-var RegistrationCopy = Object.assign({}, Registration);
-var RegistrationBuild$1 = Object.assign(RegistrationCopy, RegistrationBuild);
+var RegistrationBuild$1 = {
+  ...Registration,
+  ...RegistrationBuild
+};
+
+var sDelimiters = "[=(),; \t\"']|%(09|20|22|27|28|29|2c|2C|3b|3B)", sSystemQueryOption = "\\$\\w+", sODataIdentifier = "[a-zA-Z_\\u0080-\\uFFFF][\\w\\u0080-\\uFFFF]*", sWhitespace = "(?:[ \\t]|%09|%20)", rRws = new RegExp(sWhitespace + "+", "g"), rNot = new RegExp("^not" + sWhitespace + "+"), sOperators = "(" + sWhitespace + "+)(and|eq|ge|gt|le|lt|ne|or)" + sWhitespace + "+", sGuid = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}", sStar = "(?:\\*|%2[aA])", sNamedPath = sODataIdentifier + "(?:[./]" + sODataIdentifier + ")*" + "(?:[./]" + sStar + "|/\\$ref|/\\$count)?", sStarPath = sStar + "(?:/\\$ref)?", sPathExpression = sNamedPath + "|" + sStarPath, sValueExpression = "(?:[-+:./\\w\"]|%2[bB]|%3[aA])+", rToken = new RegExp("^(?:" + sOperators + "|" + sDelimiters + "|(" + sGuid + ")|(" + sPathExpression + ")|(" + sValueExpression + ")|(" + sSystemQueryOption + "))"), rEscapeDigits = /^[0-9a-f]{2}$/i, mFunctions = {
+  ceiling: {
+    ambiguousParameters: true
+  },
+  concat: {
+    type: "Edm.String"
+  },
+  contains: {
+    type: "Edm.Boolean"
+  },
+  day: {
+    type: "Edm.Int32",
+    ambiguousParameters: true
+  },
+  endswith: {
+    type: "Edm.Boolean"
+  },
+  floor: {
+    ambiguousParameters: true
+  },
+  hour: {
+    type: "Edm.Int32",
+    ambiguousParameters: true
+  },
+  indexof: {
+    type: "Edm.Int32"
+  },
+  length: {
+    type: "Edm.Int32"
+  },
+  minute: {
+    type: "Edm.Int32",
+    ambiguousParameters: true
+  },
+  month: {
+    type: "Edm.Int32",
+    ambiguousParameters: true
+  },
+  round: {
+    ambiguousParameters: true
+  },
+  second: {
+    type: "Edm.Int32",
+    ambiguousParameters: true
+  },
+  startswith: {
+    type: "Edm.Boolean"
+  },
+  substring: {
+    type: "Edm.String"
+  },
+  tolower: {
+    type: "Edm.String"
+  },
+  toupper: {
+    type: "Edm.String"
+  },
+  trim: {
+    type: "Edm.String"
+  },
+  year: {
+    type: "Edm.Int32",
+    ambiguousParameters: true
+  }
+}, mFilterParserSymbols = {
+  "(": {
+    lbp: 9,
+    led: function (oToken, oLeft) {
+      var oFunction, oParameter;
+      if (oLeft.id !== "PATH") {
+        this.error("Unexpected ", oToken);
+      }
+      oFunction = mFunctions[oLeft.value];
+      if (!oFunction) {
+        this.error("Unknown function ", oLeft);
+      }
+      oLeft.id = "FUNCTION";
+      if (oFunction.type) {
+        oLeft.type = oFunction.type;
+      }
+      oLeft.parameters = [];
+      do {
+        this.advanceBws();
+        oParameter = this.expression(0);
+        if (oFunction.ambiguousParameters) {
+          oParameter.ambiguous = true;
+        }
+        oLeft.parameters.push(oParameter);
+        this.advanceBws();
+      } while (this.advanceIf(","));
+      this.advanceBws();
+      this.advance(")");
+      return oLeft;
+    },
+    nud: function () {
+      var oToken;
+      this.advanceBws();
+      oToken = this.expression(0);
+      this.advanceBws();
+      this.advance(")");
+      return oToken;
+    }
+  },
+  not: {
+    lbp: 7,
+    nud: function (oToken) {
+      oToken.precedence = 7;
+      oToken.right = this.expression(7);
+      oToken.type = "Edm.Boolean";
+      return oToken;
+    }
+  }
+};
+function addInfixOperator(sId, iLbp) {
+  mFilterParserSymbols[sId] = {
+    lbp: iLbp,
+    led: function (oToken, oLeft) {
+      oToken.type = "Edm.Boolean";
+      oToken.precedence = iLbp;
+      oToken.left = oLeft;
+      oToken.right = this.expression(iLbp);
+      return oToken;
+    }
+  };
+}
+function addLeafSymbol(sId) {
+  mFilterParserSymbols[sId] = {
+    lbp: 0,
+    nud: function (oToken) {
+      oToken.precedence = 99;
+      return oToken;
+    }
+  };
+}
+addInfixOperator("and", 2);
+addInfixOperator("eq", 3);
+addInfixOperator("ge", 4);
+addInfixOperator("gt", 4);
+addInfixOperator("le", 4);
+addInfixOperator("lt", 4);
+addInfixOperator("ne", 3);
+addInfixOperator("or", 1);
+addLeafSymbol("PATH");
+addLeafSymbol("VALUE");
+function _Parser() {}
+_Parser.prototype.advance = function (sExpectedTokenId) {
+  var oToken = this.current();
+  if (sExpectedTokenId && (!oToken || oToken.id !== sExpectedTokenId)) {
+    if (sExpectedTokenId === "OPTION") {
+      sExpectedTokenId = "system query option";
+    } else if (sExpectedTokenId.length === 1) {
+      sExpectedTokenId = "'" + sExpectedTokenId + "'";
+    }
+    this.expected(sExpectedTokenId, oToken);
+  }
+  this.iCurrentToken += 1;
+  return oToken;
+};
+_Parser.prototype.advanceIf = function (sExpectedTokenId) {
+  var oToken = this.current();
+  if (oToken && oToken.id === sExpectedTokenId) {
+    this.iCurrentToken += 1;
+    return true;
+  }
+  return false;
+};
+_Parser.prototype.current = function () {
+  return this.aTokens[this.iCurrentToken];
+};
+_Parser.prototype.error = function (sMessage, oToken) {
+  var sValue;
+  if (oToken) {
+    sValue = oToken.value;
+    sMessage += "'" + (sValue === " " ? sValue : sValue.replace(rRws, "")) + "' at " + oToken.at;
+  } else {
+    sMessage += "end of input";
+  }
+  throw new SyntaxError(sMessage + ": " + this.sText);
+};
+_Parser.prototype.expected = function (sWhat, oToken) {
+  this.error("Expected " + sWhat + " but instead saw ", oToken);
+};
+_Parser.prototype.finish = function () {
+  if (this.iCurrentToken < this.aTokens.length) {
+    this.expected("end of input", this.aTokens[this.iCurrentToken]);
+  }
+};
+_Parser.prototype.init = function (sText) {
+  this.sText = sText;
+  this.aTokens = tokenize(sText);
+  this.iCurrentToken = 0;
+};
+function _FilterParser() {
+  _Parser.apply(this, arguments);
+}
+_FilterParser.prototype = Object.create(_Parser.prototype);
+_FilterParser.prototype.advanceBws = function () {
+  var oToken;
+  for (; ; ) {
+    oToken = this.current();
+    if (!oToken || oToken.id !== " " && oToken.id !== "\t") {
+      return;
+    }
+    this.advance();
+  }
+};
+_FilterParser.prototype.expression = function (iRbp) {
+  var fnLeft, oLeft, oToken;
+  oToken = this.advance();
+  if (!oToken) {
+    this.expected("expression");
+  }
+  fnLeft = this.getSymbolValue(oToken, "nud");
+  if (!fnLeft) {
+    this.expected("expression", oToken);
+  }
+  oLeft = fnLeft.call(this, oToken);
+  oToken = this.current();
+  while (oToken && this.getSymbolValue(oToken, "lbp", 0) > iRbp) {
+    oLeft = this.getSymbolValue(oToken, "led").call(this, this.advance(), oLeft);
+    oToken = this.current();
+  }
+  return oLeft;
+};
+_FilterParser.prototype.getSymbolValue = function (oToken, sWhat, vDefault) {
+  var oSymbol = mFilterParserSymbols[oToken.id];
+  return oSymbol && (sWhat in oSymbol) ? oSymbol[sWhat] : vDefault;
+};
+_FilterParser.prototype.parse = function (sFilter) {
+  var oResult;
+  this.init(sFilter);
+  oResult = this.expression(0);
+  this.finish();
+  return oResult;
+};
+function _KeyPredicateParser() {
+  _Parser.apply(this, arguments);
+}
+_KeyPredicateParser.prototype = Object.create(_Parser.prototype);
+_KeyPredicateParser.prototype.parse = function (sKeyPredicate) {
+  var sKey, oKeyProperties = {}, sValue;
+  this.init(sKeyPredicate);
+  this.advance("(");
+  if (this.current().id === "VALUE") {
+    oKeyProperties[""] = this.advance().value;
+  } else {
+    do {
+      sKey = this.advance("PATH").value;
+      this.advance("=");
+      sValue = this.advance("VALUE").value;
+      oKeyProperties[sKey] = sValue;
+    } while (this.advanceIf(","));
+  }
+  this.advance(")");
+  this.finish();
+  return oKeyProperties;
+};
+function _SystemQueryOptionParser() {
+  _Parser.apply(this, arguments);
+}
+_SystemQueryOptionParser.prototype = Object.create(_Parser.prototype);
+_SystemQueryOptionParser.prototype.parse = function (sOption) {
+  var oResult;
+  this.init(sOption);
+  oResult = this.parseSystemQueryOption();
+  this.finish();
+  return oResult;
+};
+_SystemQueryOptionParser.prototype.parseAnythingWithBrackets = function (oStartToken) {
+  var sValue = "", oResult = {}, oToken, that = this;
+  function brackets() {
+    for (; ; ) {
+      oToken = that.advance();
+      if (!oToken || oToken.id === ";") {
+        that.expected("')'", oToken);
+      }
+      sValue += oToken.value;
+      if (oToken.id === ")") {
+        return;
+      }
+      if (oToken.id === "(") {
+        brackets();
+      }
+    }
+  }
+  this.advance("=");
+  for (; ; ) {
+    oToken = this.current();
+    if (!oToken || oToken.id === ")" || oToken.id === ";") {
+      break;
+    }
+    sValue += this.advance().value;
+    if (oToken.id === "(") {
+      brackets();
+    }
+  }
+  if (!sValue) {
+    this.expected("an option value", oToken);
+  }
+  oResult[oStartToken.value] = sValue;
+  return oResult;
+};
+_SystemQueryOptionParser.prototype.parseExpand = function () {
+  var oExpand = {}, sExpandPath, oQueryOption, sQueryOptionName, vValue;
+  this.advance("=");
+  do {
+    vValue = null;
+    sExpandPath = this.advance("PATH").value.replace(/%2a/i, "*");
+    if (this.advanceIf("(")) {
+      vValue = {};
+      do {
+        oQueryOption = this.parseSystemQueryOption();
+        sQueryOptionName = Object.keys(oQueryOption)[0];
+        vValue[sQueryOptionName] = oQueryOption[sQueryOptionName];
+      } while (this.advanceIf(";"));
+      this.advance(")");
+    }
+    oExpand[sExpandPath] = vValue;
+  } while (this.advanceIf(","));
+  return {
+    $expand: oExpand
+  };
+};
+_SystemQueryOptionParser.prototype.parseSelect = function () {
+  var sPath, sPrefix, aSelect = [], oToken;
+  this.advance("=");
+  do {
+    oToken = this.advance("PATH");
+    sPath = oToken.value.replace(/%2a/i, "*");
+    if (this.advanceIf("(")) {
+      sPrefix = "(";
+      do {
+        sPath += sPrefix + this.advance("PATH").value;
+        sPrefix = ",";
+      } while (this.advanceIf(","));
+      sPath += this.advance(")").value;
+    }
+    aSelect.push(sPath);
+  } while (this.advanceIf(","));
+  return {
+    $select: aSelect
+  };
+};
+_SystemQueryOptionParser.prototype.parseSystemQueryOption = function () {
+  var oToken = this.advance("OPTION");
+  switch (oToken.value) {
+    case "$expand":
+      return this.parseExpand();
+    case "$select":
+      return this.parseSelect();
+    default:
+      return this.parseAnythingWithBrackets(oToken);
+  }
+};
+function unescape$1(sEscape) {
+  return String.fromCharCode(parseInt(sEscape, 16));
+}
+function tokenizeSingleQuotedString(sNext, sOption, iAt) {
+  var i;
+  function nextChar(bConsume) {
+    var c = sNext[i];
+    if (c === "%" && sNext[i + 1] === "2" && sNext[i + 2] === "7") {
+      c = "'";
+      if (bConsume) {
+        i += 2;
+      }
+    }
+    if (bConsume) {
+      i += 1;
+    }
+    return c;
+  }
+  for (i = 1; i < sNext.length; ) {
+    if (nextChar(true) === "'") {
+      if (nextChar(false) !== "'") {
+        return sNext.slice(0, i);
+      }
+      nextChar(true);
+    }
+  }
+  throw new SyntaxError("Unterminated string at " + iAt + ": " + sOption);
+}
+function tokenizeDoubleQuotedString(sNext, sOption, iAt) {
+  var c, sEscape, bEscaping = false, i;
+  for (i = 1; i < sNext.length; i += 1) {
+    if (bEscaping) {
+      bEscaping = false;
+    } else {
+      c = sNext[i];
+      if (c === "%") {
+        sEscape = sNext.slice(i + 1, i + 3);
+        if (rEscapeDigits.test(sEscape)) {
+          c = unescape$1(sEscape);
+          i += 2;
+        }
+      }
+      if (c === "\"") {
+        return sNext.slice(0, i + 1);
+      }
+      bEscaping = c === "\\";
+    }
+  }
+  throw new SyntaxError("Unterminated string at " + iAt + ": " + sOption);
+}
+function tokenize(sOption) {
+  var iAt = 1, sId, aMatches, sNext = sOption, iOffset, oToken, aTokens = [], sValue;
+  while (sNext.length) {
+    aMatches = rToken.exec(sNext);
+    iOffset = 0;
+    if (aMatches) {
+      sValue = aMatches[0];
+      if (aMatches[7]) {
+        sId = "OPTION";
+      } else if (aMatches[6] || aMatches[4]) {
+        sId = "VALUE";
+      } else if (aMatches[5]) {
+        sId = "PATH";
+        if (sValue === "false" || sValue === "true" || sValue === "null") {
+          sId = "VALUE";
+        } else if (sValue === "not") {
+          aMatches = rNot.exec(sNext);
+          if (aMatches) {
+            sId = "not";
+            sValue = aMatches[0];
+          }
+        }
+      } else if (aMatches[3]) {
+        sId = unescape$1(aMatches[3]);
+      } else if (aMatches[2]) {
+        sId = aMatches[2];
+        iOffset = aMatches[1].length;
+      } else {
+        sId = aMatches[0];
+      }
+      if (sId === "\"") {
+        sId = "VALUE";
+        sValue = tokenizeDoubleQuotedString(sNext, sOption, iAt);
+      } else if (sId === "'") {
+        sId = "VALUE";
+        sValue = tokenizeSingleQuotedString(sNext, sOption, iAt);
+      }
+      oToken = {
+        at: iAt + iOffset,
+        id: sId,
+        value: sValue
+      };
+    } else {
+      throw new SyntaxError("Unknown character '" + sNext[0] + "' at " + iAt + ": " + sOption);
+    }
+    sNext = sNext.slice(sValue.length);
+    iAt += sValue.length;
+    aTokens.push(oToken);
+  }
+  return aTokens;
+}
+var _Parser$1 = {
+  buildFilterString: function (oSyntaxTree) {
+    function serialize(oNode, iParentPrecedence) {
+      var sFilter;
+      if (!oNode) {
+        return "";
+      }
+      if (oNode.parameters) {
+        sFilter = oNode.parameters.map(function (oParameter) {
+          return serialize(oParameter, 0);
+        }).join(",");
+        return oNode.value + "(" + sFilter + ")";
+      }
+      sFilter = serialize(oNode.left, oNode.precedence) + oNode.value + serialize(oNode.right, oNode.precedence);
+      if (oNode.precedence < iParentPrecedence) {
+        sFilter = "(" + sFilter + ")";
+      }
+      return sFilter;
+    }
+    return serialize(oSyntaxTree, 0);
+  },
+  parseFilter: function (sFilter) {
+    return new _FilterParser().parse(sFilter);
+  },
+  parseKeyPredicate: function (sKeyPredicate) {
+    return new _KeyPredicateParser().parse(sKeyPredicate);
+  },
+  parseSystemQueryOption: function (sOption) {
+    return new _SystemQueryOptionParser().parse(sOption);
+  },
+  sODataIdentifier: sODataIdentifier,
+  sWhitespace: sWhitespace
+};
 
 var fnEqual = function (a, b, maxDepth, contains, depth) {
   if (typeof maxDepth == "boolean") {
@@ -3909,6 +4750,1068 @@ SyncPromise.resolve = function (vResult) {
   });
 };
 
+var FilterOperator = {
+  EQ: "EQ",
+  NE: "NE",
+  LT: "LT",
+  LE: "LE",
+  GT: "GT",
+  GE: "GE",
+  BT: "BT",
+  NB: "NB",
+  Contains: "Contains",
+  NotContains: "NotContains",
+  StartsWith: "StartsWith",
+  NotStartsWith: "NotStartsWith",
+  EndsWith: "EndsWith",
+  NotEndsWith: "NotEndsWith",
+  All: "All",
+  Any: "Any"
+};
+
+class config {
+    config = new Map();
+    static get Type() {
+        return {
+            String: "string"
+        }
+    }
+    static get({ name }) {
+        return name === "sapUiLogLevel" ? "Error" : undefined;
+    }
+    static getWritableInstance() {
+        return {
+            get(obj) {
+                config.get(obj.name);
+            },
+            set(name, obj) {
+                config.set(name, obj);
+            }
+        }
+    }
+}
+
+class Eventing {
+		#mEventRegistry = {};
+		/**
+		 * Attaches an event handler to the event with the given identifier.
+		 *
+		 * @param {string}
+		 * 		sType The type of the event to listen for
+		 * @param {function}
+		 * 		fnFunction The handler function to call when the event occurs. The event
+		 * 		object ({@link module:sap/base/Event}) is provided as first argument of the handler. Handlers must not change
+		 * 		the content of the event.
+		 * @param {object}
+		 * 		[oData] An object that will be passed to the handler along with the event object when the event is fired
+		 * @since 1.120.0
+		 * @private
+		 * @ui5-restricted sap.ui.core sap/base/i18n
+		 */
+		attachEvent(sType, fnFunction, oData) {
+			assert(typeof (sType) === "string" && sType, "Eventing.attachEvent: sType must be a non-empty string");
+			assert(typeof (fnFunction) === "function", "Eventing.attachEvent: fnFunction must be a function");
+
+			let aEventListeners = this.#mEventRegistry[sType];
+			if ( !Array.isArray(aEventListeners) ) {
+				aEventListeners = this.#mEventRegistry[sType] = [];
+			}
+
+			aEventListeners.push({fnFunction: fnFunction, oData: oData});
+		}
+
+		/**
+		 * Attaches an event handler, called one time only, to the event with the given identifier.
+		 *
+		 * When the event occurs, the handler function is called and the handler registration is automatically removed afterwards.
+		 *
+		 * @param {string}
+		 *            sType The type of the event to listen for
+		 * @param {function}
+		 *            fnFunction The handler function to call when the event occurs. The event
+		 *                       object ({@link module:sap/base/Event}) is provided as first argument of the handler. Handlers must not change
+		 *                       the content of the event.
+		 * @param {object}
+		 *            [oData] An object that will be passed to the handler along with the event object when the event is fired
+		 * @since 1.120.0
+		 * @private
+		 * @ui5-restricted sap.ui.core sap/base/i18n
+		 */
+		attachEventOnce(sType, fnFunction, oData) {
+			const fnOnce = (oEvent) => {
+				this.detachEvent(sType, fnOnce);
+				fnFunction.call(null, oEvent);  // needs to do the same resolution as in fireEvent
+			};
+			fnOnce.oOriginal = {
+				fnFunction: fnFunction
+			};
+			this.attachEvent(sType, fnOnce, oData);
+		}
+
+		/**
+		 * Removes a previously attached event handler from the event with the given identifier.
+		 *
+		 * The passed parameters must match those used for registration with {@link #attachEvent} beforehand.
+		 *
+		 * @param {string}
+		 *            sType The type of the event to detach from
+		 * @param {function}
+		 *            fnFunction The handler function to detach from the event
+		 * @since 1.120.0
+		 * @private
+		 * @ui5-restricted sap.ui.core sap/base/i18n
+		 */
+		detachEvent(sType, fnFunction) {
+			assert(typeof (sType) === "string" && sType, "Eventing.detachEvent: sType must be a non-empty string" );
+			assert(typeof (fnFunction) === "function", "Eventing.detachEvent: fnFunction must be a function");
+
+			const aEventListeners = this.#mEventRegistry[sType];
+			if ( !Array.isArray(aEventListeners) ) {
+				return;
+			}
+
+			let oFound;
+
+			for (let i = 0, iL = aEventListeners.length; i < iL; i++) {
+				if (aEventListeners[i].fnFunction === fnFunction) {
+					oFound = aEventListeners[i];
+					aEventListeners.splice(i,1);
+					break;
+				}
+			}
+			// If no listener was found, look for original listeners of attachEventOnce
+			if (!oFound) {
+				for (let i = 0, iL = aEventListeners.length; i < iL; i++) {
+					const oOriginal = aEventListeners[i].fnFunction.oOriginal;
+					if (oOriginal && oOriginal.fnFunction === fnFunction) {
+						aEventListeners.splice(i,1);
+						break;
+					}
+				}
+			}
+			// If we just deleted the last registered EventHandler, remove the whole entry from our map.
+			if (aEventListeners.length == 0) {
+				delete this.#mEventRegistry[sType];
+			}
+		}
+
+		/**
+		 * Fires an {@link module:sap/base/Event event} with the given settings and notifies all attached event handlers.
+		 *
+		 * @param {string}
+		 *            sType The type of the event to fire
+		 * @param {object}
+		 *            [oParameters] Parameters which should be carried by the event
+		 * @since 1.120.0
+		 * @private
+		 * @ui5-restricted sap.ui.core sap/base/i18n
+		 */
+		fireEvent(sType, oParameters) {
+			let aEventListeners, oEvent, i, iL, oInfo;
+
+			aEventListeners = this.#mEventRegistry[sType];
+
+			if (Array.isArray(aEventListeners)) {
+
+				// avoid issues with 'concurrent modification' (e.g. if an event listener unregisters itself).
+				aEventListeners = aEventListeners.slice();
+				oEvent = new Event(sType, oParameters);
+
+				for (i = 0, iL = aEventListeners.length; i < iL; i++) {
+					oInfo = aEventListeners[i];
+					oInfo.fnFunction.call(null, oEvent);
+				}
+			}
+		}
+	}
+
+class LanguageTag {
+		/**
+		 * Get the language.
+		 *
+		 * Note that the case might differ from the original script tag
+		 * (Lower case is enforced as recommended by BCP47/ISO639).
+		 *
+		 * @type {string}
+		 * @public
+		 */
+		language;
+
+		/**
+		 * Get the script or <code>null</code> if none was specified.
+		 *
+		 * Note that the case might differ from the original language tag
+		 * (Upper case first letter and lower case reminder enforced as
+		 * recommended by BCP47/ISO15924)
+		 *
+		 * @type {string|null}
+		 * @public
+		 */
+		script;
+
+		/**
+		 * Get the region or <code>null</code> if none was specified.
+		 *
+		 * Note that the case might differ from the original script tag
+		 * (Upper case is enforced as recommended by BCP47/ISO3166-1).
+		 *
+		 * @type {string}
+		 * @public
+		 */
+		region;
+
+		/**
+		 * Get the variants as a single string or <code>null</code>.
+		 *
+		 * Multiple variants are separated by a dash '-'.
+		 *
+		 * @type {string|null}
+		 * @public
+		 */
+		variant;
+
+		/**
+		 * Get the variants as an array of individual variants.
+		 *
+		 * The separating dashes are not part of the result.
+		 * If there is no variant section in the language tag, an empty array is returned.
+		 *
+		 * @type {string[]}
+		 * @public
+		 */
+		variantSubtags;
+
+		/**
+		 * Get the extension as a single string or <code>null</code>.
+		 *
+		 * The extension always consists of a singleton character (not 'x'),
+		 * a dash '-' and one or more extension token, each separated
+		 * again with a dash.
+		 *
+		 * @type {string|null}
+		 * @public
+		 */
+		extension;
+
+		/**
+		 * Get the extensions as an array of tokens.
+		 *
+		 * The leading singleton and the separating dashes are not part of the result.
+		 * If there is no extensions section in the language tag, an empty array is returned.
+		 *
+		 * @type {string[]}
+		 * @public
+		 */
+		extensionSubtags;
+
+		/**
+		 * Get the private use section or <code>null</code>.
+		 *
+		 * @type {string}
+		 */
+		privateUse;
+
+		/**
+		 * Get the private use section as an array of tokens.
+		 *
+		 * The leading singleton and the separating dashes are not part of the result.
+		 * If there is no private use section in the language tag, an empty array is returned.
+		 *
+		 * @type {string[]}
+		 */
+		privateUseSubtags;
+
+		constructor(sLanguageTag) {
+			var aResult = rLanguageTag.exec(sLanguageTag.replace(/_/g, "-"));
+			// If the given language tag string cannot be parsed by the regular expression above,
+			// we should at least tell the developer why the Core fails to load.
+			if (aResult === null ) {
+				throw new TypeError("The given language tag '" + sLanguageTag + "' does not adhere to BCP-47.");
+			}
+			this.language = aResult[1] || null;
+			this.script = aResult[2] || null;
+			this.region = aResult[3] || null;
+			this.variant = (aResult[4] && aResult[4].slice(1)) || null; // remove leading dash from capturing group
+			this.variantSubtags = this.variant ? this.variant.split('-') : [];
+			this.extension = (aResult[5] && aResult[5].slice(1)) || null; // remove leading dash from capturing group
+			this.extensionSubtags = this.variant ? this.variant.split('-') : [];
+			this.privateUse = aResult[6] || null;
+			this.privateUseSubtags = this.privateUse ? this.privateUse.slice(2).split('-') : [];
+			// convert subtags according to the BCP47 recommendations
+			// - language: all lower case
+			// - script: lower case with the first letter capitalized
+			// - region: all upper case
+			if ( this.language ) {
+				this.language = this.language.toLowerCase();
+			}
+			if ( this.script ) {
+				this.script = this.script.toLowerCase().replace(/^[a-z]/, function($) {
+					return $.toUpperCase();
+				});
+			}
+			if ( this.region ) {
+				this.region = this.region.toUpperCase();
+			}
+			Object.freeze(this);
+		}
+		toString() {
+			return this.#join(
+				this.language,
+				this.script,
+				this.region,
+				this.variant,
+				this.extension,
+				this.privateUse);
+		}
+		#join() {
+			return Array.prototype.filter.call(arguments, Boolean).join("-");
+		}
+	}
+
+let _fnRegisterEnum;
+const mEarlyRegistrations = new Map();
+var _EnumHelper = {
+  inject: function (registerEnum) {
+    if (!_fnRegisterEnum) {
+      _fnRegisterEnum = registerEnum;
+      mEarlyRegistrations.forEach((mEnumContent, sName) => {
+        _fnRegisterEnum(sName, mEnumContent);
+      });
+    }
+  },
+  register: function (sName, mEnumContent) {
+    if (_fnRegisterEnum) {
+      _fnRegisterEnum(sName, mEnumContent);
+    } else {
+      mEarlyRegistrations.set(sName, mEnumContent);
+    }
+  }
+};
+
+var CalendarType = {
+  Gregorian: "Gregorian",
+  Islamic: "Islamic",
+  Japanese: "Japanese",
+  Persian: "Persian",
+  Buddhist: "Buddhist"
+};
+_EnumHelper.register("sap.base.i18n.date.CalendarType", CalendarType);
+
+var TimezoneUtils = {};
+var sLocalTimezone = "";
+var aSupportedTimezoneIDs;
+var oIntlDateTimeFormatCache = {
+  _oCache: new Map(),
+  _iCacheLimit: 10,
+  get: function (sTimezone) {
+    var cacheEntry = this._oCache.get(sTimezone);
+    if (cacheEntry) {
+      return cacheEntry;
+    }
+    var oOptions = {
+      hourCycle: "h23",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      fractionalSecondDigits: 3,
+      day: "2-digit",
+      month: "2-digit",
+      year: "numeric",
+      timeZone: sTimezone,
+      timeZoneName: "short",
+      era: "narrow",
+      weekday: "short"
+    };
+    var oInstance = new Intl.DateTimeFormat("en-US", oOptions);
+    if (this._oCache.size === this._iCacheLimit) {
+      this._oCache = new Map();
+    }
+    this._oCache.set(sTimezone, oInstance);
+    return oInstance;
+  }
+};
+TimezoneUtils.isValidTimezone = function (sTimezone) {
+  if (!sTimezone) {
+    return false;
+  }
+  if (Intl.supportedValuesOf) {
+    try {
+      aSupportedTimezoneIDs = aSupportedTimezoneIDs || Intl.supportedValuesOf("timeZone");
+      if (aSupportedTimezoneIDs.includes(sTimezone)) {
+        return true;
+      }
+    } catch (oError) {
+      aSupportedTimezoneIDs = [];
+    }
+  }
+  try {
+    oIntlDateTimeFormatCache.get(sTimezone);
+    return true;
+  } catch (oError) {
+    return false;
+  }
+};
+TimezoneUtils.convertToTimezone = function (oDate, sTargetTimezone) {
+  var oFormatParts = this._getParts(oDate, sTargetTimezone);
+  return TimezoneUtils._getDateFromParts(oFormatParts);
+};
+TimezoneUtils._getParts = function (oDate, sTargetTimezone) {
+  var sKey, oPart, oDateParts = Object.create(null), oIntlDate = oIntlDateTimeFormatCache.get(sTargetTimezone), oParts = oIntlDate.formatToParts(new Date(oDate.getTime()));
+  for (sKey in oParts) {
+    oPart = oParts[sKey];
+    if (oPart.type !== "literal") {
+      oDateParts[oPart.type] = oPart.value;
+    }
+  }
+  return oDateParts;
+};
+TimezoneUtils._getDateFromParts = function (oParts) {
+  var oDate = new Date(0), iUTCYear = parseInt(oParts.year);
+  if (oParts.era === "B") {
+    iUTCYear = iUTCYear * -1 + 1;
+  }
+  oDate.setUTCFullYear(iUTCYear, parseInt(oParts.month) - 1, parseInt(oParts.day));
+  oDate.setUTCHours(parseInt(oParts.hour), parseInt(oParts.minute), parseInt(oParts.second), parseInt(oParts.fractionalSecond || 0));
+  return oDate;
+};
+TimezoneUtils.calculateOffset = function (oDate, sTimezoneSource) {
+  const oDateInTimezone = TimezoneUtils.convertToTimezone(oDate, sTimezoneSource);
+  const iGivenTimestamp = oDate.getTime();
+  const iInitialOffset = iGivenTimestamp - oDateInTimezone.getTime();
+  const oFirstGuess = new Date(iGivenTimestamp + iInitialOffset);
+  const oFirstGuessInTimezone = TimezoneUtils.convertToTimezone(oFirstGuess, sTimezoneSource);
+  const iFirstGuessInTimezoneTimestamp = oFirstGuessInTimezone.getTime();
+  const iSecondOffset = oFirstGuess.getTime() - iFirstGuessInTimezoneTimestamp;
+  let iTimezoneOffset = iSecondOffset;
+  if (iInitialOffset !== iSecondOffset) {
+    const oSecondGuess = new Date(iGivenTimestamp + iSecondOffset);
+    const oSecondGuessInTimezone = TimezoneUtils.convertToTimezone(oSecondGuess, sTimezoneSource);
+    const iSecondGuessInTimezoneTimestamp = oSecondGuessInTimezone.getTime();
+    if (iSecondGuessInTimezoneTimestamp !== iGivenTimestamp && iFirstGuessInTimezoneTimestamp > iSecondGuessInTimezoneTimestamp) {
+      iTimezoneOffset = iInitialOffset;
+    }
+  }
+  return iTimezoneOffset / 1000;
+};
+TimezoneUtils.mCLDR2ABAPTimezones = {
+  "America/Buenos_Aires": "America/Argentina/Buenos_Aires",
+  "America/Catamarca": "America/Argentina/Catamarca",
+  "America/Cordoba": "America/Argentina/Cordoba",
+  "America/Jujuy": "America/Argentina/Jujuy",
+  "America/Mendoza": "America/Argentina/Mendoza",
+  "America/Indianapolis": "America/Indiana/Indianapolis",
+  "America/Louisville": "America/Kentucky/Louisville",
+  "Africa/Asmera": "Africa/Asmara",
+  "Asia/Katmandu": "Asia/Kathmandu",
+  "Asia/Calcutta": "Asia/Kolkata",
+  "Atlantic/Faeroe": "Atlantic/Faroe",
+  "Pacific/Ponape": "Pacific/Pohnpei",
+  "Asia/Rangoon": "Asia/Yangon",
+  "Pacific/Truk": "Pacific/Chuuk",
+  "America/Godthab": "America/Nuuk",
+  "Asia/Saigon": "Asia/Ho_Chi_Minh",
+  "America/Coral_Harbour": "America/Atikokan"
+};
+TimezoneUtils.getLocalTimezone = function () {
+  if (sLocalTimezone === "") {
+    sLocalTimezone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+    sLocalTimezone = TimezoneUtils.mCLDR2ABAPTimezones[sLocalTimezone] || sLocalTimezone;
+  }
+  return sLocalTimezone;
+};
+TimezoneUtils._clearLocalTimezoneCache = function () {
+  sLocalTimezone = "";
+};
+
+const oWritableConfig = config.getWritableInstance();
+let sLanguageSetByApi;
+const oEventing = new Eventing();
+let mChanges;
+let bLanguageWarningLogged = false;
+const _mPreferredCalendar = {
+  "ar-SA": CalendarType.Islamic,
+  "fa": CalendarType.Persian,
+  "th": CalendarType.Buddhist,
+  "default": CalendarType.Gregorian
+};
+const M_ABAP_LANGUAGE_TO_LOCALE = {
+  "ZH": "zh-Hans",
+  "ZF": "zh-Hant",
+  "SH": "sr-Latn",
+  "CT": "cnr",
+  "6N": "en-GB",
+  "1P": "pt-PT",
+  "1X": "es-MX",
+  "3F": "fr-CA",
+  "1Q": "en-US-x-saptrc",
+  "2Q": "en-US-x-sappsd",
+  "3Q": "en-US-x-saprigi"
+};
+const M_ISO639_OLD_TO_NEW = {
+  "iw": "he",
+  "ji": "yi"
+};
+const M_LOCALE_TO_ABAP_LANGUAGE = (obj => {
+  return Object.keys(obj).reduce((inv, key) => {
+    inv[obj[key]] = key;
+    return inv;
+  }, {});
+})(M_ABAP_LANGUAGE_TO_LOCALE);
+function getPseudoLanguageTag(sPrivateUse) {
+  let sPseudoLanguageTag;
+  if (sPrivateUse) {
+    const m = (/-(saptrc|sappsd|saprigi)(?:-|$)/i).exec(sPrivateUse);
+    sPseudoLanguageTag = m && "en-US-x-" + m[1].toLowerCase();
+  }
+  return sPseudoLanguageTag;
+}
+function getDesigntimePropertyAsArray(sValue) {
+  const m = (/\$([-a-z0-9A-Z._]+)(?::([^$]*))?\$/).exec(sValue);
+  return m && m[2] ? m[2].split(/,/) : null;
+}
+const A_RTL_LOCALES = getDesigntimePropertyAsArray("$cldr-rtl-locales:ar,fa,he$") || [];
+const _coreI18nLocales = getDesigntimePropertyAsArray("$core-i18n-locales:,ar,bg,ca,cnr,cs,cy,da,de,el,en,en_GB,es,es_MX,et,fi,fr,fr_CA,hi,hr,hu,id,it,iw,ja,kk,ko,lt,lv,mk,ms,nl,no,pl,pt,pt_PT,ro,ru,sh,sk,sl,sr,sv,th,tr,uk,vi,zh_CN,zh_TW$");
+function fromSAPLogonLanguage(sSAPLogonLanguage) {
+  let oLanguageTag;
+  if (sSAPLogonLanguage && typeof sSAPLogonLanguage === "string") {
+    sSAPLogonLanguage = M_ABAP_LANGUAGE_TO_LOCALE[sSAPLogonLanguage.toUpperCase()] || sSAPLogonLanguage;
+    try {
+      oLanguageTag = new LanguageTag(sSAPLogonLanguage);
+    } catch (e) {}
+  }
+  return [oLanguageTag, sSAPLogonLanguage];
+}
+function createLanguageTag(sLanguage) {
+  let oLanguageTag;
+  if (sLanguage) {
+    oLanguageTag = new LanguageTag(sLanguage);
+  }
+  return oLanguageTag;
+}
+function detectLanguage() {
+  return globalThis.navigator ? globalThis.navigator.languages && globalThis.navigator.languages[0] || globalThis.navigator.language || "en" : new Intl.Collator().resolvedOptions().locale || "en";
+}
+function check(bCondition, sMessage) {
+  if (!bCondition) {
+    throw new TypeError(sMessage);
+  }
+}
+function join() {
+  return Array.prototype.filter.call(arguments, Boolean).join("-");
+}
+function checkTimezone(sTimezone) {
+  const bIsValidTimezone = TimezoneUtils.isValidTimezone(sTimezone);
+  if (!bIsValidTimezone) {
+    Log.error("The provided timezone '" + sTimezone + "' is not a valid IANA timezone ID." + " Falling back to browser's local timezone '" + TimezoneUtils.getLocalTimezone() + "'.");
+  }
+  return bIsValidTimezone;
+}
+const Localization = {
+  attachChange: function (fnFunction) {
+    oEventing.attachEvent("change", fnFunction);
+  },
+  detachChange: function (fnFunction) {
+    oEventing.detachEvent("change", fnFunction);
+  },
+  getActiveTerminologies: function () {
+    return oWritableConfig.get({
+      name: "sapUiActiveTerminologies",
+      type: config.Type.StringArray,
+      defaultValue: undefined,
+      external: true
+    });
+  },
+  getLanguage: function () {
+    let oLanguageTag, sDerivedLanguage;
+    if (sLanguageSetByApi) {
+      return sLanguageSetByApi;
+    }
+    const sLanguage = oWritableConfig.get({
+      name: "sapUiLanguage",
+      type: config.Type.String,
+      external: true
+    });
+    const sSapLocale = oWritableConfig.get({
+      name: "sapLocale",
+      type: config.Type.String,
+      external: true
+    });
+    const sSapLanguage = oWritableConfig.get({
+      name: "sapLanguage",
+      type: config.Type.String,
+      external: true
+    });
+    if (sSapLocale) {
+      oLanguageTag = createLanguageTag(sSapLocale);
+      sDerivedLanguage = sSapLocale;
+    } else if (sSapLanguage) {
+      if (!sLanguage && !bLanguageWarningLogged) {
+        Log.warning("sap-language '" + sSapLanguage + "' is not a valid BCP47 language tag and will only be used as SAP logon language");
+        bLanguageWarningLogged = true;
+      }
+      [oLanguageTag, sDerivedLanguage] = fromSAPLogonLanguage(sSapLanguage);
+    }
+    if (!oLanguageTag) {
+      if (sLanguage) {
+        oLanguageTag = createLanguageTag(sLanguage);
+        sDerivedLanguage = sLanguage;
+      } else {
+        sDerivedLanguage = detectLanguage();
+        oLanguageTag = createLanguageTag(sLanguage);
+      }
+    }
+    return sDerivedLanguage;
+  },
+  getModernLanguage: function (sLanguage) {
+    return M_ISO639_OLD_TO_NEW[sLanguage] || sLanguage;
+  },
+  setLanguage: function (sLanguage, sSAPLogonLanguage) {
+    const oLanguageTag = createLanguageTag(sLanguage), bOldRTL = Localization.getRTL();
+    check(oLanguageTag, "Localization.setLanguage: sLanguage must be a valid BCP47 language tag");
+    check(sSAPLogonLanguage == null || typeof sSAPLogonLanguage === "string" && (/^[A-Z0-9]{2,2}$/i).test(sSAPLogonLanguage), "Localization.setLanguage: sSAPLogonLanguage must be null or be a string of length 2, consisting of digits and latin characters only");
+    sSAPLogonLanguage = sSAPLogonLanguage || "";
+    if (oLanguageTag.toString() != Localization.getLanguageTag().toString() || sSAPLogonLanguage !== oWritableConfig.get({
+      name: "sapLanguage",
+      type: config.Type.String,
+      external: true
+    })) {
+      oWritableConfig.set("sapLanguage", sSAPLogonLanguage);
+      sLanguageSetByApi = sLanguage;
+      mChanges = {};
+      mChanges.language = Localization.getLanguageTag().toString();
+      const bRtl = Localization.getRTL();
+      if (bOldRTL != bRtl) {
+        mChanges.rtl = bRtl;
+      }
+      fireChange();
+    }
+  },
+  getTimezone: function () {
+    let sTimezone = oWritableConfig.get({
+      name: "sapTimezone",
+      type: config.Type.String,
+      external: true,
+      defaultValue: oWritableConfig.get({
+        name: "sapUiTimezone",
+        type: config.Type.String,
+        external: true
+      })
+    });
+    if (!sTimezone || !checkTimezone(sTimezone)) {
+      sTimezone = TimezoneUtils.getLocalTimezone();
+    }
+    return sTimezone;
+  },
+  setTimezone: function (sTimezone) {
+    check(sTimezone == null || typeof sTimezone === "string", "Localization.setTimezone: sTimezone must be null or be a string");
+    const sCurrentTimezone = Localization.getTimezone();
+    sTimezone = sTimezone === null || !checkTimezone(sTimezone) ? undefined : sTimezone;
+    oWritableConfig.set("sapTimezone", sTimezone);
+    if (Localization.getTimezone() !== sCurrentTimezone) {
+      mChanges = {};
+      mChanges.timezone = Localization.getTimezone();
+      fireChange();
+    }
+  },
+  getLanguageTag: function () {
+    const oLanguageTag = new LanguageTag(Localization.getLanguage());
+    const sLanguage = Localization.getModernLanguage(oLanguageTag.language);
+    const sScript = oLanguageTag.script;
+    let sLanguageTag = oLanguageTag.toString();
+    if (sLanguage === "sr" && sScript === "Latn") {
+      sLanguageTag = sLanguageTag.replace("sr-Latn", "sh");
+    } else {
+      sLanguageTag = sLanguageTag.replace(oLanguageTag.language, sLanguage);
+    }
+    return new LanguageTag(sLanguageTag);
+  },
+  getRTL: function () {
+    return oWritableConfig.get({
+      name: "sapRtl",
+      type: config.Type.Boolean,
+      external: true,
+      defaultValue: oWritableConfig.get({
+        name: "sapUiRtl",
+        type: config.Type.Boolean,
+        defaultValue: function () {
+          return impliesRTL(Localization.getLanguageTag());
+        },
+        external: true
+      })
+    });
+  },
+  setRTL: function (bRTL) {
+    check(bRTL === null || typeof bRTL === "boolean", "bRTL must be null or a boolean");
+    bRTL = bRTL === null ? undefined : bRTL;
+    const oldRTL = Localization.getRTL();
+    oWritableConfig.set("sapRtl", bRTL);
+    const bCurrentRTL = Localization.getRTL();
+    if (oldRTL != bCurrentRTL) {
+      mChanges = {};
+      mChanges.rtl = bCurrentRTL;
+      fireChange();
+    }
+  },
+  _getSAPLogonLanguage: function (oLanguageTag) {
+    let sLanguage = oLanguageTag.language || "";
+    if (sLanguage.indexOf("-") >= 0) {
+      sLanguage = sLanguage.slice(0, sLanguage.indexOf("-"));
+    }
+    sLanguage = Localization.getModernLanguage(sLanguage);
+    if (sLanguage === "zh" && !oLanguageTag.script && oLanguageTag.region === "TW") {
+      return "ZF";
+    }
+    return M_LOCALE_TO_ABAP_LANGUAGE[join(sLanguage, oLanguageTag.script)] || M_LOCALE_TO_ABAP_LANGUAGE[join(sLanguage, oLanguageTag.region)] || M_LOCALE_TO_ABAP_LANGUAGE[getPseudoLanguageTag(oLanguageTag.privateUse)] || sLanguage.toUpperCase();
+  },
+  getSAPLogonLanguage: function () {
+    let oLanguageTag;
+    const sLanguage = oWritableConfig.get({
+      name: "sapLanguage",
+      type: config.Type.String,
+      external: true
+    }).toUpperCase();
+    try {
+      [oLanguageTag] = fromSAPLogonLanguage(sLanguage);
+    } catch (exc) {}
+    if (sLanguage && !oLanguageTag) {
+      Log.warning("sap-language '" + sLanguage + "' is not a valid BCP47 language tag and will only be used as SAP logon language");
+    }
+    return sLanguage || Localization._getSAPLogonLanguage(Localization.getLanguageTag());
+  },
+  getPreferredCalendarType: function () {
+    const oLocale = Localization.getLanguageTag();
+    return _mPreferredCalendar[oLocale.language + "-" + oLocale.region] || _mPreferredCalendar[oLocale.language] || _mPreferredCalendar["default"];
+  },
+  getLanguagesDeliveredWithCore: function () {
+    return _coreI18nLocales;
+  },
+  getSupportedLanguages: function () {
+    let aLangs = config.get({
+      name: "sapUiXxSupportedLanguages",
+      type: config.Type.StringArray,
+      external: true
+    });
+    if (aLangs.length === 0 || aLangs.length === 1 && aLangs[0] === "*") {
+      aLangs = [];
+    } else if (aLangs.length === 1 && aLangs[0] === "default") {
+      aLangs = this.getLanguagesDeliveredWithCore() || [];
+    }
+    return aLangs;
+  }
+};
+function impliesRTL(oLanguageTag) {
+  let sLanguage = oLanguageTag.language || "";
+  sLanguage = Localization.getModernLanguage(oLanguageTag.language);
+  const sRegion = oLanguageTag.region || "";
+  if (sRegion && A_RTL_LOCALES.indexOf(sLanguage + "_" + sRegion) >= 0) {
+    return true;
+  }
+  return A_RTL_LOCALES.indexOf(sLanguage) >= 0;
+}
+function fireChange() {
+  oEventing.fireEvent("change", mChanges);
+  mChanges = undefined;
+}
+
+var Filter = BaseObject.extend("sap.ui.model.Filter", {
+  constructor: function (vFilterInfo, vOperator, vValue1, vValue2) {
+    BaseObject.call(this);
+    if (typeof vFilterInfo === "object" && !Array.isArray(vFilterInfo)) {
+      this.sPath = vFilterInfo.path;
+      this.sOperator = vFilterInfo.operator;
+      this.oValue1 = vFilterInfo.value1;
+      this.oValue2 = vFilterInfo.value2;
+      this.sVariable = vFilterInfo.variable;
+      this.oCondition = vFilterInfo.condition;
+      this.aFilters = vFilterInfo.filters || vFilterInfo.aFilters;
+      this.bAnd = vFilterInfo.and || vFilterInfo.bAnd;
+      this.fnTest = vFilterInfo.test;
+      this.fnCompare = vFilterInfo.comparator;
+      this.bCaseSensitive = vFilterInfo.caseSensitive;
+    } else {
+      if (Array.isArray(vFilterInfo)) {
+        this.aFilters = vFilterInfo;
+      } else {
+        this.sPath = vFilterInfo;
+      }
+      if (typeof vOperator === "boolean") {
+        this.bAnd = vOperator;
+      } else if (typeof vOperator === "function") {
+        this.fnTest = vOperator;
+      } else {
+        this.sOperator = vOperator;
+      }
+      this.oValue1 = vValue1;
+      this.oValue2 = vValue2;
+      if (this.sOperator === FilterOperator.Any || this.sOperator === FilterOperator.All) {
+        throw new Error("The filter operators 'Any' and 'All' are only supported with the parameter object notation.");
+      }
+    }
+    if (this.aFilters?.includes(Filter.NONE)) {
+      throw new Error("Filter.NONE not allowed in multiple filter");
+    } else if (this.oCondition && this.oCondition === Filter.NONE) {
+      throw new Error("Filter.NONE not allowed as condition");
+    }
+    if (this.sOperator === FilterOperator.Any) {
+      if (this.sVariable && this.oCondition) {
+        this._checkLambdaArgumentTypes();
+      } else if (!this.sVariable && !this.oCondition) ; else {
+        throw new Error("When using the filter operator 'Any', a lambda variable and a condition have to be given or neither.");
+      }
+    } else if (this.sOperator === FilterOperator.All) {
+      this._checkLambdaArgumentTypes();
+    } else if (Array.isArray(this.aFilters) && !this.sPath && !this.sOperator && !this.oValue1 && !this.oValue2) {
+      this._bMultiFilter = true;
+      if (!this.aFilters.every(isFilter)) {
+        Log.error("Filter in aggregation of multi filter has to be instance of" + " sap.ui.model.Filter");
+      }
+    } else if (!this.aFilters && this.sPath !== undefined && (this.sOperator && this.oValue1 !== undefined || this.fnTest)) {
+      this._bMultiFilter = false;
+    } else {
+      Log.error("Wrong parameters defined for filter.");
+    }
+    this.sFractionalSeconds1 = undefined;
+    this.sFractionalSeconds2 = undefined;
+  }
+});
+Filter.NONE = new Filter({
+  path: "/",
+  test: () => false
+});
+Filter.checkFilterNone = function (vFilter) {
+  if (Array.isArray(vFilter) && vFilter.length > 1 && vFilter.includes(Filter.NONE)) {
+    throw new Error("Filter.NONE cannot be used together with other filters");
+  }
+};
+Filter.prototype._checkLambdaArgumentTypes = function () {
+  if (!this.sVariable || typeof this.sVariable !== "string") {
+    throw new Error("When using the filter operators 'Any' or 'All', a string has to be given as argument 'variable'.");
+  }
+  if (!isFilter(this.oCondition)) {
+    throw new Error("When using the filter operator 'Any' or 'All', a valid instance of sap.ui.model.Filter has to be given as argument 'condition'.");
+  }
+};
+function isFilter(v) {
+  return v instanceof Filter;
+}
+Filter.prototype.appendFractionalSeconds1 = function (sFractionalSeconds) {
+  this.sFractionalSeconds1 = sFractionalSeconds;
+};
+Filter.prototype.appendFractionalSeconds2 = function (sFractionalSeconds) {
+  this.sFractionalSeconds2 = sFractionalSeconds;
+};
+var Type = {
+  Logical: "Logical",
+  Binary: "Binary",
+  Unary: "Unary",
+  Lambda: "Lambda",
+  Reference: "Reference",
+  Literal: "Literal",
+  Variable: "Variable",
+  Call: "Call",
+  Custom: "Custom"
+};
+var Op = {
+  Equal: "==",
+  NotEqual: "!=",
+  LessThan: "<",
+  GreaterThan: ">",
+  LessThanOrEqual: "<=",
+  GreaterThanOrEqual: ">=",
+  And: "&&",
+  Or: "||",
+  Not: "!"
+};
+var Func = {
+  Contains: "contains",
+  StartsWith: "startswith",
+  EndsWith: "endswith"
+};
+Filter.prototype.getAST = function (bIncludeOrigin) {
+  var oResult, sOp, sOrigOp, oRef, oValue, oFromValue, oToValue, oVariable, oCondition;
+  function logical(sOp, oLeft, oRight) {
+    return {
+      type: Type.Logical,
+      op: sOp,
+      left: oLeft,
+      right: oRight
+    };
+  }
+  function binary(sOp, oLeft, oRight) {
+    return {
+      type: Type.Binary,
+      op: sOp,
+      left: oLeft,
+      right: oRight
+    };
+  }
+  function unary(sOp, oArg) {
+    return {
+      type: Type.Unary,
+      op: sOp,
+      arg: oArg
+    };
+  }
+  function lambda(sOp, oRef, oVariable, oCondition) {
+    return {
+      type: Type.Lambda,
+      op: sOp,
+      ref: oRef,
+      variable: oVariable,
+      condition: oCondition
+    };
+  }
+  function reference(sPath) {
+    return {
+      type: Type.Reference,
+      path: sPath
+    };
+  }
+  function literal(vValue) {
+    return {
+      type: Type.Literal,
+      value: vValue
+    };
+  }
+  function variable(sName) {
+    return {
+      type: Type.Variable,
+      name: sName
+    };
+  }
+  function call(sName, aArguments) {
+    return {
+      type: Type.Call,
+      name: sName,
+      args: aArguments
+    };
+  }
+  if (this.aFilters) {
+    sOp = this.bAnd ? Op.And : Op.Or;
+    sOrigOp = this.bAnd ? "AND" : "OR";
+    oResult = this.aFilters[this.aFilters.length - 1].getAST(bIncludeOrigin);
+    for (var i = this.aFilters.length - 2; i >= 0; i--) {
+      oResult = logical(sOp, this.aFilters[i].getAST(bIncludeOrigin), oResult);
+    }
+  } else {
+    sOp = this.sOperator;
+    sOrigOp = this.sOperator;
+    oRef = reference(this.sPath);
+    oValue = literal(this.oValue1);
+    switch (sOp) {
+      case FilterOperator.EQ:
+        oResult = binary(Op.Equal, oRef, oValue);
+        break;
+      case FilterOperator.NE:
+        oResult = binary(Op.NotEqual, oRef, oValue);
+        break;
+      case FilterOperator.LT:
+        oResult = binary(Op.LessThan, oRef, oValue);
+        break;
+      case FilterOperator.GT:
+        oResult = binary(Op.GreaterThan, oRef, oValue);
+        break;
+      case FilterOperator.LE:
+        oResult = binary(Op.LessThanOrEqual, oRef, oValue);
+        break;
+      case FilterOperator.GE:
+        oResult = binary(Op.GreaterThanOrEqual, oRef, oValue);
+        break;
+      case FilterOperator.Contains:
+        oResult = call(Func.Contains, [oRef, oValue]);
+        break;
+      case FilterOperator.StartsWith:
+        oResult = call(Func.StartsWith, [oRef, oValue]);
+        break;
+      case FilterOperator.EndsWith:
+        oResult = call(Func.EndsWith, [oRef, oValue]);
+        break;
+      case FilterOperator.NotContains:
+        oResult = unary(Op.Not, call(Func.Contains, [oRef, oValue]));
+        break;
+      case FilterOperator.NotStartsWith:
+        oResult = unary(Op.Not, call(Func.StartsWith, [oRef, oValue]));
+        break;
+      case FilterOperator.NotEndsWith:
+        oResult = unary(Op.Not, call(Func.EndsWith, [oRef, oValue]));
+        break;
+      case FilterOperator.BT:
+        oFromValue = oValue;
+        oToValue = literal(this.oValue2);
+        oResult = logical(Op.And, binary(Op.GreaterThanOrEqual, oRef, oFromValue), binary(Op.LessThanOrEqual, oRef, oToValue));
+        break;
+      case FilterOperator.NB:
+        oFromValue = oValue;
+        oToValue = literal(this.oValue2);
+        oResult = logical(Op.Or, binary(Op.LessThan, oRef, oFromValue), binary(Op.GreaterThan, oRef, oToValue));
+        break;
+      case FilterOperator.Any:
+      case FilterOperator.All:
+        oVariable = variable(this.sVariable);
+        oCondition = this.oCondition.getAST(bIncludeOrigin);
+        oResult = lambda(sOp, oRef, oVariable, oCondition);
+        break;
+      default:
+        throw new Error("Unknown operator: " + sOp);
+    }
+  }
+  if (bIncludeOrigin && !oResult.origin) {
+    oResult.origin = sOrigOp;
+  }
+  return oResult;
+};
+Filter.prototype.getComparator = function () {
+  return this.fnCompare;
+};
+Filter.prototype.getCondition = function () {
+  return this.oCondition;
+};
+Filter.prototype.getOperator = function () {
+  return this.sOperator;
+};
+Filter.prototype.getPath = function () {
+  return this.sPath;
+};
+Filter.prototype.getFilters = function () {
+  return this.aFilters && this.aFilters.slice();
+};
+Filter.prototype.getTest = function () {
+  return this.fnTest;
+};
+Filter.prototype.getValue1 = function () {
+  return this.oValue1;
+};
+Filter.prototype.getValue2 = function () {
+  return this.oValue2;
+};
+Filter.prototype.getVariable = function () {
+  return this.sVariable;
+};
+Filter.prototype.isAnd = function () {
+  return !!this.bAnd;
+};
+Filter.prototype.isCaseSensitive = function () {
+  return this.bCaseSensitive;
+};
+Filter.defaultComparator = function (a, b) {
+  if (a == b) {
+    return 0;
+  }
+  if (a == null || b == null) {
+    return NaN;
+  }
+  if (typeof a == "string" && typeof b == "string") {
+    return a.localeCompare(b, Localization.getLanguageTag().toString());
+  }
+  if (a < b) {
+    return -1;
+  }
+  if (a > b) {
+    return 1;
+  }
+  return NaN;
+};
+
 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, ")");
@@ -4175,7 +6078,12 @@ _Helper = {
   createMissing: function (oObject, aSegments) {
     aSegments.reduce(function (oCurrent, sSegment, i) {
       if (!((sSegment in oCurrent))) {
-        oCurrent[sSegment] = i + 1 < aSegments.length ? {} : null;
+        if (i + 1 < aSegments.length) {
+          oCurrent[sSegment] = {};
+        } else {
+          oCurrent[sSegment] = undefined;
+          oCurrent[sSegment + "@$ui5.noData"] = true;
+        }
       }
       return oCurrent[sSegment];
     }, oObject);
@@ -4465,6 +6373,27 @@ _Helper = {
   getContentID: function (oMessage) {
     return _Helper.getAnnotation(oMessage, ".ContentID");
   },
+  getFilterForPredicate: function (sPredicate, oEntityType, oMetaModel, sMetaPath, bIgnore$Key) {
+    var aFilters, mValueByKeyOrAlias = _Parser$1.parseKeyPredicate(sPredicate);
+    if (("" in mValueByKeyOrAlias)) {
+      mValueByKeyOrAlias[oEntityType.$Key[0]] = mValueByKeyOrAlias[""];
+      delete mValueByKeyOrAlias[""];
+    }
+    aFilters = (bIgnore$Key ? Object.keys(mValueByKeyOrAlias) : oEntityType.$Key).map(function (vKey) {
+      var sKeyOrAlias, sKeyPath;
+      if (typeof vKey === "string") {
+        sKeyPath = sKeyOrAlias = vKey;
+      } else {
+        sKeyOrAlias = Object.keys(vKey)[0];
+        sKeyPath = vKey[sKeyOrAlias];
+      }
+      return new Filter(sKeyPath, FilterOperator.EQ, _Helper.parseLiteral(decodeURIComponent(mValueByKeyOrAlias[sKeyOrAlias]), oMetaModel.getObject(sMetaPath + "/" + sKeyPath + "/$Type"), sKeyPath));
+    });
+    return aFilters.length === 1 ? aFilters[0] : new Filter({
+      and: true,
+      filters: aFilters
+    });
+  },
   getKeyFilter: function (oInstance, sMetaPath, mTypeForMetaPath, aKeyProperties) {
     var aFilters = [], sKey, mKey2Value = _Helper.getKeyProperties(oInstance, sMetaPath, mTypeForMetaPath, aKeyProperties);
     if (!mKey2Value) {
@@ -4616,6 +6545,9 @@ _Helper = {
         oSource = oSource[sSegment];
         oTarget = oTarget[sSegment];
       } else if (bMissing) {
+        if (oSource[sSegment + "@$ui5.noData"]) {
+          oTarget[sSegment + "@$ui5.noData"] = true;
+        }
         oTarget[sSegment] = oSource[sSegment];
       }
     });
@@ -4760,8 +6692,10 @@ _Helper = {
   mergeQueryOptions: function (mQueryOptions, sOrderby, aFilters) {
     var mResult;
     function set(sProperty, sValue) {
-      if (sValue && (!mQueryOptions || mQueryOptions[sProperty] !== sValue)) {
-        mResult ??= mQueryOptions ? _Helper.clone(mQueryOptions) : {};
+      if (sValue && mQueryOptions?.[sProperty] !== sValue) {
+        mResult ??= {
+          ...mQueryOptions
+        };
         mResult[sProperty] = sValue;
       }
     }
@@ -4769,6 +6703,7 @@ _Helper = {
     if (aFilters) {
       set("$filter", aFilters[0]);
       set("$$filterBeforeAggregate", aFilters[1]);
+      set("$$filterOnAggregate", aFilters[2]);
     }
     return mResult || mQueryOptions;
   },