@sapui5/sap.fe.core 1.127.2 → 1.129.0

package/src/sap/fe/core/definition/FEDefinition.js

@@ -0,0 +1,2550 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2024 SAP SE. All rights reserved
+ */
+ sap.ui.define([], function() {
+ 	var FEDefinition;
+/******/ (function() { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 462:
+/***/ (function(__unused_webpack_module, exports) {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.Placement = exports.BaseDefinition = void 0;
+exports.annotation = annotation;
+exports.configurable = configurable;
+let Placement = exports.Placement = /*#__PURE__*/function (Placement) {
+  Placement["After"] = "After";
+  Placement["Before"] = "Before";
+  Placement["End"] = "End";
+  return Placement;
+}({});
+class BaseDefinition {
+  constructor(metaPath, configuration) {
+    this.annotationPath = metaPath?.getPath();
+    for (const configurablePropertiesKey in this.__configurableProperties) {
+      const configSettings = this.__configurableProperties[configurablePropertiesKey];
+      if (configSettings) {
+        const configurationValue = configuration[configSettings.aliasFor];
+        if (configurationValue !== undefined) {
+          this[configurablePropertiesKey] = configSettings.validator(configurationValue);
+        } else {
+          this[configurablePropertiesKey] = configSettings.defaultValue;
+        }
+      }
+    }
+    const targetObject = metaPath?.getTarget();
+    if (targetObject) {
+      for (const annotationPropertiesKey in this.__annotationProperties) {
+        const configSettings = this.__annotationProperties[annotationPropertiesKey];
+        if (configSettings) {
+          const configurationValue = targetObject.annotations._annotations?.[configSettings.term];
+          if (configurationValue !== undefined && configurationValue !== null) {
+            this[annotationPropertiesKey] = configurationValue.valueOf();
+          } else {
+            this[annotationPropertiesKey] = configSettings.defaultValue;
+          }
+        }
+      }
+    }
+  }
+  getConfiguration() {
+    const outObj = {};
+    for (const configurablePropertiesKey in this.__configurableProperties) {
+      const configSettings = this.__configurableProperties[configurablePropertiesKey];
+      if (configSettings) {
+        outObj[configSettings.aliasFor] = this[configurablePropertiesKey];
+      }
+    }
+    return outObj;
+  }
+}
+exports.BaseDefinition = BaseDefinition;
+function noop(value) {
+  return value;
+}
+function configurable(propertyConfiguration = {}) {
+  return function (target, propertyKey, propertyDescriptor) {
+    const localPropertyConfiguration = {
+      name: propertyKey,
+      validator: propertyConfiguration.validator || noop,
+      aliasFor: propertyConfiguration.aliasFor || propertyKey,
+      defaultValue: propertyDescriptor.initializer?.()
+    };
+    const targetPrototype = target.constructor.prototype;
+    if (!targetPrototype.__configurableProperties) {
+      targetPrototype.__configurableProperties = {};
+    }
+    delete propertyDescriptor?.initializer;
+    targetPrototype.__configurableProperties[propertyKey] = localPropertyConfiguration;
+  };
+}
+function annotation(annotationConfiguration) {
+  return function (target, propertyKey, propertyDescriptor) {
+    const localAnnotationConfiguration = {
+      name: propertyKey,
+      term: annotationConfiguration.term,
+      defaultValue: propertyDescriptor.initializer?.()
+    };
+    const targetPrototype = target.constructor.prototype;
+    if (!targetPrototype.__annotationProperties) {
+      targetPrototype.__annotationProperties = {};
+    }
+    targetPrototype.__annotationProperties[propertyKey] = localAnnotationConfiguration;
+    delete propertyDescriptor.initializer;
+    return propertyDescriptor;
+  }; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.;
+}
+
+
+/***/ }),
+
+/***/ 333:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+var _TypeGuards = __webpack_require__(331);
+function enhancePath(sBasePath, sPathAddition) {
+  if (sPathAddition) {
+    if (sPathAddition.startsWith("/")) {
+      return sPathAddition;
+    } else if (sPathAddition.startsWith("@")) {
+      return sBasePath + sPathAddition;
+    } else if (!sBasePath.endsWith("/")) {
+      return sBasePath + "/" + sPathAddition;
+    } else {
+      return sBasePath + sPathAddition;
+    }
+  }
+  return sBasePath;
+}
+/**
+ *
+ */
+class MetaPath {
+  /**
+   * Create the MetaPath object.
+   * @param convertedMetadata The current model converter output
+   * @param metaPath The current object metaPath
+   * @param contextPath The current context
+   */
+  constructor(convertedMetadata, metaPath, contextPath) {
+    this.convertedMetadata = convertedMetadata;
+    this.metaPath = metaPath;
+    this.contextPath = contextPath;
+    this.navigationProperties = [];
+    this.contextNavigationProperties = [];
+    this.absolutePath = enhancePath(contextPath, metaPath);
+    this.relativePath = this.absolutePath.replace(contextPath, "");
+    if (this.relativePath.startsWith("/")) {
+      this.relativePath = this.relativePath.substring(1);
+    }
+    const resolvedMetaPath = this.convertedMetadata.resolvePath(this.absolutePath);
+    const resolvedContextPath = this.convertedMetadata.resolvePath(contextPath);
+    if (resolvedMetaPath.target === undefined || resolvedMetaPath.target === null) {
+      throw new Error(`No annotation target found for ${metaPath}`);
+    }
+    this.targetObject = resolvedMetaPath.target;
+    let rootEntitySet;
+    let currentEntitySet;
+    let currentEntityType;
+    let navigatedPaths = [];
+    resolvedMetaPath.objectPath.forEach(objectPart => {
+      if ((0, _TypeGuards.isServiceObject)(objectPart)) {
+        switch (objectPart._type) {
+          case "NavigationProperty":
+            navigatedPaths.push(objectPart.name);
+            this.navigationProperties.push(objectPart);
+            currentEntityType = objectPart.targetType;
+            if (currentEntitySet?.navigationPropertyBinding.hasOwnProperty(navigatedPaths.join("/"))) {
+              currentEntitySet = currentEntitySet.navigationPropertyBinding[navigatedPaths.join("/")];
+              navigatedPaths = [];
+            }
+            break;
+          case "EntitySet":
+            if (rootEntitySet === undefined) {
+              rootEntitySet = objectPart;
+            }
+            currentEntitySet = objectPart;
+            currentEntityType = currentEntitySet.entityType;
+            break;
+          case "EntityType":
+            if (currentEntityType === undefined) {
+              currentEntityType = objectPart;
+            }
+            break;
+          default:
+            break;
+        }
+      }
+    });
+    resolvedContextPath.objectPath.forEach(objectPart => {
+      rootEntitySet = this.getResolvedContextPath(objectPart, currentEntityType, rootEntitySet);
+    });
+    if (rootEntitySet === undefined || currentEntityType === undefined) {
+      throw new Error("MetaPath doesn't contain an entitySet -> Should never happen");
+    }
+    this.serviceObjectPath = this.contextPath;
+    if (this.navigationProperties.length) {
+      this.serviceObjectPath += "/" + this.navigationProperties.map(nav => nav.name).join("/");
+    }
+    this.rootEntitySet = rootEntitySet;
+    this.currentEntitySet = currentEntitySet;
+    this.currentEntityType = currentEntityType;
+  }
+  getResolvedContextPath(objectPart, currentEntityType, rootEntitySet) {
+    if ((0, _TypeGuards.isServiceObject)(objectPart)) {
+      switch (objectPart._type) {
+        case "NavigationProperty":
+          this.contextNavigationProperties.push(objectPart);
+          break;
+        case "EntitySet":
+          if (this.contextRootEntitySet === undefined) {
+            this.contextRootEntitySet = objectPart;
+          }
+          if (rootEntitySet === undefined && objectPart.entityType === currentEntityType) {
+            rootEntitySet = objectPart;
+          }
+          break;
+        default:
+          break;
+      }
+    }
+    return rootEntitySet;
+  }
+  getContextPath() {
+    return this.contextPath;
+  }
+
+  /**
+   * Retrieve the absolute path for this MetaPath.
+   * @param sPathPart The path to evaluate
+   * @returns The absolute path
+   */
+  getPath(sPathPart) {
+    return enhancePath(this.absolutePath, sPathPart);
+  }
+
+  /**
+   * Retrieve the path relative to the context for this MetaPath.
+   * @param sPathPart The path to evaluate
+   * @returns The relative path
+   */
+  getRelativePath(sPathPart) {
+    return enhancePath(this.relativePath, sPathPart);
+  }
+
+  /**
+   * Retrieve the typed target for this object call.
+   * @returns The typed target object
+   */
+  getTarget() {
+    return this.targetObject;
+  }
+
+  /**
+   * Retrieve the closest entityset in the path.
+   * @returns The closest entityset
+   */
+  getClosestEntitySet() {
+    let closestEntitySet = this.rootEntitySet;
+    for (const navigationProperty of this.navigationProperties) {
+      const navigationPropertyBindingElement = closestEntitySet.navigationPropertyBinding[navigationProperty.name];
+      if (navigationPropertyBindingElement) {
+        closestEntitySet = navigationPropertyBindingElement;
+      }
+    }
+    return closestEntitySet;
+  }
+  getClosestEntityType() {
+    let closestEntityType = this.rootEntitySet.entityType;
+    for (const navigationProperty of this.navigationProperties) {
+      closestEntityType = navigationProperty.targetType;
+    }
+    return closestEntityType;
+  }
+
+  /**
+   * Retrieve the closest entityset in the path.
+   * @returns The closest entityset
+   */
+  getContextClosestEntitySet() {
+    let closestEntitySet = this.contextRootEntitySet;
+    if (closestEntitySet === undefined) {
+      return closestEntitySet;
+    }
+    const nonNullEntitySet = closestEntitySet;
+    for (const navigationProperty of this.contextNavigationProperties) {
+      if (nonNullEntitySet.navigationPropertyBinding[navigationProperty.name]) {
+        closestEntitySet = nonNullEntitySet.navigationPropertyBinding[navigationProperty.name];
+      }
+    }
+    return closestEntitySet;
+  }
+  getNavigationProperties() {
+    return this.navigationProperties;
+  }
+  getMetaPathForPath(targetPath) {
+    try {
+      return new MetaPath(this.convertedMetadata, enhancePath(this.serviceObjectPath, targetPath), this.contextPath);
+    } catch (_error) {
+      return undefined;
+    }
+  }
+  getMetaPathForObject(targetObject) {
+    if ((0, _TypeGuards.isAnnotationPath)(targetObject)) {
+      return this.getMetaPathForPath(targetObject.value);
+    } else if ((0, _TypeGuards.isPathAnnotationExpression)(targetObject)) {
+      return this.getMetaPathForPath(targetObject.path);
+    } else {
+      const metaPathApp = targetObject.fullyQualifiedName.replace(this.rootEntitySet.entityType.fullyQualifiedName, this.contextPath);
+      return new MetaPath(this.convertedMetadata, metaPathApp, this.contextPath);
+    }
+  }
+  getConvertedMetadata() {
+    return this.convertedMetadata;
+  }
+}
+exports["default"] = MetaPath;
+
+
+/***/ }),
+
+/***/ 438:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+var _BaseDefinition = __webpack_require__(462);
+var _EntitySet2 = _interopRequireDefault(__webpack_require__(827));
+var _TypeGuards = __webpack_require__(331);
+var _dec, _dec2, _dec3, _class, _descriptor, _descriptor2, _descriptor3;
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _initializerDefineProperty(e, i, r, l) { r && Object.defineProperty(e, i, { enumerable: r.enumerable, configurable: r.configurable, writable: r.writable, value: r.initializer ? r.initializer.call(l) : void 0 }); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _applyDecoratedDescriptor(i, e, r, n, l) { var a = {}; return Object.keys(n).forEach(function (i) { a[i] = n[i]; }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, ("value" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function (r, n) { return n(i, e, r) || r; }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a; }
+function _initializerWarningHelper(r, e) { throw Error("Decorating class property failed. Please ensure that transform-class-properties is enabled and runs after the decorators transform."); }
+let FilterField = (_dec = (0, _BaseDefinition.configurable)(), _dec2 = (0, _BaseDefinition.configurable)(), _dec3 = (0, _BaseDefinition.configurable)(), (_class = class FilterField extends _BaseDefinition.BaseDefinition {
+  get label() {
+    return this.filterFieldProperty.getTarget().annotations.Common?.Label?.toString() ?? this.filterFieldProperty.getTarget().name;
+  }
+  constructor(filterFieldProperty, filterFieldConfiguration) {
+    super(filterFieldProperty, filterFieldConfiguration);
+    _initializerDefineProperty(this, "group", _descriptor, this);
+    _initializerDefineProperty(this, "groupLabel", _descriptor2, this);
+    _initializerDefineProperty(this, "visible", _descriptor3, this);
+    this.filterFieldProperty = filterFieldProperty;
+  }
+}, (_descriptor = _applyDecoratedDescriptor(_class.prototype, "group", [_dec], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, "groupLabel", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor3 = _applyDecoratedDescriptor(_class.prototype, "visible", [_dec3], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+})), _class));
+class FilterBar {
+  constructor(selectionFields, filterBarConfiguration, metaPath) {
+    this.selectionFields = selectionFields;
+    this.filterBarConfiguration = filterBarConfiguration;
+    this.metaPath = metaPath;
+  }
+  getFilterGroups() {
+    const filterFacets = this.metaPath.getClosestEntityType().annotations.UI?.FilterFacets;
+    const filterFieldsGroup = {};
+    if (!filterFacets) {
+      const fieldGroups = Object.keys(this.metaPath.getClosestEntityType().annotations.UI ?? {}).filter(key => {
+        return key.startsWith("FieldGroup");
+      }).map(key => {
+        return this.metaPath.getClosestEntityType().annotations.UI?.[key];
+      });
+      for (const fieldGroup of fieldGroups) {
+        fieldGroup.Data.forEach(fieldGroupEntry => {
+          switch (fieldGroupEntry.$Type) {
+            case "com.sap.vocabularies.UI.v1.DataField":
+              {
+                const fieldGroupValue = fieldGroupEntry.Value;
+                if ((0, _TypeGuards.isPathAnnotationExpression)(fieldGroupValue) && fieldGroupValue.$target) {
+                  filterFieldsGroup[fieldGroupValue.$target.fullyQualifiedName] = {
+                    group: fieldGroup.fullyQualifiedName,
+                    groupLabel: fieldGroup.Label?.toString() ?? fieldGroup.annotations?.Common?.Label?.toString() ?? fieldGroup.qualifier
+                  };
+                }
+                break;
+              }
+            default:
+              // Not supported
+              break;
+          }
+        });
+      }
+    } else {
+      filterFacets.forEach(filterFacet => {
+        const filterFacetTarget = filterFacet.Target.$target;
+        if ((0, _TypeGuards.isAnnotationOfType)(filterFacetTarget, "com.sap.vocabularies.UI.v1.FieldGroupType")) {
+          filterFacetTarget.Data.forEach(fieldGroupEntry => {
+            switch (fieldGroupEntry.$Type) {
+              case "com.sap.vocabularies.UI.v1.DataField":
+                {
+                  const fieldGroupValue = fieldGroupEntry.Value;
+                  if ((0, _TypeGuards.isPathAnnotationExpression)(fieldGroupValue) && fieldGroupValue.$target) {
+                    filterFieldsGroup[fieldGroupValue.$target.fullyQualifiedName] = {
+                      group: filterFacet.ID?.toString(),
+                      groupLabel: filterFacet.Label?.toString()
+                    };
+                  }
+                  break;
+                }
+              default:
+                // Not supported
+                break;
+            }
+          });
+        }
+      });
+    }
+    return filterFieldsGroup;
+  }
+  getFilterFields() {
+    const filterGroups = this.getFilterGroups();
+    const consideredProperties = {};
+    const fromSelectionField = this.selectionFields.filter(_TypeGuards.isValidPropertyPathExpression).map(field => {
+      const metaPathForProperty = this.metaPath.getMetaPathForPath(field.value);
+      if (metaPathForProperty) {
+        consideredProperties[metaPathForProperty.getTarget().fullyQualifiedName] = true;
+        return new FilterField(metaPathForProperty, {
+          group: filterGroups[metaPathForProperty.getTarget().fullyQualifiedName]?.group,
+          groupLabel: filterGroups[metaPathForProperty.getTarget().fullyQualifiedName]?.groupLabel,
+          visible: true
+        });
+      }
+    }).filter(field => {
+      return !!field;
+    });
+    const nonFilterableProperties = new _EntitySet2.default(this.metaPath).getNonFilterableProperties();
+    this.metaPath.getClosestEntityType().entityProperties.forEach(property => {
+      if (!consideredProperties[property.fullyQualifiedName] && !nonFilterableProperties.includes(property) && property.targetType === undefined && property.annotations.UI?.Hidden?.valueOf() !== true) {
+        consideredProperties[property.fullyQualifiedName] = true;
+        fromSelectionField.push(new FilterField(this.metaPath.getMetaPathForPath(property.name), {
+          group: filterGroups[property.fullyQualifiedName]?.group,
+          groupLabel: filterGroups[property.fullyQualifiedName]?.groupLabel,
+          visible: false
+        }));
+      }
+    });
+    return fromSelectionField;
+  }
+  isSearchSupported() {
+    return new _EntitySet2.default(this.metaPath).isSearchAllowed();
+  }
+}
+exports["default"] = FilterBar;
+
+
+/***/ }),
+
+/***/ 274:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.DefinitionPage = void 0;
+var _FilterBar = _interopRequireDefault(__webpack_require__(438));
+var _Identification2 = __webpack_require__(877);
+var _LineItem2 = __webpack_require__(384);
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class DefinitionPage {
+  constructor(metaPath) {
+    _defineProperty(this, "requestSet", new Set());
+    this.metaPath = metaPath;
+  }
+  getMetaPath() {
+    return this.metaPath;
+  }
+
+  /**
+   * Gets the target entity set identification annotation if available.
+   *
+   * @returns Identification annotation wrapper
+   */
+  getIdentification() {
+    const targetEntityType = this.metaPath.getClosestEntityType();
+    const idAnnotation = targetEntityType.annotations.UI?.Identification;
+    if (idAnnotation) {
+      return new _Identification2._Identification(idAnnotation, this.metaPath);
+    } else {
+      return undefined;
+    }
+  }
+
+  /**
+   * Retrieves the LineItem annotation for the target entity set
+   * @returns LineItem annotation
+   */
+  getTableVisualization() {
+    return _LineItem2._LineItem.fromSPV(this._getTableVisualizationAnnotation(), this.metaPath);
+  }
+  getFilterBarDefinition(filterBarConfiguration) {
+    const targetEntityType = this.metaPath.getClosestEntityType();
+    //this.tracer.markRequest("Page.getFilterBarDefinition", targetEntityType);
+    let selectionField = targetEntityType.annotations.UI?.SelectionFields;
+    if (!selectionField) {
+      selectionField = Object.assign([], {
+        term: "com.sap.vocabularies.UI.v1.SelectionFields"
+      });
+    }
+    //this.tracer.endMarkRequest("Page.getFilterBarDefinition");
+    return new _FilterBar.default(selectionField, filterBarConfiguration, this.metaPath);
+  }
+
+  /**
+   * Create a default LineItem annotation for the target entity type based on properties
+   * @returns LineItem annotation
+   */
+  createDefaultTableVisualization() {
+    return _LineItem2._LineItem.createDefault(this.metaPath);
+  }
+  _getTableVisualizationAnnotation() {
+    const targetEntityType = this.metaPath.getClosestEntityType();
+    const spv = targetEntityType.annotations.UI?.SelectionPresentationVariant;
+    if (spv) {
+      if (spv.PresentationVariant.Visualizations.find(v => v.$target?.term === "com.sap.vocabularies.UI.v1.LineItem")) {
+        return spv;
+      }
+    }
+    const pv = targetEntityType.annotations.UI?.PresentationVariant;
+    if (pv?.Visualizations) {
+      if (pv.Visualizations.find(v => v.$target?.term === "com.sap.vocabularies.UI.v1.LineItem")) {
+        return pv;
+      }
+    }
+    return targetEntityType.annotations.UI?.LineItem;
+  }
+  addDataToRequest(propertyPath) {
+    // Add data to request
+    this.requestSet.add(propertyPath);
+  }
+  getQueryComponents() {
+    const select = [];
+    const expand = [];
+    this.requestSet.forEach(property => {
+      const parts = property.split("/");
+      if (parts.length > 1 && parts[0]) {
+        expand.push(parts[0]);
+      } else {
+        select.push(property);
+      }
+    });
+    const query = {
+      $format: "json",
+      $select: select.join(",")
+    };
+    if (expand.length > 0) {
+      query.$expand = expand.join(",");
+    }
+    return query;
+  }
+}
+exports.DefinitionPage = DefinitionPage;
+
+
+/***/ }),
+
+/***/ 829:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+var _exportNames = {
+  DefinitionPage: true,
+  _DataField: true,
+  _LineItem: true,
+  DefinitionContext: true
+};
+Object.defineProperty(exports, "DefinitionContext", ({
+  enumerable: true,
+  get: function () {
+    return _DefinitionContext.DefinitionContext;
+  }
+}));
+Object.defineProperty(exports, "DefinitionPage", ({
+  enumerable: true,
+  get: function () {
+    return _DefinitionPage.DefinitionPage;
+  }
+}));
+Object.defineProperty(exports, "_DataField", ({
+  enumerable: true,
+  get: function () {
+    return _DataField._DataField;
+  }
+}));
+Object.defineProperty(exports, "_LineItem", ({
+  enumerable: true,
+  get: function () {
+    return _LineItem._LineItem;
+  }
+}));
+var _DefinitionPage = __webpack_require__(274);
+var _DataField = __webpack_require__(596);
+var _LineItem = __webpack_require__(384);
+var _DefinitionContext = __webpack_require__(747);
+var _TypeGuards = __webpack_require__(331);
+Object.keys(_TypeGuards).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _TypeGuards[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _TypeGuards[key];
+    }
+  });
+});
+
+
+/***/ }),
+
+/***/ 747:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.DefinitionContext = void 0;
+var _MetaPath = _interopRequireDefault(__webpack_require__(333));
+var _DefinitionPage = __webpack_require__(274);
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class DefinitionContext {
+  constructor(convertedMetadata) {
+    this.convertedMetadata = convertedMetadata;
+  }
+  addApplicationManifest(manifest) {
+    this.manifest = manifest;
+  }
+  getEntitySets() {
+    return this.convertedMetadata.entitySets;
+  }
+  getEntitySet(entitySetName) {
+    return this.convertedMetadata.entitySets.by_name(entitySetName);
+  }
+  getRootEntitySet() {
+    if (this.manifest) {
+      // Use the ui5 routing config to identify the root entityset
+      const initialRoutePattern = ":?query:";
+      const initialRoute = (this.manifest["sap.ui5"]?.routing?.routes).find(r => r.pattern === initialRoutePattern);
+      if (initialRoute?.target && this.manifest["sap.ui5"]?.routing?.targets) {
+        const target = this.manifest["sap.ui5"].routing.targets[initialRoute.target];
+        if (target?.name) {
+          const options = target.options;
+          const settings = options?.settings;
+          const entitySet = this.convertedMetadata.resolvePath(settings?.contextPath ?? `${settings?.entitySet}`);
+          return entitySet.target;
+        }
+      }
+    }
+    // Try to determine the root entity set from the metadata
+  }
+  getMetaPath(metaPath, contextPath) {
+    return new _MetaPath.default(this.convertedMetadata, metaPath, contextPath);
+  }
+  getPageFor(contextPath) {
+    // A page could point to
+    // - An entitySet (/SalesOrder)
+    // - A singleton (/Me)
+    // - A navigation property (/SalesOrder/Set)
+    return new _DefinitionPage.DefinitionPage(new _MetaPath.default(this.convertedMetadata, contextPath, contextPath));
+  }
+}
+exports.DefinitionContext = DefinitionContext;
+
+
+/***/ }),
+
+/***/ 827:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+var _BaseDefinition = __webpack_require__(462);
+class _EntitySet extends _BaseDefinition.BaseDefinition {
+  constructor(entitySet, entitySetConfiguration = {}) {
+    super(entitySet, entitySetConfiguration);
+    this.entitySet = entitySet;
+    this.entitySetConfiguration = entitySetConfiguration;
+  }
+  //
+  // @annotation({
+  // 	term: CapabilitiesAnnotationTerms.FilterRestrictions,
+  // 	processor: (filterRestrictions?: FilterRestrictions): Property[] => {
+  // 		const requiredProperties =
+  // 			filterRestrictions?.RequiredProperties ?? [];
+  // 		return requiredProperties
+  // 			.map((propertyPath) => {
+  // 				return propertyPath.$target;
+  // 			})
+  // 			.filter((property): property is Property => {
+  // 				return !!property;
+  // 			});
+  // 	}
+  // })
+  // requiredProperties: Property[];
+
+  /**
+   * Retrieves the required properties for the entity set.
+   */
+  getRequiredProperties() {
+    const requiredProperties = this.entitySet.getTarget().annotations.Capabilities?.FilterRestrictions?.RequiredProperties ?? [];
+    return requiredProperties.map(propertyPath => {
+      return propertyPath.$target;
+    }).filter(property => {
+      return !!property;
+    });
+  }
+
+  /**
+   * Retrieves the required properties for the entity set.
+   */
+  getNonFilterableProperties() {
+    const nonFilterableProperties = this.entitySet.getTarget().annotations.Capabilities?.FilterRestrictions?.NonFilterableProperties ?? [];
+    return nonFilterableProperties.map(propertyPath => {
+      return propertyPath.$target;
+    }).filter(property => {
+      return !!property;
+    });
+  }
+
+  /**
+   * Retrieves the required properties for the entity set.
+   * @param property
+   */
+  getAllowedFilterExpression(property) {
+    const filterExpressionRestrictions = this.entitySet.getTarget().annotations.Capabilities?.FilterRestrictions?.FilterExpressionRestrictions ?? [];
+    const propertyRestrictions = filterExpressionRestrictions.filter(filterExpressionRestriction => filterExpressionRestriction.Property?.$target === property);
+    return propertyRestrictions.map(propertyRestriction => {
+      return propertyRestriction.AllowedExpressions;
+    }).filter(propertyRestriction => {
+      return !!propertyRestriction;
+    });
+  }
+  isSearchAllowed() {
+    return !!this.entitySet.getTarget().annotations.Capabilities?.SearchRestrictions?.Searchable;
+  }
+}
+exports["default"] = _EntitySet;
+
+
+/***/ }),
+
+/***/ 596:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports._DataField = void 0;
+var _Expression = __webpack_require__(238);
+var _TypeGuards = __webpack_require__(331);
+class _DataField {
+  constructor(dataField, pageMetaPath) {
+    this.dataField = dataField;
+    this.pageMetaPath = pageMetaPath;
+  }
+  getValue() {
+    return (0, _Expression.getExpressionFromAnnotation)(this.dataField.Value);
+  }
+  getFormattedValue() {
+    // Compute display mode and then return the formatted value
+    // Also consider units and currency
+    const targetValue = (0, _Expression.getExpressionFromAnnotation)(this.dataField.Value);
+    return (0, _Expression.transformRecursively)(targetValue, "PathInModel", value => {
+      const propertyMetaPath = this.pageMetaPath.getMetaPathForPath(value.path);
+      if (!propertyMetaPath) {
+        return _Expression.unresolvableExpression;
+      }
+      const measure = this.getMeasure(propertyMetaPath);
+      if (measure) {
+        return (0, _Expression.concat)(value, " ", measure);
+      }
+      const displayMode = this.getDisplayMode(propertyMetaPath);
+      if (displayMode !== "Value") {
+        const text = (0, _Expression.getExpressionFromAnnotation)(propertyMetaPath.getTarget().annotations.Common?.Text);
+        if (displayMode === "Description") {
+          return text;
+        } else if (displayMode === "DescriptionValue") {
+          return (0, _Expression.concat)(text, " (", value, ")");
+        } else if (displayMode === "ValueDescription") {
+          return (0, _Expression.concat)(value, (0, _Expression.ifElse)((0, _Expression.notEqual)(text, undefined), (0, _Expression.concat)(" (", text, ")"), ""));
+        }
+      }
+      return value;
+    });
+  }
+
+  /**
+   * Checks if the given property has a Unit or ISOCurrency annotation and returns it.
+   *
+   * @param property property to get the measure for
+   * @returns the measure annotation or undefined
+   */
+  getMeasure(property) {
+    const measures = property.getTarget().annotations.Measures;
+    if (measures) {
+      const measure = measures.Unit ?? measures.ISOCurrency;
+      if (measure) {
+        return (0, _Expression.getExpressionFromAnnotation)(measure);
+      }
+    }
+    return undefined;
+  }
+  getDisplayMode(property) {
+    const currentEntityType = property.getClosestEntityType();
+    const textAnnotation = property.getTarget().annotations.Common?.Text;
+    const textArrangement = textAnnotation?.annotations?.UI?.TextArrangement ?? currentEntityType.annotations.UI?.TextArrangement;
+    let displayMode = textAnnotation ? "DescriptionValue" : "Value";
+    if (textAnnotation && textArrangement != null) {
+      if (textArrangement === "UI.TextArrangementType/TextOnly") {
+        displayMode = "Description";
+      } else if (textArrangement === "UI.TextArrangementType/TextLast") {
+        displayMode = "ValueDescription";
+      } else if (textArrangement === "UI.TextArrangementType/TextSeparate") {
+        displayMode = "Value";
+      } else {
+        //Default should be TextFirst if there is a Text annotation and neither TextOnly nor TextLast are set
+        displayMode = "DescriptionValue";
+      }
+    }
+    return displayMode;
+  }
+  getLabel() {
+    let label = this.dataField.Label?.toString() ?? this.dataField.annotations?.Common?.Label?.toString();
+    if (!label) {
+      const valueTarget = this.dataField.Value;
+      if ((0, _TypeGuards.isPathAnnotationExpression)(valueTarget)) {
+        label = valueTarget.$target?.annotations.Common?.Label?.toString() ?? valueTarget.$target?.name ?? valueTarget.path;
+      } else {
+        label = this.dataField.fullyQualifiedName;
+      }
+    }
+    return label;
+  }
+
+  /**
+   * Retrieve a property from the data field IF it can be easily determined (no complex exression)
+   */
+  getProperty() {
+    const valueTarget = this.dataField.Value;
+    if ((0, _TypeGuards.isPathAnnotationExpression)(valueTarget)) {
+      return valueTarget.$target;
+    }
+  }
+  getFullyQualifiedName() {
+    return this.dataField.fullyQualifiedName;
+  }
+}
+exports._DataField = _DataField;
+
+
+/***/ }),
+
+/***/ 877:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports._Identification = void 0;
+var _DataField2 = __webpack_require__(596);
+class _Identification {
+  constructor(id, pageMetaPath) {
+    this.id = id;
+    this.pageMetaPath = pageMetaPath;
+  }
+  getDataFields(options) {
+    return this.id.filter(item => {
+      if (options?.restrictTypes && !options.restrictTypes.includes(item.$Type)) {
+        return false;
+      }
+      switch (item.$Type) {
+        case "com.sap.vocabularies.UI.v1.DataField":
+        case "com.sap.vocabularies.UI.v1.DataFieldWithUrl":
+        case "com.sap.vocabularies.UI.v1.DataFieldWithAction":
+        case "com.sap.vocabularies.UI.v1.DataFieldWithActionGroup":
+        case "com.sap.vocabularies.UI.v1.DataFieldWithIntentBasedNavigation":
+        case "com.sap.vocabularies.UI.v1.DataFieldWithNavigationPath":
+        case "com.sap.vocabularies.UI.v1.DataFieldForAnnotation":
+        case "com.sap.vocabularies.UI.v1.DataFieldForAction":
+        case "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation":
+        case "com.sap.vocabularies.UI.v1.DataFieldForActionGroup":
+          return options?.importance === undefined || options.importance.includes(item.annotations?.UI?.Importance?.toString());
+        default:
+          return false;
+      }
+    }).map(item => {
+      return new _DataField2._DataField(item, this.pageMetaPath);
+    });
+  }
+}
+exports._Identification = _Identification;
+
+
+/***/ }),
+
+/***/ 384:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports._LineItem = void 0;
+var _DataField2 = __webpack_require__(596);
+class _LineItem {
+  constructor(lineItem, pageMetaPath) {
+    this.lineItem = lineItem;
+    this.pageMetaPath = pageMetaPath;
+  }
+  static createDefault(pageMetaPath) {
+    const fakeLineItemAnnotation = pageMetaPath.getClosestEntityType().entityProperties.map(prop => {
+      if (prop.annotations.UI?.DataFieldDefault) {
+        return prop.annotations.UI.DataFieldDefault;
+      } else {
+        return {
+          $Type: "com.sap.vocabularies.UI.v1.DataField",
+          Value: {
+            type: "Path",
+            path: prop.name,
+            $target: prop
+          }
+        };
+      }
+    });
+    fakeLineItemAnnotation.term = "com.sap.vocabularies.UI.v1.LineItem";
+    return new _LineItem(fakeLineItemAnnotation, pageMetaPath);
+  }
+  static fromSPV(spv, pageMetaPath) {
+    switch (spv?.term) {
+      case "com.sap.vocabularies.UI.v1.LineItem":
+        return new _LineItem(spv, pageMetaPath);
+      case "com.sap.vocabularies.UI.v1.PresentationVariant":
+        return new _LineItem(spv.Visualizations[0].$target, pageMetaPath);
+      case "com.sap.vocabularies.UI.v1.SelectionPresentationVariant":
+        return new _LineItem(spv.PresentationVariant.Visualizations[0].$target, pageMetaPath);
+      case undefined:
+        return undefined;
+    }
+  }
+  getActions() {
+    return this.lineItem.filter(item => item.$Type === "com.sap.vocabularies.UI.v1.DataFieldForAction");
+  }
+  getHeaderActions() {
+    return this.getActions().filter(action => action.Determining === true);
+  }
+  getDataFields(options) {
+    return this.lineItem.filter(item => {
+      if (options?.restrictTypes && !options.restrictTypes.includes(item.$Type)) {
+        return false;
+      }
+      switch (item.$Type) {
+        case "com.sap.vocabularies.UI.v1.DataField":
+        case "com.sap.vocabularies.UI.v1.DataFieldWithUrl":
+        case "com.sap.vocabularies.UI.v1.DataFieldWithAction":
+        case "com.sap.vocabularies.UI.v1.DataFieldWithActionGroup":
+        case "com.sap.vocabularies.UI.v1.DataFieldWithIntentBasedNavigation":
+        case "com.sap.vocabularies.UI.v1.DataFieldWithNavigationPath":
+        case "com.sap.vocabularies.UI.v1.DataFieldForAnnotation":
+        case "com.sap.vocabularies.UI.v1.DataFieldForAction":
+        case "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation":
+        case "com.sap.vocabularies.UI.v1.DataFieldForActionGroup":
+          return options?.importance === undefined || options.importance.includes(item.annotations?.UI?.Importance?.toString());
+        default:
+          return false;
+      }
+    }).map(item => {
+      return new _DataField2._DataField(item, this.pageMetaPath);
+    });
+  }
+}
+exports._LineItem = _LineItem;
+
+
+/***/ }),
+
+/***/ 238:
+/***/ (function(__unused_webpack_module, exports) {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports._checkExpressionsAreEqual = _checkExpressionsAreEqual;
+exports.and = and;
+exports.annotationApplyExpression = annotationApplyExpression;
+exports.annotationIfExpression = annotationIfExpression;
+exports.concat = concat;
+exports.constant = constant;
+exports.equal = equal;
+exports.fn = fn;
+exports.formatResult = formatResult;
+exports.getExpressionFromAnnotation = getExpressionFromAnnotation;
+exports.getFiscalType = void 0;
+exports.greaterOrEqual = greaterOrEqual;
+exports.greaterThan = greaterThan;
+exports.hasUnresolvableExpression = hasUnresolvableExpression;
+exports.ifElse = ifElse;
+exports.isComplexTypeExpression = isComplexTypeExpression;
+exports.isConstant = isConstant;
+exports.isEmpty = isEmpty;
+exports.isExpression = isExpression;
+exports.isPathInModelExpression = isPathInModelExpression;
+exports.isTruthy = isTruthy;
+exports.isUndefinedExpression = isUndefinedExpression;
+exports.length = length;
+exports.lessOrEqual = lessOrEqual;
+exports.lessThan = lessThan;
+exports.not = not;
+exports.notEqual = notEqual;
+exports.objectPath = objectPath;
+exports.or = or;
+exports.pathInModel = pathInModel;
+exports.ref = ref;
+exports.resolveBindingString = resolveBindingString;
+exports.transformRecursively = transformRecursively;
+exports.unresolvableExpression = void 0;
+exports.wrapPrimitive = wrapPrimitive;
+/**
+ */
+
+/**
+ * An expression that evaluates to type T.
+ *
+ */
+
+/**
+ * An expression that evaluates to type T, or a constant value of type T
+ */
+
+const unresolvableExpression = exports.unresolvableExpression = {
+  _type: "Unresolvable"
+};
+function hasUnresolvableExpression(...expressions) {
+  return expressions.find(expr => expr._type === "Unresolvable") !== undefined;
+}
+/**
+ * Check two expressions for (deep) equality.
+ *
+ * @param a
+ * @param b
+ * @returns `true` if the two expressions are equal
+ */
+function _checkExpressionsAreEqual(a, b) {
+  if (!a || !b) {
+    return false;
+  }
+  if (a._type !== b._type) {
+    return false;
+  }
+  switch (a._type) {
+    case "Unresolvable":
+      return false;
+    // Unresolvable is never equal to anything even itself
+    case "Constant":
+    case "EmbeddedBinding":
+    case "EmbeddedExpressionBinding":
+      return a.value === b.value;
+    case "Not":
+      return _checkExpressionsAreEqual(a.operand, b.operand);
+    case "Truthy":
+      return _checkExpressionsAreEqual(a.operand, b.operand);
+    case "Set":
+      return a.operator === b.operator && a.operands.length === b.operands.length && a.operands.every(expression => b.operands.some(otherExpression => _checkExpressionsAreEqual(expression, otherExpression)));
+    case "IfElse":
+      return _checkExpressionsAreEqual(a.condition, b.condition) && _checkExpressionsAreEqual(a.onTrue, b.onTrue) && _checkExpressionsAreEqual(a.onFalse, b.onFalse);
+    case "Comparison":
+      return a.operator === b.operator && _checkExpressionsAreEqual(a.operand1, b.operand1) && _checkExpressionsAreEqual(a.operand2, b.operand2);
+    case "Concat":
+      {
+        const aExpressions = a.expressions;
+        const bExpressions = b.expressions;
+        if (aExpressions.length !== bExpressions.length) {
+          return false;
+        }
+        return aExpressions.every((expression, index) => {
+          return _checkExpressionsAreEqual(expression, bExpressions[index]);
+        });
+      }
+    case "Length":
+      return _checkExpressionsAreEqual(a.pathInModel, b.pathInModel);
+    case "PathInModel":
+      return a.modelName === b.modelName && a.path === b.path && a.targetEntitySet === b.targetEntitySet;
+    case "Formatter":
+      return a.fn === b.fn && a.parameters.length === b.parameters.length && a.parameters.every((value, index) => _checkExpressionsAreEqual(b.parameters[index], value));
+    case "ComplexType":
+      return a.type === b.type && a.bindingParameters.length === b.bindingParameters.length && a.bindingParameters.every((value, index) => _checkExpressionsAreEqual(b.bindingParameters[index], value));
+    case "Function":
+      const otherFunction = b;
+      if (a.obj === undefined || otherFunction.obj === undefined) {
+        return a.obj === otherFunction;
+      }
+      return a.fn === otherFunction.fn && _checkExpressionsAreEqual(a.obj, otherFunction.obj) && a.parameters.length === otherFunction.parameters.length && a.parameters.every((value, index) => _checkExpressionsAreEqual(otherFunction.parameters[index], value));
+    case "Ref":
+      return a.ref === b.ref;
+  }
+  return false;
+}
+
+/**
+ * Converts a nested SetExpression by inlining operands of type SetExpression with the same operator.
+ *
+ * @param expression The expression to flatten
+ * @returns A new SetExpression with the same operator
+ */
+function flattenSetExpression(expression) {
+  return expression.operands.reduce((result, operand) => {
+    const candidatesForFlattening = operand._type === "Set" && operand.operator === expression.operator ? operand.operands : [operand];
+    candidatesForFlattening.forEach(candidate => {
+      if (result.operands.every(e => !_checkExpressionsAreEqual(e, candidate))) {
+        result.operands.push(candidate);
+      }
+    });
+    return result;
+  }, {
+    _type: "Set",
+    operator: expression.operator,
+    operands: []
+  });
+}
+
+/**
+ * Detects whether an array of boolean expressions contains an expression and its negation.
+ *
+ * @param expressions Array of expressions
+ * @returns `true` if the set of expressions contains an expression and its negation
+ */
+function hasOppositeExpressions(expressions) {
+  const negatedExpressions = expressions.map(not);
+  return expressions.some((expression, index) => {
+    for (let i = index + 1; i < negatedExpressions.length; i++) {
+      if (_checkExpressionsAreEqual(expression, negatedExpressions[i])) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+
+/**
+ * Logical `and` expression.
+ *
+ * The expression is simplified to false if this can be decided statically (that is, if one operand is a constant
+ * false or if the expression contains an operand and its negation).
+ *
+ * @param operands Expressions to connect by `and`
+ * @returns Expression evaluating to boolean
+ */
+function and(...operands) {
+  const expressions = flattenSetExpression({
+    _type: "Set",
+    operator: "&&",
+    operands: operands.map(wrapPrimitive)
+  }).operands;
+  if (hasUnresolvableExpression(...expressions)) {
+    return unresolvableExpression;
+  }
+  let isStaticFalse = false;
+  const nonTrivialExpression = expressions.filter(expression => {
+    if (isFalse(expression)) {
+      isStaticFalse = true;
+    }
+    return !isConstant(expression);
+  });
+  if (isStaticFalse) {
+    return constant(false);
+  } else if (nonTrivialExpression.length === 0) {
+    // Resolve the constant then
+    const isValid = expressions.reduce((result, expression) => result && isTrue(expression), true);
+    return constant(isValid);
+  } else if (nonTrivialExpression.length === 1) {
+    return nonTrivialExpression[0];
+  } else if (hasOppositeExpressions(nonTrivialExpression)) {
+    return constant(false);
+  } else {
+    return {
+      _type: "Set",
+      operator: "&&",
+      operands: nonTrivialExpression
+    };
+  }
+}
+
+// let tracer: any;
+// export function traceExpression(inTracer: never): void {
+// 	tracer = inTracer;
+// }
+//
+// export function pickFirstNonNull(
+// 	...operands: ExpressionOrPrimitive<PrimitiveType>[]
+// ): ExpressionOrPrimitive<PrimitiveType> {
+// 	const result = operands.find((operand) => operand !== undefined);
+// 	if (tracer) {
+// 		tracer.logConditional("pickFirstNonNull", operands, result);
+// 	}
+// 	return result;
+// }
+/**
+ * Logical `or` expression.
+ *
+ * The expression is simplified to true if this can be decided statically (that is, if one operand is a constant
+ * true or if the expression contains an operand and its negation).
+ *
+ * @param operands Expressions to connect by `or`
+ * @returns Expression evaluating to boolean
+ */
+function or(...operands) {
+  const expressions = flattenSetExpression({
+    _type: "Set",
+    operator: "||",
+    operands: operands.map(wrapPrimitive)
+  }).operands;
+  if (hasUnresolvableExpression(...expressions)) {
+    return unresolvableExpression;
+  }
+  let isStaticTrue = false;
+  const nonTrivialExpression = expressions.filter(expression => {
+    if (isTrue(expression)) {
+      isStaticTrue = true;
+    }
+    return !isConstant(expression) || expression.value;
+  });
+  if (isStaticTrue) {
+    return constant(true);
+  } else if (nonTrivialExpression.length === 0) {
+    // Resolve the constant then
+    const isValid = expressions.reduce((result, expression) => result && isTrue(expression), true);
+    return constant(isValid);
+  } else if (nonTrivialExpression.length === 1) {
+    return nonTrivialExpression[0];
+  } else if (hasOppositeExpressions(nonTrivialExpression)) {
+    return constant(true);
+  } else {
+    return {
+      _type: "Set",
+      operator: "||",
+      operands: nonTrivialExpression
+    };
+  }
+}
+
+/**
+ * Logical `not` operator.
+ *
+ * @param operand The expression to reverse
+ * @returns The resulting expression that evaluates to boolean
+ */
+function not(operand) {
+  operand = wrapPrimitive(operand);
+  if (hasUnresolvableExpression(operand)) {
+    return unresolvableExpression;
+  } else if (isConstant(operand)) {
+    return constant(!operand.value);
+  } else if (typeof operand === "object" && operand._type === "Set" && operand.operator === "||" && operand.operands.every(expression => isConstant(expression) || isComparison(expression))) {
+    return and(...operand.operands.map(expression => not(expression)));
+  } else if (typeof operand === "object" && operand._type === "Set" && operand.operator === "&&" && operand.operands.every(expression => isConstant(expression) || isComparison(expression))) {
+    return or(...operand.operands.map(expression => not(expression)));
+  } else if (isComparison(operand)) {
+    // Create the reverse comparison
+    switch (operand.operator) {
+      case "!==":
+        return {
+          ...operand,
+          operator: "==="
+        };
+      case "<":
+        return {
+          ...operand,
+          operator: ">="
+        };
+      case "<=":
+        return {
+          ...operand,
+          operator: ">"
+        };
+      case "===":
+        return {
+          ...operand,
+          operator: "!=="
+        };
+      case ">":
+        return {
+          ...operand,
+          operator: "<="
+        };
+      case ">=":
+        return {
+          ...operand,
+          operator: "<"
+        };
+    }
+  } else if (operand._type === "Not") {
+    return operand.operand;
+  }
+  return {
+    _type: "Not",
+    operand: operand
+  };
+}
+
+/**
+ * Evaluates whether a binding expression is equal to true with a loose equality.
+ *
+ * @param operand The expression to check
+ * @returns The resulting expression that evaluates to boolean
+ */
+function isTruthy(operand) {
+  if (isConstant(operand)) {
+    return constant(!!operand.value);
+  } else {
+    return {
+      _type: "Truthy",
+      operand: operand
+    };
+  }
+}
+
+/**
+ * Creates a binding expression that will be evaluated by the corresponding model.
+ *
+ * @param path
+ * @param modelName
+ * @param visitedNavigationPaths
+ * @param pathVisitor
+ * @returns An expression representating that path in the model
+ */
+function objectPath(path, modelName, visitedNavigationPaths = [], pathVisitor) {
+  return pathInModel(path, modelName, visitedNavigationPaths, pathVisitor);
+}
+
+/**
+ * Creates a binding expression that will be evaluated by the corresponding model.
+ *
+ * @template TargetType
+ * @param path The path on the model
+ * @param [modelName] The name of the model
+ * @param [visitedNavigationPaths] The paths from the root entitySet
+ * @param [pathVisitor] A function to modify the resulting path
+ * @returns An expression representating that path in the model
+ */
+
+function pathInModel(path, modelName, visitedNavigationPaths = [], pathVisitor) {
+  if (path === undefined) {
+    return unresolvableExpression;
+  }
+  let targetPath;
+  if (pathVisitor) {
+    targetPath = pathVisitor(path);
+    if (targetPath === undefined) {
+      return unresolvableExpression;
+    }
+  } else {
+    const localPath = visitedNavigationPaths.concat();
+    localPath.push(path);
+    targetPath = localPath.join("/");
+  }
+  return {
+    _type: "PathInModel",
+    modelName: modelName,
+    path: targetPath
+  };
+}
+/**
+ * Creates a constant expression based on a primitive value.
+ *
+ * @template T
+ * @param value The constant to wrap in an expression
+ * @returns The constant expression
+ */
+function constant(value) {
+  let constantValue;
+  if (typeof value === "object" && value !== null && value !== undefined) {
+    if (Array.isArray(value)) {
+      constantValue = value.map(wrapPrimitive);
+    } else if (isPrimitiveObject(value)) {
+      constantValue = value.valueOf();
+    } else {
+      constantValue = Object.entries(value).reduce((plainExpression, [key, val]) => {
+        const wrappedValue = wrapPrimitive(val);
+        if (wrappedValue._type !== "Constant" || wrappedValue.value !== undefined) {
+          plainExpression[key] = wrappedValue;
+        }
+        return plainExpression;
+      }, {});
+    }
+  } else {
+    constantValue = value;
+  }
+  return {
+    _type: "Constant",
+    value: constantValue
+  };
+}
+function resolveBindingString(value, targetType) {
+  if (value !== undefined && typeof value === "string" && value.startsWith("{")) {
+    const pathInModelRegex = /^{(.*)>(.+)}$/; // Matches model paths like "model>path" or ">path" (default model)
+    const pathInModelRegexMatch = pathInModelRegex.exec(value);
+    if (value.startsWith("{=")) {
+      // Expression binding, we can just remove the outer binding things
+      return {
+        _type: "EmbeddedExpressionBinding",
+        value: value
+      };
+    } else if (pathInModelRegexMatch) {
+      return pathInModel(pathInModelRegexMatch[2] || "", pathInModelRegexMatch[1] || undefined);
+    } else {
+      return {
+        _type: "EmbeddedBinding",
+        value: value
+      };
+    }
+  } else if (targetType === "boolean" && typeof value === "string" && (value === "true" || value === "false")) {
+    return constant(value === "true");
+  } else if (targetType === "number" && typeof value === "string" && (!isNaN(Number(value)) || value === "NaN")) {
+    return constant(Number(value));
+  } else {
+    return constant(value);
+  }
+}
+
+/**
+ * A named reference.
+ *
+ * @see fn
+ * @param reference Reference
+ * @returns The object reference binding part
+ */
+function ref(reference) {
+  return {
+    _type: "Ref",
+    ref: reference
+  };
+}
+
+/**
+ * Wrap a primitive into a constant expression if it is not already an expression.
+ *
+ * @template T
+ * @param something The object to wrap in a Constant expression
+ * @returns Either the original object or the wrapped one depending on the case
+ */
+function wrapPrimitive(something) {
+  if (isExpression(something)) {
+    return something;
+  }
+  return constant(something);
+}
+
+/**
+ * Checks if the expression or value provided is a binding tooling expression or not.
+ *
+ * Every object having a property named `_type` of some value is considered an expression, even if there is actually
+ * no such expression type supported.
+ *
+ * @param expression
+ * @returns `true` if the expression is a binding toolkit expression
+ */
+function isExpression(expression) {
+  return expression?._type !== undefined;
+}
+
+/**
+ * Checks if the expression or value provided is constant or not.
+ *
+ * @template T The target type
+ * @param  maybeConstant The expression or primitive value that is to be checked
+ * @returns `true` if it is constant
+ */
+function isConstant(maybeConstant) {
+  return typeof maybeConstant !== "object" || maybeConstant._type === "Constant";
+}
+function isTrue(expression) {
+  return isConstant(expression) && expression.value === true;
+}
+function isFalse(expression) {
+  return isConstant(expression) && expression.value === false;
+}
+
+/**
+ * Checks if the expression or value provided is a path in model expression or not.
+ *
+ * @template T The target type
+ * @param  maybeBinding The expression or primitive value that is to be checked
+ * @returns `true` if it is a path in model expression
+ */
+function isPathInModelExpression(maybeBinding) {
+  return maybeBinding._type === "PathInModel";
+}
+
+/**
+ * Checks if the expression or value provided is a complex type expression.
+ *
+ * @template T The target type
+ * @param  maybeBinding The expression or primitive value that is to be checked
+ * @returns `true` if it is a path in model expression
+ */
+function isComplexTypeExpression(maybeBinding) {
+  return maybeBinding._type === "ComplexType";
+}
+
+/**
+ * Checks if the expression or value provided is a concat expression or not.
+ *
+ * @param expression
+ * @returns `true` if the expression is a ConcatExpression
+ */
+function isConcatExpression(expression) {
+  return expression._type === "Concat";
+}
+
+/**
+ * Checks if the expression or value provided is a IfElse expression or not.
+ *
+ * @param expression
+ * @returns `true` if the expression is a IfElseExpression
+ */
+function isIfElseExpression(expression) {
+  return expression._type === "IfElse";
+}
+
+/**
+ * Checks if the expression provided is a comparison or not.
+ *
+ * @template T The target type
+ * @param expression The expression
+ * @returns `true` if the expression is a ComparisonExpression
+ */
+function isComparison(expression) {
+  return expression._type === "Comparison";
+}
+
+/**
+ * Checks whether the input parameter is a constant expression of type undefined.
+ *
+ * @param expression The input expression or object in general
+ * @returns `true` if the input is constant which has undefined for value
+ */
+function isUndefinedExpression(expression) {
+  const expressionAsExpression = expression;
+  return expressionAsExpression._type === "Constant" && expressionAsExpression.value === undefined;
+}
+function isPrimitiveObject(objectType) {
+  switch (objectType.constructor.name) {
+    case "String":
+    case "Number":
+    case "Boolean":
+      return true;
+    default:
+      return false;
+  }
+}
+/**
+ * Check if the passed annotation annotationValue is a ComplexAnnotationExpression.
+ *
+ * @template T The target type
+ * @param  annotationValue The annotation annotationValue to evaluate
+ * @returns `true` if the object is a {ComplexAnnotationExpression}
+ */
+function isComplexAnnotationExpression(annotationValue) {
+  return typeof annotationValue === "object" && !isPrimitiveObject(annotationValue);
+}
+
+/**
+ * Generate the corresponding annotationValue for a given annotation annotationValue.
+ *
+ * @template T The target type
+ * @param annotationValue The source annotation annotationValue
+ * @param visitedNavigationPaths The path from the root entity set
+ * @param defaultValue Default value if the annotationValue is undefined
+ * @param pathVisitor A function to modify the resulting path
+ * @returns The annotationValue equivalent to that annotation annotationValue
+ */
+function getExpressionFromAnnotation(annotationValue, visitedNavigationPaths = [], defaultValue, pathVisitor) {
+  if (annotationValue === undefined) {
+    return wrapPrimitive(defaultValue);
+  }
+  annotationValue = annotationValue.valueOf();
+  if (!isComplexAnnotationExpression(annotationValue)) {
+    return constant(annotationValue);
+  }
+  switch (annotationValue.type) {
+    case "Path":
+      return pathInModel(annotationValue.path, undefined, visitedNavigationPaths, pathVisitor);
+    case "If":
+      return annotationIfExpression(annotationValue.$If, visitedNavigationPaths, pathVisitor);
+    case "Not":
+      return not(parseAnnotationCondition(annotationValue.$Not, visitedNavigationPaths, pathVisitor));
+    case "Eq":
+      return equal(parseAnnotationCondition(annotationValue.$Eq[0], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue.$Eq[1], visitedNavigationPaths, pathVisitor));
+    case "Ne":
+      return notEqual(parseAnnotationCondition(annotationValue.$Ne[0], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue.$Ne[1], visitedNavigationPaths, pathVisitor));
+    case "Gt":
+      return greaterThan(parseAnnotationCondition(annotationValue.$Gt[0], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue.$Gt[1], visitedNavigationPaths, pathVisitor));
+    case "Ge":
+      return greaterOrEqual(parseAnnotationCondition(annotationValue.$Ge[0], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue.$Ge[1], visitedNavigationPaths, pathVisitor));
+    case "Lt":
+      return lessThan(parseAnnotationCondition(annotationValue.$Lt[0], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue.$Lt[1], visitedNavigationPaths, pathVisitor));
+    case "Le":
+      return lessOrEqual(parseAnnotationCondition(annotationValue.$Le[0], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue.$Le[1], visitedNavigationPaths, pathVisitor));
+    case "Or":
+      return or(...annotationValue.$Or.map(function (orCondition) {
+        return parseAnnotationCondition(orCondition, visitedNavigationPaths, pathVisitor);
+      }));
+    case "And":
+      return and(...annotationValue.$And.map(function (andCondition) {
+        return parseAnnotationCondition(andCondition, visitedNavigationPaths, pathVisitor);
+      }));
+    case "Apply":
+      return annotationApplyExpression(annotationValue, visitedNavigationPaths, pathVisitor);
+  }
+  return unresolvableExpression;
+}
+
+/**
+ * Parse the annotation condition into an expression.
+ *
+ * @template T The target type
+ * @param annotationValue The condition or value from the annotation
+ * @param visitedNavigationPaths The path from the root entity set
+ * @param pathVisitor A function to modify the resulting path
+ * @returns An equivalent expression
+ */
+function parseAnnotationCondition(annotationValue, visitedNavigationPaths = [], pathVisitor) {
+  if (annotationValue === null || typeof annotationValue !== "object") {
+    return constant(annotationValue);
+  } else if (annotationValue.hasOwnProperty("$Or")) {
+    return or(...annotationValue.$Or.map(function (orCondition) {
+      return parseAnnotationCondition(orCondition, visitedNavigationPaths, pathVisitor);
+    }));
+  } else if (annotationValue.hasOwnProperty("$And")) {
+    return and(...annotationValue.$And.map(function (andCondition) {
+      return parseAnnotationCondition(andCondition, visitedNavigationPaths, pathVisitor);
+    }));
+  } else if (annotationValue.hasOwnProperty("$Not")) {
+    return not(parseAnnotationCondition(annotationValue.$Not, visitedNavigationPaths, pathVisitor));
+  } else if (annotationValue.hasOwnProperty("$Eq")) {
+    return equal(parseAnnotationCondition(annotationValue.$Eq[0], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue.$Eq[1], visitedNavigationPaths, pathVisitor));
+  } else if (annotationValue.hasOwnProperty("$Ne")) {
+    return notEqual(parseAnnotationCondition(annotationValue.$Ne[0], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue.$Ne[1], visitedNavigationPaths, pathVisitor));
+  } else if (annotationValue.hasOwnProperty("$Gt")) {
+    return greaterThan(parseAnnotationCondition(annotationValue.$Gt[0], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue.$Gt[1], visitedNavigationPaths, pathVisitor));
+  } else if (annotationValue.hasOwnProperty("$Ge")) {
+    return greaterOrEqual(parseAnnotationCondition(annotationValue.$Ge[0], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue.$Ge[1], visitedNavigationPaths, pathVisitor));
+  } else if (annotationValue.hasOwnProperty("$Lt")) {
+    return lessThan(parseAnnotationCondition(annotationValue.$Lt[0], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue.$Lt[1], visitedNavigationPaths, pathVisitor));
+  } else if (annotationValue.hasOwnProperty("$Le")) {
+    return lessOrEqual(parseAnnotationCondition(annotationValue.$Le[0], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue.$Le[1], visitedNavigationPaths, pathVisitor));
+  } else if (annotationValue.hasOwnProperty("$Path")) {
+    return pathInModel(annotationValue.$Path, undefined, visitedNavigationPaths, pathVisitor);
+  } else if (annotationValue.hasOwnProperty("Path")) {
+    return pathInModel(annotationValue.Path, undefined, visitedNavigationPaths, pathVisitor);
+  } else if (annotationValue.hasOwnProperty("$Apply")) {
+    return getExpressionFromAnnotation({
+      type: "Apply",
+      $Function: annotationValue.$Function,
+      $Apply: annotationValue.$Apply
+    }, visitedNavigationPaths, undefined, pathVisitor);
+  } else if (annotationValue.hasOwnProperty("$If")) {
+    return getExpressionFromAnnotation({
+      type: "If",
+      $If: annotationValue.$If
+    }, visitedNavigationPaths, undefined, pathVisitor);
+  } else if (annotationValue.hasOwnProperty("$EnumMember")) {
+    return constant(annotationValue.$EnumMember);
+  } else if (annotationValue.hasOwnProperty("String")) {
+    return constant(annotationValue.String);
+  } else if (annotationValue.hasOwnProperty("Bool")) {
+    return constant(annotationValue.Bool);
+  } else if (annotationValue.hasOwnProperty("Int")) {
+    return constant(annotationValue.Int);
+  } else if (annotationValue.hasOwnProperty("Decimal")) {
+    return constant(annotationValue.Decimal);
+  } else if (annotationValue.hasOwnProperty("type") && annotationValue.type === "Null") {
+    return constant(null);
+  }
+  return constant(false);
+}
+
+/**
+ * Process the {IfAnnotationExpressionValue} into an expression.
+ *
+ * @template T The target type
+ * @param annotationValue An If expression returning the type T
+ * @param visitedNavigationPaths The path from the root entity set
+ * @param pathVisitor A function to modify the resulting path
+ * @returns The equivalent ifElse expression
+ */
+function annotationIfExpression(annotationValue, visitedNavigationPaths = [], pathVisitor) {
+  return ifElse(parseAnnotationCondition(annotationValue[0], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue[1], visitedNavigationPaths, pathVisitor), parseAnnotationCondition(annotationValue[2], visitedNavigationPaths, pathVisitor));
+}
+// This type is not recursively transformed from the metamodel content, as such we have some ugly things there
+
+function convertSubApplyParameters(applyParam) {
+  let applyParamConverted = applyParam;
+  if (applyParam.hasOwnProperty("$Path")) {
+    applyParamConverted = {
+      type: "Path",
+      path: applyParam.$Path
+    };
+  } else if (applyParam.hasOwnProperty("$If")) {
+    applyParamConverted = {
+      type: "If",
+      $If: applyParam.$If
+    };
+  } else if (applyParam.hasOwnProperty("$Apply")) {
+    applyParamConverted = {
+      type: "Apply",
+      $Function: applyParam.$Function,
+      $Apply: applyParam.$Apply
+    };
+  }
+  return applyParamConverted;
+}
+function annotationApplyExpression(applyExpression, visitedNavigationPaths = [], pathVisitor) {
+  switch (applyExpression.$Function) {
+    case "odata.concat":
+      return concat(...applyExpression.$Apply.map(applyParam => {
+        return getExpressionFromAnnotation(convertSubApplyParameters(applyParam), visitedNavigationPaths, undefined, pathVisitor);
+      }));
+    case "odata.uriEncode":
+      const parameter = getExpressionFromAnnotation(convertSubApplyParameters(applyExpression.$Apply[0]), visitedNavigationPaths, undefined, pathVisitor);
+      // The second parameter for uriEncode is always a string since the target evaluation is against a formatValue call in ODataUtils which expect the target type as second parameter
+      return fn("odata.uriEncode", [parameter, "Edm.String"], undefined, true);
+    case "odata.fillUriTemplate":
+      const template = applyExpression.$Apply[0];
+      const templateParams = applyExpression.$Apply.slice(1);
+      const targetObject = {};
+      templateParams.forEach(applyParam => {
+        targetObject[applyParam.$Name] = getExpressionFromAnnotation(convertSubApplyParameters(applyParam.$LabeledElement), visitedNavigationPaths, undefined, pathVisitor);
+      });
+      return fn("odata.fillUriTemplate", [template, targetObject], undefined, true);
+  }
+  return unresolvableExpression;
+}
+
+/**
+ * Generic helper for the comparison operations (equal, notEqual, ...).
+ *
+ * @template T The target type
+ * @param operator The operator to apply
+ * @param leftOperand The operand on the left side of the operator
+ * @param rightOperand The operand on the right side of the operator
+ * @returns An expression representing the comparison
+ */
+function comparison(operator, leftOperand, rightOperand) {
+  const leftExpression = wrapPrimitive(leftOperand);
+  const rightExpression = wrapPrimitive(rightOperand);
+  if (hasUnresolvableExpression(leftExpression, rightExpression)) {
+    return unresolvableExpression;
+  }
+  if (isConstant(leftExpression) && isConstant(rightExpression)) {
+    switch (operator) {
+      case "!==":
+        return constant(leftExpression.value !== rightExpression.value);
+      case "===":
+        return constant(leftExpression.value === rightExpression.value);
+      case "<":
+        if (leftExpression.value === null || leftExpression.value === undefined || rightExpression.value === null || rightExpression.value === undefined) {
+          return constant(false);
+        }
+        return constant(leftExpression.value < rightExpression.value);
+      case "<=":
+        if (leftExpression.value === null || leftExpression.value === undefined || rightExpression.value === null || rightExpression.value === undefined) {
+          return constant(false);
+        }
+        return constant(leftExpression.value <= rightExpression.value);
+      case ">":
+        if (leftExpression.value === null || leftExpression.value === undefined || rightExpression.value === null || rightExpression.value === undefined) {
+          return constant(false);
+        }
+        return constant(leftExpression.value > rightExpression.value);
+      case ">=":
+        if (leftExpression.value === null || leftExpression.value === undefined || rightExpression.value === null || rightExpression.value === undefined) {
+          return constant(false);
+        }
+        return constant(leftExpression.value >= rightExpression.value);
+    }
+  } else {
+    return {
+      _type: "Comparison",
+      operator: operator,
+      operand1: leftExpression,
+      operand2: rightExpression
+    };
+  }
+}
+
+/**
+ * Generic helper for the length of an expression.
+ *
+ * @param expression The input expression pointing to an array
+ * @param checkUndefined Is the array potentially undefined
+ * @returns An expression representing the length
+ */
+function length(expression, checkUndefined = false) {
+  if (expression._type === "Unresolvable") {
+    return expression;
+  }
+  if (!checkUndefined) {
+    return {
+      _type: "Length",
+      pathInModel: expression
+    };
+  }
+  return ifElse(equal(expression, undefined), -1, length(expression));
+}
+
+/**
+ * Comparison: "equal" (===).
+ *
+ * @template T The target type
+ * @param leftOperand The operand on the left side
+ * @param rightOperand The operand on the right side of the comparison
+ * @returns An expression representing the comparison
+ */
+function equal(leftOperand, rightOperand) {
+  const leftExpression = wrapPrimitive(leftOperand);
+  const rightExpression = wrapPrimitive(rightOperand);
+  if (hasUnresolvableExpression(leftExpression, rightExpression)) {
+    return unresolvableExpression;
+  }
+  if (_checkExpressionsAreEqual(leftExpression, rightExpression)) {
+    return constant(true);
+  }
+  function reduce(left, right) {
+    if (left._type === "Comparison" && isTrue(right)) {
+      // compare(a, b) === true ~~> compare(a, b)
+      return left;
+    } else if (left._type === "Comparison" && isFalse(right)) {
+      // compare(a, b) === false ~~> !compare(a, b)
+      return not(left);
+    } else if (left._type === "IfElse" && _checkExpressionsAreEqual(left.onTrue, right)) {
+      // (if (x) { a } else { b }) === a ~~> x || (b === a)
+      return or(left.condition, equal(left.onFalse, right));
+    } else if (left._type === "IfElse" && _checkExpressionsAreEqual(left.onFalse, right)) {
+      // (if (x) { a } else { b }) === b ~~> !x || (a === b)
+      return or(not(left.condition), equal(left.onTrue, right));
+    } else if (left._type === "IfElse" && isConstant(left.onTrue) && isConstant(left.onFalse) && isConstant(right) && !_checkExpressionsAreEqual(left.onTrue, right) && !_checkExpressionsAreEqual(left.onFalse, right)) {
+      return constant(false);
+    }
+    return undefined;
+  }
+
+  // exploit symmetry: a === b <~> b === a
+  const reduced = reduce(leftExpression, rightExpression) ?? reduce(rightExpression, leftExpression);
+  return reduced ?? comparison("===", leftExpression, rightExpression);
+}
+
+/**
+ * Comparison: "not equal" (!==).
+ *
+ * @template T The target type
+ * @param leftOperand The operand on the left side
+ * @param rightOperand The operand on the right side of the comparison
+ * @returns An expression representing the comparison
+ */
+function notEqual(leftOperand, rightOperand) {
+  return not(equal(leftOperand, rightOperand));
+}
+
+/**
+ * Comparison: "greater or equal" (>=).
+ *
+ * @template T The target type
+ * @param leftOperand The operand on the left side
+ * @param rightOperand The operand on the right side of the comparison
+ * @returns An expression representing the comparison
+ */
+function greaterOrEqual(leftOperand, rightOperand) {
+  return comparison(">=", leftOperand, rightOperand);
+}
+
+/**
+ * Comparison: "greater than" (>).
+ *
+ * @template T The target type
+ * @param leftOperand The operand on the left side
+ * @param rightOperand The operand on the right side of the comparison
+ * @returns An expression representing the comparison
+ */
+function greaterThan(leftOperand, rightOperand) {
+  return comparison(">", leftOperand, rightOperand);
+}
+
+/**
+ * Comparison: "less or equal" (<=).
+ *
+ * @template T The target type
+ * @param leftOperand The operand on the left side
+ * @param rightOperand The operand on the right side of the comparison
+ * @returns An expression representing the comparison
+ */
+function lessOrEqual(leftOperand, rightOperand) {
+  return comparison("<=", leftOperand, rightOperand);
+}
+
+/**
+ * Comparison: "less than" (<).
+ *
+ * @template T The target type
+ * @param leftOperand The operand on the left side
+ * @param rightOperand The operand on the right side of the comparison
+ * @returns An expression representing the comparison
+ */
+function lessThan(leftOperand, rightOperand) {
+  return comparison("<", leftOperand, rightOperand);
+}
+
+/**
+ * If-then-else expression.
+ *
+ * Evaluates to onTrue if the condition evaluates to true, else evaluates to onFalse.
+ *
+ * @template T The target type
+ * @param condition The condition to evaluate
+ * @param onTrue Expression result if the condition evaluates to true
+ * @param onFalse Expression result if the condition evaluates to false
+ * @returns The expression that represents this conditional check
+ */
+function ifElse(condition, onTrue, onFalse) {
+  let conditionExpression = wrapPrimitive(condition);
+  let onTrueExpression = wrapPrimitive(onTrue);
+  let onFalseExpression = wrapPrimitive(onFalse);
+
+  // swap branches if the condition is a negation
+  if (conditionExpression._type === "Not") {
+    // ifElse(not(X), a, b) --> ifElse(X, b, a)
+    [onTrueExpression, onFalseExpression] = [onFalseExpression, onTrueExpression];
+    conditionExpression = not(conditionExpression);
+  }
+
+  // inline nested if-else expressions: onTrue branch
+  // ifElse(X, ifElse(X, a, b), c) ==> ifElse(X, a, c)
+  if (onTrueExpression._type === "IfElse" && _checkExpressionsAreEqual(conditionExpression, onTrueExpression.condition)) {
+    onTrueExpression = onTrueExpression.onTrue;
+  }
+
+  // inline nested if-else expressions: onFalse branch
+  // ifElse(X, a, ifElse(X, b, c)) ==> ifElse(X, a, c)
+  if (onFalseExpression._type === "IfElse" && _checkExpressionsAreEqual(conditionExpression, onFalseExpression.condition)) {
+    onFalseExpression = onFalseExpression.onFalse;
+  }
+
+  // (if true then a else b)  ~~> a
+  // (if false then a else b) ~~> b
+  if (isConstant(conditionExpression)) {
+    return conditionExpression.value ? onTrueExpression : onFalseExpression;
+  }
+
+  // if (isConstantBoolean(onTrueExpression) || isConstantBoolean(onFalseExpression)) {
+  // 	return or(and(condition, onTrueExpression as Expression<boolean>), and(not(condition), onFalseExpression as Expression<boolean>)) as Expression<T>
+  // }
+
+  // (if X then a else a) ~~> a
+  if (_checkExpressionsAreEqual(onTrueExpression, onFalseExpression)) {
+    return onTrueExpression;
+  }
+
+  // if X then a else false ~~> X && a
+  if (isFalse(onFalseExpression)) {
+    return and(conditionExpression, onTrueExpression);
+  }
+
+  // if X then a else true ~~> !X || a
+  if (isTrue(onFalseExpression)) {
+    return or(not(conditionExpression), onTrueExpression);
+  }
+
+  // if X then false else a ~~> !X && a
+  if (isFalse(onTrueExpression)) {
+    return and(not(conditionExpression), onFalseExpression);
+  }
+
+  // if X then true else a ~~> X || a
+  if (isTrue(onTrueExpression)) {
+    return or(conditionExpression, onFalseExpression);
+  }
+  if (hasUnresolvableExpression(conditionExpression, onTrueExpression, onFalseExpression)) {
+    return unresolvableExpression;
+  }
+  if (isComplexTypeExpression(condition) || isComplexTypeExpression(onTrue) || isComplexTypeExpression(onFalse)) {
+    let pathIdx = 0;
+    const myIfElseExpression = formatResult([condition, onTrue, onFalse], "sap.fe.core.formatters.StandardFormatter#ifElse");
+    const allParts = [];
+    transformRecursively(myIfElseExpression, "PathInModel", constantPath => {
+      allParts.push(constantPath);
+      return pathInModel(`$${pathIdx++}`, "$");
+    }, true);
+    allParts.unshift(constant(JSON.stringify(myIfElseExpression)));
+    return formatResult(allParts, "sap.fe.core.formatters.StandardFormatter#evaluateComplexExpression", undefined, true);
+  }
+  return {
+    _type: "IfElse",
+    condition: conditionExpression,
+    onTrue: onTrueExpression,
+    onFalse: onFalseExpression
+  };
+}
+
+/**
+ * Checks whether the current expression has a reference to the default model (undefined).
+ *
+ * @param expression The expression to evaluate
+ * @returns `true` if there is a reference to the default context
+ */
+function hasReferenceToDefaultContext(expression) {
+  switch (expression._type) {
+    case "Constant":
+    case "Formatter":
+    case "ComplexType":
+      return false;
+    case "Set":
+      return expression.operands.some(hasReferenceToDefaultContext);
+    case "PathInModel":
+      return expression.modelName === undefined;
+    case "Comparison":
+      return hasReferenceToDefaultContext(expression.operand1) || hasReferenceToDefaultContext(expression.operand2);
+    case "IfElse":
+      return hasReferenceToDefaultContext(expression.condition) || hasReferenceToDefaultContext(expression.onTrue) || hasReferenceToDefaultContext(expression.onFalse);
+    case "Not":
+    case "Truthy":
+      return hasReferenceToDefaultContext(expression.operand);
+    default:
+      return false;
+  }
+}
+
+// This is one case where any does make sense...
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+
+// So, this works but I cannot get it to compile :D, but it still does what is expected...
+
+/**
+ * A function reference or a function name.
+ */
+
+/**
+ * Function parameters, either derived from the function or an untyped array.
+ */
+
+/**
+ * Calls a formatter function to process the parameters.
+ * If requireContext is set to true and no context is passed a default context will be added automatically.
+ *
+ * @template T
+ * @template U
+ * @param parameters The list of parameter that should match the type and number of the formatter function
+ * @param formatterFunction The function to call
+ * @param [contextEntityType] If no parameter refers to the context then we use this information to add a reference to the keys from the entity type.
+ * @param [ignoreComplexType] Whether to ignore the transgformation to the StandardFormatter or not
+ * @returns The corresponding expression
+ */
+function formatResult(parameters, formatterFunction, contextEntityType, ignoreComplexType = false) {
+  const parameterExpressions = parameters.map(wrapPrimitive);
+  if (hasUnresolvableExpression(...parameterExpressions)) {
+    return unresolvableExpression;
+  }
+  if (contextEntityType) {
+    // Otherwise, if the context is required and no context is provided make sure to add the default binding
+    if (!parameterExpressions.some(hasReferenceToDefaultContext)) {
+      contextEntityType.keys.forEach(key => parameterExpressions.push(pathInModel(key.name, "")));
+    }
+  }
+  let functionName = "";
+  if (typeof formatterFunction === "string") {
+    functionName = formatterFunction;
+  } else {
+    functionName = formatterFunction.__functionName;
+  }
+  // FormatterName can be of format sap.fe.core.xxx#methodName to have multiple formatter in one class
+  const [formatterClass, formatterName] = functionName.split("#");
+
+  // In some case we also cannot call directly a function because of too complex input, in that case we need to convert to a simpler function call
+  if (!ignoreComplexType && (parameterExpressions.some(isComplexTypeExpression) || parameterExpressions.some(isConcatExpression) || parameterExpressions.some(isIfElseExpression))) {
+    let pathIdx = 0;
+    const myFormatExpression = formatResult(parameterExpressions, functionName, undefined, true);
+    const allParts = [];
+    transformRecursively(myFormatExpression, "PathInModel", constantPath => {
+      allParts.push(constantPath);
+      return pathInModel(`$${pathIdx++}`, "$");
+    }, true);
+    allParts.unshift(constant(JSON.stringify(myFormatExpression)));
+    return formatResult(allParts, "sap.fe.core.formatters.StandardFormatter#evaluateComplexExpression", undefined, true);
+  } else if (!!formatterName && formatterName.length > 0) {
+    parameterExpressions.unshift(constant(formatterName));
+  }
+  return {
+    _type: "Formatter",
+    fn: formatterClass,
+    parameters: parameterExpressions
+  };
+}
+const getFiscalType = function (property) {
+  if (property.annotations.Common?.IsFiscalYear) {
+    return "com.sap.vocabularies.Common.v1.IsFiscalYear";
+  }
+  if (property.annotations.Common?.IsFiscalPeriod) {
+    return "com.sap.vocabularies.Common.v1.IsFiscalPeriod";
+  }
+  if (property.annotations.Common?.IsFiscalYearPeriod) {
+    return "com.sap.vocabularies.Common.v1.IsFiscalYearPeriod";
+  }
+  if (property.annotations.Common?.IsFiscalQuarter) {
+    return "com.sap.vocabularies.Common.v1.IsFiscalQuarter";
+  }
+  if (property.annotations.Common?.IsFiscalYearQuarter) {
+    return "com.sap.vocabularies.Common.v1.IsFiscalYearQuarter";
+  }
+  if (property.annotations.Common?.IsFiscalWeek) {
+    return "com.sap.vocabularies.Common.v1.IsFiscalWeek";
+  }
+  if (property.annotations.Common?.IsFiscalYearWeek) {
+    return "com.sap.vocabularies.Common.v1.IsFiscalYearWeek";
+  }
+  if (property.annotations.Common?.IsDayOfFiscalYear) {
+    return "com.sap.vocabularies.Common.v1.IsDayOfFiscalYear";
+  }
+};
+
+/**
+ * Function call, optionally with arguments.
+ *
+ * @param func Function name or reference to function
+ * @param parameters Arguments
+ * @param on Object to call the function on
+ * @param isFormattingFn
+ * @returns Expression representing the function call (not the result of the function call!)
+ */
+exports.getFiscalType = getFiscalType;
+function fn(func, parameters, on, isFormattingFn = false) {
+  const functionName = typeof func === "string" ? func : func.__functionName;
+  return {
+    _type: "Function",
+    obj: on !== undefined ? wrapPrimitive(on) : undefined,
+    fn: functionName,
+    isFormattingFn: isFormattingFn,
+    parameters: parameters.map(wrapPrimitive)
+  };
+}
+
+/**
+ * Shortcut function to determine if a binding value is null, undefined or empty.
+ *
+ * @param expression
+ * @returns A Boolean expression evaluating the fact that the current element is empty
+ */
+function isEmpty(expression) {
+  const aBindings = [];
+  transformRecursively(expression, "PathInModel", expr => {
+    aBindings.push(or(equal(expr, ""), equal(expr, undefined), equal(expr, null)));
+    return expr;
+  });
+  return and(...aBindings);
+}
+function concat(
+//eslint-disable-next-line @typescript-eslint/no-wrapper-object-types
+...inExpressions) {
+  const expressions = inExpressions.map(wrapPrimitive);
+  if (hasUnresolvableExpression(...expressions)) {
+    return unresolvableExpression;
+  }
+  if (expressions.every(isConstant)) {
+    return constant(expressions.reduce((concatenated, value) => {
+      if (value.value !== undefined && value.value !== null) {
+        return concatenated + value.value.toString();
+      }
+      return concatenated;
+    }, ""));
+  } else if (expressions.some(isComplexTypeExpression)) {
+    let pathIdx = 0;
+    const myConcatExpression = formatResult(expressions, "sap.fe.core.formatters.StandardFormatter#concat", undefined, true);
+    const allParts = [];
+    transformRecursively(myConcatExpression, "PathInModel", constantPath => {
+      allParts.push(constantPath);
+      return pathInModel(`$${pathIdx++}`, "$");
+    });
+    allParts.unshift(constant(JSON.stringify(myConcatExpression)));
+    return formatResult(allParts, "sap.fe.core.formatters.StandardFormatter#evaluateComplexExpression", undefined, true);
+  }
+  return {
+    _type: "Concat",
+    expressions: expressions
+  };
+}
+function transformRecursively(inExpression, expressionType, transformFunction, includeAllExpression = false) {
+  let expression = inExpression;
+  switch (expression._type) {
+    case "Function":
+    case "Formatter":
+      expression.parameters = expression.parameters.map(parameter => transformRecursively(parameter, expressionType, transformFunction, includeAllExpression));
+      break;
+    case "Concat":
+      expression.expressions = expression.expressions.map(subExpression => transformRecursively(subExpression, expressionType, transformFunction, includeAllExpression));
+      expression = concat(...expression.expressions);
+      break;
+    case "ComplexType":
+      expression.bindingParameters = expression.bindingParameters.map(bindingParameter => transformRecursively(bindingParameter, expressionType, transformFunction, includeAllExpression));
+      break;
+    case "IfElse":
+      {
+        const onTrue = transformRecursively(expression.onTrue, expressionType, transformFunction, includeAllExpression);
+        const onFalse = transformRecursively(expression.onFalse, expressionType, transformFunction, includeAllExpression);
+        let condition = expression.condition;
+        if (includeAllExpression) {
+          condition = transformRecursively(expression.condition, expressionType, transformFunction, includeAllExpression);
+        }
+        expression = ifElse(condition, onTrue, onFalse);
+        break;
+      }
+    case "Not":
+      if (includeAllExpression) {
+        const operand = transformRecursively(expression.operand, expressionType, transformFunction, includeAllExpression);
+        expression = not(operand);
+      }
+      break;
+    case "Truthy":
+      break;
+    case "Set":
+      if (includeAllExpression) {
+        const operands = expression.operands.map(operand => transformRecursively(operand, expressionType, transformFunction, includeAllExpression));
+        expression = expression.operator === "||" ? or(...operands) : and(...operands);
+      }
+      break;
+    case "Comparison":
+      if (includeAllExpression) {
+        const operand1 = transformRecursively(expression.operand1, expressionType, transformFunction, includeAllExpression);
+        const operand2 = transformRecursively(expression.operand2, expressionType, transformFunction, includeAllExpression);
+        expression = comparison(expression.operator, operand1, operand2);
+      }
+      break;
+    case "Constant":
+      {
+        const constantValue = expression.value;
+        if (typeof constantValue === "object" && constantValue) {
+          Object.keys(constantValue).forEach(key => {
+            constantValue[key] = transformRecursively(constantValue[key], expressionType, transformFunction, includeAllExpression);
+          });
+        }
+        break;
+      }
+    case "Ref":
+    case "Length":
+    case "PathInModel":
+    case "EmbeddedBinding":
+    case "EmbeddedExpressionBinding":
+    case "Unresolvable":
+      // Do nothing
+      break;
+  }
+  if (expressionType === expression._type) {
+    expression = transformFunction(inExpression);
+  }
+  return expression;
+}
+
+
+/***/ }),
+
+/***/ 331:
+/***/ (function(__unused_webpack_module, exports) {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.isAnnotationOfTerm = isAnnotationOfTerm;
+exports.isAnnotationOfType = isAnnotationOfType;
+exports.isAnnotationPath = isAnnotationPath;
+exports.isAnnotationTerm = isAnnotationTerm;
+exports.isComplexType = isComplexType;
+exports.isEntityContainer = isEntityContainer;
+exports.isEntitySet = isEntitySet;
+exports.isEntityType = isEntityType;
+exports.isMultipleNavigationProperty = isMultipleNavigationProperty;
+exports.isNavigationProperty = isNavigationProperty;
+exports.isPathAnnotationExpression = isPathAnnotationExpression;
+exports.isProperty = isProperty;
+exports.isPropertyPathExpression = isPropertyPathExpression;
+exports.isServiceObject = isServiceObject;
+exports.isSingleNavigationProperty = isSingleNavigationProperty;
+exports.isSingleton = isSingleton;
+exports.isTypeDefinition = isTypeDefinition;
+exports.isValidPropertyPathExpression = isValidPropertyPathExpression;
+/**
+ * Checks whether the argument is an annotation of the given type.
+ * @param potentialAnnotationType The annotation to check
+ * @param typeName The type to check for
+ * @returns Whether the argument is an annotation of the given type
+ */
+function isAnnotationOfType(potentialAnnotationType, typeName) {
+  if (Array.isArray(typeName)) {
+    return typeName.includes(potentialAnnotationType.$Type);
+  }
+  return potentialAnnotationType.$Type === typeName;
+}
+
+/**
+ * Checks whether the argument is an annotation of the given term.
+ * @param potentialAnnotation The annotation to check
+ * @param termName The term to check for
+ * @returns Whether the argument is an annotation of the given term
+ */
+function isAnnotationOfTerm(potentialAnnotation, termName) {
+  return potentialAnnotation.term === termName;
+}
+function isAnnotationTerm(potentialAnnotation) {
+  return potentialAnnotation.hasOwnProperty("term");
+}
+
+/**
+ * Checks whether the argument is a {@link ServiceObject}.
+ *
+ * @param serviceObject The object to be checked.
+ * @returns Whether the argument is a {@link ServiceObject}.
+ */
+function isServiceObject(serviceObject) {
+  return serviceObject?.hasOwnProperty("_type") ?? false;
+}
+
+/**
+ * Checks whether the argument is a {@link ComplexType}.
+ *
+ * @param serviceObject The object to be checked.
+ * @returns Whether the argument is a {@link ComplexType}.
+ */
+function isComplexType(serviceObject) {
+  return serviceObject._type === "ComplexType";
+}
+
+/**
+ * Checks whether the argument is a {@link TypeDefinition}.
+ *
+ * @param serviceObject The object to be checked.
+ * @returns Whether the argument is a {@link TypeDefinition}.
+ */
+function isTypeDefinition(serviceObject) {
+  return serviceObject._type === "TypeDefinition";
+}
+
+/**
+ * Checks whether the argument is an {@link EntityContainer}.
+ *
+ * @param serviceObject The object to be checked.
+ * @returns Whether the argument is an {@link EntityContainer}.
+ */
+function isEntityContainer(serviceObject) {
+  return serviceObject._type === "EntityContainer";
+}
+
+/**
+ * Checks whether the argument is an {@link EntitySet}.
+ *
+ * @param serviceObject The object to be checked.
+ * @returns Whether the argument is an {@link EntitySet}.
+ */
+function isEntitySet(serviceObject) {
+  return serviceObject._type === "EntitySet";
+}
+
+/**
+ * Checks whether the argument is a {@link Singleton}.
+ *
+ * @param serviceObject The object to be checked.
+ * @returns Whether the argument is a {@link Singleton}
+ */
+function isSingleton(serviceObject) {
+  return serviceObject._type === "Singleton";
+}
+
+/**
+ * Checks whether the argument is an {@link EntityType}.
+ *
+ * @param serviceObject The object to be checked.
+ * @returns Whether the argument is an {@link EntityType}
+ */
+function isEntityType(serviceObject) {
+  return serviceObject._type === "EntityType";
+}
+
+/**
+ * Checks whether the argument is a {@link Property}.
+ *
+ * @param serviceObject The object to be checked.
+ * @returns Whether the argument is a {@link Property}.
+ */
+function isProperty(serviceObject) {
+  return serviceObject._type === "Property";
+}
+
+/**
+ * Checks whether the argument is a {@link NavigationProperty}.
+ *
+ * Hint: There are also the more specific functions {@link isSingleNavigationProperty} and {@link isMultipleNavigationProperty}. These can be
+ * used to check for to-one and to-many navigation properties, respectively.
+ *
+ * @param serviceObject The object to be checked.
+ * @returns Whether the argument is a {@link NavigationProperty}.
+ */
+function isNavigationProperty(serviceObject) {
+  return serviceObject._type === "NavigationProperty";
+}
+
+/**
+ * Checks whether the argument is a {@link SingleNavigationProperty}.
+ *
+ * @param serviceObject The object to be checked.
+ * @returns Whether the argument is a {@link SingleNavigationProperty}.
+ */
+function isSingleNavigationProperty(serviceObject) {
+  return isNavigationProperty(serviceObject) && !serviceObject.isCollection;
+}
+
+/**
+ * Checks whether the argument is a {@link MultipleNavigationProperty}.
+ *
+ * @param serviceObject The object to be checked.
+ * @returns Whether the argument is a {@link MultipleNavigationProperty}.
+ */
+function isMultipleNavigationProperty(serviceObject) {
+  return isNavigationProperty(serviceObject) && serviceObject.isCollection;
+}
+
+/**
+ * Checks whether the argument is a {@link PathAnnotationExpression}.
+ *
+ * @param expression The object to be checked.
+ * @returns Whether the argument is a {@link PathAnnotationExpression}.
+ */
+function isPathAnnotationExpression(expression) {
+  return expression.type === "Path";
+}
+
+/**
+ * Checks whether the argument is a {@link AnnotationPathExpression}.
+ *
+ * @param expression The object to be checked.
+ * @returns Whether the argument is a {@link AnnotationPathExpression}.
+ */
+function isAnnotationPath(expression) {
+  return expression.type == "AnnotationPath";
+}
+
+/**
+ * Checks whether the argument is a {@link PropertyPath}.
+ *
+ * @param expression The object to be checked.
+ * @returns Whether the argument is a {@link PropertyPath}.
+ */
+function isPropertyPathExpression(expression) {
+  return expression.type === "PropertyPath";
+}
+/**
+ * Checks whether the argument is a {@link PropertyPath}.
+ *
+ * @param expression The object to be checked.
+ * @returns Whether the argument is a {@link PropertyPath}.
+ */
+function isValidPropertyPathExpression(expression) {
+  return expression.type === "PropertyPath" && !!expression.$target;
+}
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(829);
+/******/ 	FEDefinition = __webpack_exports__;
+/******/ 	
+/******/ })()
+;
+
+    return FEDefinition;
+ },true);
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://FEDefinition/node_modules/.pnpm/@sap-ux+sap.fe.definition@0.0.11/node_modules/@sap-ux/sap.fe.definition/src/BaseDefinition.ts","webpack://FEDefinition/node_modules/.pnpm/@sap-ux+sap.fe.definition@0.0.11/node_modules/@sap-ux/sap.fe.definition/src/MetaPath.ts","webpack://FEDefinition/node_modules/.pnpm/@sap-ux+sap.fe.definition@0.0.11/node_modules/@sap-ux/sap.fe.definition/src/elements/FilterBar.ts","webpack://FEDefinition/node_modules/.pnpm/@sap-ux+sap.fe.definition@0.0.11/node_modules/@sap-ux/sap.fe.definition/src/floorplans/DefinitionPage.ts","webpack://FEDefinition/node_modules/.pnpm/@sap-ux+sap.fe.definition@0.0.11/node_modules/@sap-ux/sap.fe.definition/src/index.ts","webpack://FEDefinition/node_modules/.pnpm/@sap-ux+sap.fe.definition@0.0.11/node_modules/@sap-ux/sap.fe.definition/src/odata/DefinitionContext.ts","webpack://FEDefinition/node_modules/.pnpm/@sap-ux+sap.fe.definition@0.0.11/node_modules/@sap-ux/sap.fe.definition/src/odata/EntitySet.ts","webpack://FEDefinition/node_modules/.pnpm/@sap-ux+sap.fe.definition@0.0.11/node_modules/@sap-ux/sap.fe.definition/src/odata/annotations/UI/_DataField.ts","webpack://FEDefinition/node_modules/.pnpm/@sap-ux+sap.fe.definition@0.0.11/node_modules/@sap-ux/sap.fe.definition/src/odata/annotations/UI/_Identification.ts","webpack://FEDefinition/node_modules/.pnpm/@sap-ux+sap.fe.definition@0.0.11/node_modules/@sap-ux/sap.fe.definition/src/odata/annotations/UI/_LineItem.ts","webpack://FEDefinition/node_modules/.pnpm/@sap-ux+sap.fe.definition@0.0.11/node_modules/@sap-ux/sap.fe.definition/src/utils/Expression.ts","webpack://FEDefinition/node_modules/.pnpm/@sap-ux+sap.fe.definition@0.0.11/node_modules/@sap-ux/sap.fe.definition/src/utils/TypeGuards.ts","webpack://FEDefinition/webpack/bootstrap","webpack://FEDefinition/webpack/startup"],"names":["Placement","exports","BaseDefinition","constructor","metaPath","configuration","annotationPath","getPath","configurablePropertiesKey","__configurableProperties","configSettings","configurationValue","aliasFor","undefined","validator","defaultValue","targetObject","getTarget","annotationPropertiesKey","__annotationProperties","annotations","_annotations","term","valueOf","getConfiguration","outObj","noop","value","configurable","propertyConfiguration","target","propertyKey","propertyDescriptor","localPropertyConfiguration","name","initializer","targetPrototype","prototype","annotation","annotationConfiguration","localAnnotationConfiguration","_TypeGuards","require","enhancePath","sBasePath","sPathAddition","startsWith","endsWith","MetaPath","convertedMetadata","contextPath","navigationProperties","contextNavigationProperties","absolutePath","relativePath","replace","substring","resolvedMetaPath","resolvePath","resolvedContextPath","Error","rootEntitySet","currentEntitySet","currentEntityType","navigatedPaths","objectPath","forEach","objectPart","isServiceObject","_type","push","targetType","navigationPropertyBinding","hasOwnProperty","join","entityType","getResolvedContextPath","serviceObjectPath","length","map","nav","contextRootEntitySet","getContextPath","sPathPart","getRelativePath","getClosestEntitySet","closestEntitySet","navigationProperty","navigationPropertyBindingElement","getClosestEntityType","closestEntityType","getContextClosestEntitySet","nonNullEntitySet","getNavigationProperties","getMetaPathForPath","targetPath","_error","getMetaPathForObject","isAnnotationPath","isPathAnnotationExpression","path","metaPathApp","fullyQualifiedName","getConvertedMetadata","_BaseDefinition","_EntitySet2","_interopRequireDefault","_dec","_dec2","_dec3","_class","_descriptor","_descriptor2","_descriptor3","e","__esModule","default","_initializerDefineProperty","i","r","l","Object","defineProperty","enumerable","writable","call","_defineProperty","t","_toPropertyKey","_toPrimitive","Symbol","toPrimitive","TypeError","String","Number","_applyDecoratedDescriptor","n","a","keys","slice","reverse","reduce","_initializerWarningHelper","FilterField","label","filterFieldProperty","Common","Label","toString","filterFieldConfiguration","FilterBar","selectionFields","filterBarConfiguration","getFilterGroups","filterFacets","UI","FilterFacets","filterFieldsGroup","fieldGroups","filter","key","fieldGroup","Data","fieldGroupEntry","$Type","fieldGroupValue","Value","$target","group","groupLabel","qualifier","filterFacet","filterFacetTarget","Target","isAnnotationOfType","ID","getFilterFields","filterGroups","consideredProperties","fromSelectionField","isValidPropertyPathExpression","field","metaPathForProperty","visible","nonFilterableProperties","_EntitySet","getNonFilterableProperties","entityProperties","property","includes","Hidden","isSearchSupported","isSearchAllowed","_FilterBar","_Identification2","_LineItem2","DefinitionPage","Set","getMetaPath","getIdentification","targetEntityType","idAnnotation","Identification","_Identification","getTableVisualization","_LineItem","fromSPV","_getTableVisualizationAnnotation","getFilterBarDefinition","selectionField","SelectionFields","assign","createDefaultTableVisualization","createDefault","spv","SelectionPresentationVariant","PresentationVariant","Visualizations","find","v","pv","LineItem","addDataToRequest","propertyPath","requestSet","add","getQueryComponents","select","expand","parts","split","query","$format","$select","$expand","_DefinitionPage","_DataField","_DefinitionContext","_exportNames","get","_MetaPath","DefinitionContext","addApplicationManifest","manifest","getEntitySets","entitySets","getEntitySet","entitySetName","by_name","getRootEntitySet","initialRoutePattern","initialRoute","routing","routes","pattern","targets","options","settings","entitySet","getPageFor","entitySetConfiguration","getRequiredProperties","requiredProperties","Capabilities","FilterRestrictions","RequiredProperties","NonFilterableProperties","getAllowedFilterExpression","filterExpressionRestrictions","FilterExpressionRestrictions","propertyRestrictions","filterExpressionRestriction","Property","propertyRestriction","AllowedExpressions","SearchRestrictions","Searchable","_Expression","dataField","pageMetaPath","getValue","getExpressionFromAnnotation","getFormattedValue","targetValue","transformRecursively","propertyMetaPath","unresolvableExpression","measure","getMeasure","concat","displayMode","getDisplayMode","text","Text","ifElse","notEqual","measures","Measures","Unit","ISOCurrency","textAnnotation","textArrangement","TextArrangement","getLabel","valueTarget","getProperty","getFullyQualifiedName","_DataField2","id","getDataFields","item","restrictTypes","importance","Importance","lineItem","fakeLineItemAnnotation","prop","DataFieldDefault","type","getActions","getHeaderActions","action","Determining","hasUnresolvableExpression","expressions","expr","_checkExpressionsAreEqual","b","operand","operator","operands","every","expression","some","otherExpression","condition","onTrue","onFalse","operand1","operand2","aExpressions","bExpressions","index","pathInModel","modelName","targetEntitySet","fn","parameters","bindingParameters","otherFunction","obj","ref","flattenSetExpression","result","candidatesForFlattening","candidate","hasOppositeExpressions","negatedExpressions","not","and","wrapPrimitive","isStaticFalse","nonTrivialExpression","isFalse","isConstant","constant","isValid","isTrue","or","isStaticTrue","isComparison","isTruthy","visitedNavigationPaths","pathVisitor","localPath","constantValue","Array","isArray","isPrimitiveObject","entries","plainExpression","val","wrappedValue","resolveBindingString","pathInModelRegex","pathInModelRegexMatch","exec","isNaN","reference","something","isExpression","maybeConstant","isPathInModelExpression","maybeBinding","isComplexTypeExpression","isConcatExpression","isIfElseExpression","isUndefinedExpression","expressionAsExpression","objectType","isComplexAnnotationExpression","annotationValue","annotationIfExpression","$If","parseAnnotationCondition","$Not","equal","$Eq","$Ne","greaterThan","$Gt","greaterOrEqual","$Ge","lessThan","$Lt","lessOrEqual","$Le","$Or","orCondition","$And","andCondition","annotationApplyExpression","$Path","Path","$Function","$Apply","$EnumMember","Bool","Int","Decimal","convertSubApplyParameters","applyParam","applyParamConverted","applyExpression","parameter","template","templateParams","$Name","$LabeledElement","comparison","leftOperand","rightOperand","leftExpression","rightExpression","checkUndefined","left","right","reduced","conditionExpression","onTrueExpression","onFalseExpression","pathIdx","myIfElseExpression","formatResult","allParts","constantPath","unshift","JSON","stringify","hasReferenceToDefaultContext","formatterFunction","contextEntityType","ignoreComplexType","parameterExpressions","functionName","__functionName","formatterClass","formatterName","myFormatExpression","getFiscalType","IsFiscalYear","IsFiscalPeriod","IsFiscalYearPeriod","IsFiscalQuarter","IsFiscalYearQuarter","IsFiscalWeek","IsFiscalYearWeek","IsDayOfFiscalYear","func","on","isFormattingFn","isEmpty","aBindings","inExpressions","concatenated","myConcatExpression","inExpression","expressionType","transformFunction","includeAllExpression","subExpression","bindingParameter","potentialAnnotationType","typeName","isAnnotationOfTerm","potentialAnnotation","termName","isAnnotationTerm","serviceObject","isComplexType","isTypeDefinition","isEntityContainer","isEntitySet","isSingleton","isEntityType","isProperty","isNavigationProperty","isSingleNavigationProperty","isCollection","isMultipleNavigationProperty","isPropertyPathExpression"],"mappings":"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","file":"FEDefinition.js","sourceRoot":"","sourcesContent":["import type { ServiceObject } from \"@sap-ux/vocabularies-types\";\nimport type { AnnotationTerm } from \"@sap-ux/vocabularies-types/Edm\";\nimport type MetaPath from \"./MetaPath\";\nimport type { PrimitiveType } from \"./utils/Expression\";\n\nexport type BaseConfiguration = Record<string, PrimitiveType>;\ntype InPropertyConfiguration = {\n\taliasFor?: string;\n\tvalidator?: Function;\n};\ntype PropertyConfiguration = {\n\taliasFor: string;\n\tvalidator: Function;\n\tname: string;\n\tdefaultValue: unknown;\n};\ntype InAnnotationConfiguration = {\n\tterm: string;\n};\ntype AnnotationConfiguration = {\n\tname: string;\n\tdefaultValue: unknown;\n\tterm: string;\n};\n\nexport enum Placement {\n\tAfter = \"After\",\n\tBefore = \"Before\",\n\tEnd = \"End\"\n}\n\nexport class BaseDefinition<T extends BaseConfiguration> {\n\tpublic annotationPath?: string;\n\n\t__configurableProperties!: Record<string, PropertyConfiguration>;\n\n\t__annotationProperties!: Record<string, AnnotationConfiguration>;\n\n\tconstructor(metaPath: MetaPath<ServiceObject | AnnotationTerm<{ term: string }>> | null, configuration: T) {\n\t\tthis.annotationPath = metaPath?.getPath();\n\t\tfor (const configurablePropertiesKey in this.__configurableProperties) {\n\t\t\tconst configSettings = this.__configurableProperties[configurablePropertiesKey];\n\t\t\tif (configSettings) {\n\t\t\t\tconst configurationValue = configuration[configSettings.aliasFor];\n\t\t\t\tif (configurationValue !== undefined) {\n\t\t\t\t\tthis[configurablePropertiesKey as keyof this] = configSettings.validator(configurationValue) as never;\n\t\t\t\t} else {\n\t\t\t\t\tthis[configurablePropertiesKey as keyof this] = configSettings.defaultValue as never;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tconst targetObject = metaPath?.getTarget();\n\t\tif (targetObject) {\n\t\t\tfor (const annotationPropertiesKey in this.__annotationProperties) {\n\t\t\t\tconst configSettings = this.__annotationProperties[annotationPropertiesKey];\n\t\t\t\tif (configSettings) {\n\t\t\t\t\tconst configurationValue = (\n\t\t\t\t\t\ttargetObject.annotations as unknown as {\n\t\t\t\t\t\t\t_annotations?: Record<string, unknown>;\n\t\t\t\t\t\t}\n\t\t\t\t\t)._annotations?.[configSettings.term];\n\t\t\t\t\tif (configurationValue !== undefined && configurationValue !== null) {\n\t\t\t\t\t\tthis[annotationPropertiesKey as keyof this] = configurationValue.valueOf() as never;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis[annotationPropertiesKey as keyof this] = configSettings.defaultValue as never;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tgetConfiguration(): T {\n\t\tconst outObj: BaseConfiguration = {};\n\t\tfor (const configurablePropertiesKey in this.__configurableProperties) {\n\t\t\tconst configSettings = this.__configurableProperties[configurablePropertiesKey];\n\t\t\tif (configSettings) {\n\t\t\t\toutObj[configSettings.aliasFor] = this[configurablePropertiesKey as keyof this] as PrimitiveType;\n\t\t\t}\n\t\t}\n\t\treturn outObj as T;\n\t}\n}\n\nfunction noop(value: PrimitiveType): PrimitiveType {\n\treturn value;\n}\nexport function configurable(propertyConfiguration: InPropertyConfiguration = {}): PropertyDecorator {\n\treturn function (\n\t\ttarget: BaseDefinition<BaseConfiguration>,\n\t\tpropertyKey: string,\n\t\tpropertyDescriptor: TypedPropertyDescriptor<PrimitiveType>\n\t) {\n\t\tconst localPropertyConfiguration: PropertyConfiguration = {\n\t\t\tname: propertyKey,\n\t\t\tvalidator: propertyConfiguration.validator || noop,\n\t\t\taliasFor: propertyConfiguration.aliasFor || propertyKey,\n\t\t\tdefaultValue: (propertyDescriptor as { initializer?: Function }).initializer?.()\n\t\t};\n\t\tconst targetPrototype = target.constructor.prototype as BaseDefinition<BaseConfiguration>;\n\t\tif (!targetPrototype.__configurableProperties) {\n\t\t\ttargetPrototype.__configurableProperties = {};\n\t\t}\n\t\tdelete (propertyDescriptor as { initializer?: Function } | undefined)?.initializer;\n\n\t\ttargetPrototype.__configurableProperties[propertyKey] = localPropertyConfiguration;\n\t} as unknown as PropertyDecorator;\n}\n\nexport function annotation(annotationConfiguration: InAnnotationConfiguration): PropertyDecorator {\n\treturn function (target: BaseDefinition<BaseConfiguration>, propertyKey: string, propertyDescriptor: TypedPropertyDescriptor<unknown>) {\n\t\tconst localAnnotationConfiguration: AnnotationConfiguration = {\n\t\t\tname: propertyKey,\n\t\t\tterm: annotationConfiguration.term,\n\t\t\tdefaultValue: (propertyDescriptor as { initializer?: Function }).initializer?.()\n\t\t};\n\t\tconst targetPrototype = target.constructor.prototype as BaseDefinition<BaseConfiguration>;\n\t\tif (!targetPrototype.__annotationProperties) {\n\t\t\ttargetPrototype.__annotationProperties = {};\n\t\t}\n\t\ttargetPrototype.__annotationProperties[propertyKey] = localAnnotationConfiguration;\n\t\tdelete (propertyDescriptor as { initializer?: Function }).initializer;\n\t\treturn propertyDescriptor;\n\t} as unknown as PropertyDecorator; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.;\n}\n","import type {\n\tConvertedMetadata,\n\tEntitySet,\n\tEntityType,\n\tNavigationProperty,\n\tPathAnnotationExpression,\n\tResolutionTarget,\n\tServiceObjectAndAnnotation,\n\tSingleton\n} from \"@sap-ux/vocabularies-types\";\nimport type { AnnotationPath, Property, PropertyAnnotationValue } from \"@sap-ux/vocabularies-types/Edm\";\nimport { isAnnotationPath, isPathAnnotationExpression, isServiceObject } from \"./utils/TypeGuards\";\n\nfunction enhancePath(sBasePath: string, sPathAddition?: string): string {\n\tif (sPathAddition) {\n\t\tif (sPathAddition.startsWith(\"/\")) {\n\t\t\treturn sPathAddition;\n\t\t} else if (sPathAddition.startsWith(\"@\")) {\n\t\t\treturn sBasePath + sPathAddition;\n\t\t} else if (!sBasePath.endsWith(\"/\")) {\n\t\t\treturn sBasePath + \"/\" + sPathAddition;\n\t\t} else {\n\t\t\treturn sBasePath + sPathAddition;\n\t\t}\n\t}\n\treturn sBasePath;\n}\n\ntype ResolvedTarget<T> =\n\tT extends AnnotationPath<infer K>\n\t\t? K\n\t\t: T extends PropertyAnnotationValue<infer V extends string>\n\t\t\t? V\n\t\t\t: T extends PathAnnotationExpression<unknown>\n\t\t\t\t? Property | undefined\n\t\t\t\t: T;\n\n/**\n *\n */\nexport default class MetaPath<T> {\n\tprivate rootEntitySet: EntitySet;\n\n\tprivate contextRootEntitySet: EntitySet | undefined;\n\n\tprivate absolutePath: string;\n\n\tprivate serviceObjectPath: string;\n\n\tprivate relativePath: string;\n\n\tprivate navigationProperties: NavigationProperty[];\n\n\tprivate contextNavigationProperties: NavigationProperty[];\n\n\tprivate currentEntitySet: EntitySet | Singleton | undefined;\n\n\tprivate currentEntityType?: EntityType;\n\n\tprivate targetObject: T;\n\n\t/**\n\t * Create the MetaPath object.\n\t * @param convertedMetadata The current model converter output\n\t * @param metaPath The current object metaPath\n\t * @param contextPath The current context\n\t */\n\tconstructor(\n\t\tprivate convertedMetadata: ConvertedMetadata,\n\t\tprivate metaPath: string,\n\t\tprivate contextPath: string\n\t) {\n\t\tthis.navigationProperties = [];\n\t\tthis.contextNavigationProperties = [];\n\t\tthis.absolutePath = enhancePath(contextPath, metaPath);\n\t\tthis.relativePath = this.absolutePath.replace(contextPath, \"\");\n\t\tif (this.relativePath.startsWith(\"/\")) {\n\t\t\tthis.relativePath = this.relativePath.substring(1);\n\t\t}\n\n\t\tconst resolvedMetaPath: ResolutionTarget<T> = this.convertedMetadata.resolvePath(this.absolutePath);\n\t\tconst resolvedContextPath: ResolutionTarget<T> = this.convertedMetadata.resolvePath(contextPath);\n\t\tif (resolvedMetaPath.target === undefined || resolvedMetaPath.target === null) {\n\t\t\tthrow new Error(`No annotation target found for ${metaPath}`);\n\t\t}\n\t\tthis.targetObject = resolvedMetaPath.target;\n\t\tlet rootEntitySet: EntitySet | undefined;\n\t\tlet currentEntitySet: EntitySet | Singleton | undefined;\n\t\tlet currentEntityType: EntityType | undefined;\n\t\tlet navigatedPaths: string[] = [];\n\t\tresolvedMetaPath.objectPath.forEach((objectPart: ServiceObjectAndAnnotation) => {\n\t\t\tif (isServiceObject(objectPart)) {\n\t\t\t\tswitch (objectPart._type) {\n\t\t\t\t\tcase \"NavigationProperty\":\n\t\t\t\t\t\tnavigatedPaths.push(objectPart.name);\n\t\t\t\t\t\tthis.navigationProperties.push(objectPart);\n\t\t\t\t\t\tcurrentEntityType = objectPart.targetType;\n\t\t\t\t\t\tif (currentEntitySet?.navigationPropertyBinding.hasOwnProperty(navigatedPaths.join(\"/\"))) {\n\t\t\t\t\t\t\tcurrentEntitySet = currentEntitySet.navigationPropertyBinding[navigatedPaths.join(\"/\")];\n\t\t\t\t\t\t\tnavigatedPaths = [];\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"EntitySet\":\n\t\t\t\t\t\tif (rootEntitySet === undefined) {\n\t\t\t\t\t\t\trootEntitySet = objectPart;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tcurrentEntitySet = objectPart;\n\t\t\t\t\t\tcurrentEntityType = currentEntitySet.entityType;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"EntityType\":\n\t\t\t\t\t\tif (currentEntityType === undefined) {\n\t\t\t\t\t\t\tcurrentEntityType = objectPart;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t\tresolvedContextPath.objectPath.forEach((objectPart: ServiceObjectAndAnnotation) => {\n\t\t\trootEntitySet = this.getResolvedContextPath(objectPart, currentEntityType, rootEntitySet);\n\t\t});\n\t\tif (rootEntitySet === undefined || currentEntityType === undefined) {\n\t\t\tthrow new Error(\"MetaPath doesn't contain an entitySet -> Should never happen\");\n\t\t}\n\t\tthis.serviceObjectPath = this.contextPath;\n\t\tif (this.navigationProperties.length) {\n\t\t\tthis.serviceObjectPath += \"/\" + this.navigationProperties.map((nav) => nav.name).join(\"/\");\n\t\t}\n\t\tthis.rootEntitySet = rootEntitySet;\n\t\tthis.currentEntitySet = currentEntitySet;\n\t\tthis.currentEntityType = currentEntityType;\n\t}\n\n\tprivate getResolvedContextPath(\n\t\tobjectPart: ServiceObjectAndAnnotation,\n\t\tcurrentEntityType: EntityType | undefined,\n\t\trootEntitySet: EntitySet | undefined\n\t): EntitySet | undefined {\n\t\tif (isServiceObject(objectPart)) {\n\t\t\tswitch (objectPart._type) {\n\t\t\t\tcase \"NavigationProperty\":\n\t\t\t\t\tthis.contextNavigationProperties.push(objectPart);\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"EntitySet\":\n\t\t\t\t\tif (this.contextRootEntitySet === undefined) {\n\t\t\t\t\t\tthis.contextRootEntitySet = objectPart;\n\t\t\t\t\t}\n\t\t\t\t\tif (rootEntitySet === undefined && objectPart.entityType === currentEntityType) {\n\t\t\t\t\t\trootEntitySet = objectPart;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\treturn rootEntitySet;\n\t}\n\n\tpublic getContextPath(): string {\n\t\treturn this.contextPath;\n\t}\n\n\t/**\n\t * Retrieve the absolute path for this MetaPath.\n\t * @param sPathPart The path to evaluate\n\t * @returns The absolute path\n\t */\n\tpublic getPath(sPathPart?: string): string {\n\t\treturn enhancePath(this.absolutePath, sPathPart);\n\t}\n\n\t/**\n\t * Retrieve the path relative to the context for this MetaPath.\n\t * @param sPathPart The path to evaluate\n\t * @returns The relative path\n\t */\n\tpublic getRelativePath(sPathPart?: string): string {\n\t\treturn enhancePath(this.relativePath, sPathPart);\n\t}\n\n\t/**\n\t * Retrieve the typed target for this object call.\n\t * @returns The typed target object\n\t */\n\tpublic getTarget(): T {\n\t\treturn this.targetObject;\n\t}\n\n\t/**\n\t * Retrieve the closest entityset in the path.\n\t * @returns The closest entityset\n\t */\n\tpublic getClosestEntitySet(): EntitySet | Singleton {\n\t\tlet closestEntitySet: EntitySet | Singleton = this.rootEntitySet;\n\t\tfor (const navigationProperty of this.navigationProperties) {\n\t\t\tconst navigationPropertyBindingElement: EntitySet | Singleton | undefined =\n\t\t\t\tclosestEntitySet.navigationPropertyBinding[navigationProperty.name];\n\t\t\tif (navigationPropertyBindingElement) {\n\t\t\t\tclosestEntitySet = navigationPropertyBindingElement;\n\t\t\t}\n\t\t}\n\t\treturn closestEntitySet;\n\t}\n\n\tpublic getClosestEntityType(): EntityType {\n\t\tlet closestEntityType: EntityType = this.rootEntitySet.entityType;\n\t\tfor (const navigationProperty of this.navigationProperties) {\n\t\t\tclosestEntityType = navigationProperty.targetType;\n\t\t}\n\t\treturn closestEntityType;\n\t}\n\n\t/**\n\t * Retrieve the closest entityset in the path.\n\t * @returns The closest entityset\n\t */\n\tpublic getContextClosestEntitySet(): EntitySet | Singleton | undefined {\n\t\tlet closestEntitySet: EntitySet | Singleton | undefined = this.contextRootEntitySet;\n\t\tif (closestEntitySet === undefined) {\n\t\t\treturn closestEntitySet;\n\t\t}\n\t\tconst nonNullEntitySet: EntitySet | Singleton = closestEntitySet;\n\t\tfor (const navigationProperty of this.contextNavigationProperties) {\n\t\t\tif (nonNullEntitySet.navigationPropertyBinding[navigationProperty.name]) {\n\t\t\t\tclosestEntitySet = nonNullEntitySet.navigationPropertyBinding[navigationProperty.name];\n\t\t\t}\n\t\t}\n\t\treturn closestEntitySet;\n\t}\n\n\tpublic getNavigationProperties(): NavigationProperty[] {\n\t\treturn this.navigationProperties;\n\t}\n\n\tpublic getMetaPathForPath<SubType>(targetPath: string): MetaPath<SubType> | undefined {\n\t\ttry {\n\t\t\treturn new MetaPath<SubType>(this.convertedMetadata, enhancePath(this.serviceObjectPath, targetPath), this.contextPath);\n\t\t} catch (_error) {\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\tpublic getMetaPathForObject<SubType extends { fullyQualifiedName: string }>(\n\t\ttargetObject: SubType\n\t): MetaPath<ResolvedTarget<SubType>> | undefined {\n\t\tif (isAnnotationPath(targetObject)) {\n\t\t\treturn this.getMetaPathForPath<ResolvedTarget<SubType>>(targetObject.value);\n\t\t} else if (isPathAnnotationExpression(targetObject)) {\n\t\t\treturn this.getMetaPathForPath<ResolvedTarget<SubType>>(targetObject.path);\n\t\t} else {\n\t\t\tconst metaPathApp = targetObject.fullyQualifiedName.replace(this.rootEntitySet.entityType.fullyQualifiedName, this.contextPath);\n\t\t\treturn new MetaPath<ResolvedTarget<SubType>>(this.convertedMetadata, metaPathApp, this.contextPath);\n\t\t}\n\t}\n\n\tpublic getConvertedMetadata(): ConvertedMetadata {\n\t\treturn this.convertedMetadata;\n\t}\n}\n","import type { EntitySet } from \"@sap-ux/vocabularies-types\";\nimport type { Property } from \"@sap-ux/vocabularies-types/Edm\";\nimport type { FieldGroup, SelectionFields } from \"@sap-ux/vocabularies-types/vocabularies/UI\";\nimport { UIAnnotationTypes } from \"@sap-ux/vocabularies-types/vocabularies/UI\";\nimport type { EntityTypeAnnotations_UI } from \"@sap-ux/vocabularies-types/vocabularies/UI_Edm\";\nimport { BaseDefinition, configurable } from \"../BaseDefinition\";\nimport type { PageTargetEntity } from \"../floorplans/DefinitionPage\";\nimport type MetaPath from \"../MetaPath\";\nimport _EntitySet from \"../odata/EntitySet\";\nimport { isAnnotationOfType, isPathAnnotationExpression, isValidPropertyPathExpression } from \"../utils/TypeGuards\";\n\nexport type FilterFieldConfiguration = {\n\tgroup?: string;\n\tgroupLabel?: string;\n\tvisible?: boolean;\n};\n\nclass FilterField extends BaseDefinition<FilterFieldConfiguration> {\n\t@configurable()\n\tgroup?: string;\n\n\t@configurable()\n\tgroupLabel?: string;\n\n\t@configurable()\n\tvisible?: boolean;\n\n\tget label(): string {\n\t\treturn this.filterFieldProperty.getTarget().annotations.Common?.Label?.toString() ?? this.filterFieldProperty.getTarget().name;\n\t}\n\n\tconstructor(\n\t\tprivate readonly filterFieldProperty: MetaPath<Property>,\n\t\tfilterFieldConfiguration: FilterFieldConfiguration\n\t) {\n\t\tsuper(filterFieldProperty, filterFieldConfiguration);\n\t}\n}\nexport type FilterBarConfiguration = {\n\tfilterFields?: Record<string, FilterFieldConfiguration[]>;\n};\nexport default class FilterBar {\n\tconstructor(\n\t\tprivate readonly selectionFields: SelectionFields,\n\t\tprivate readonly filterBarConfiguration: FilterBarConfiguration,\n\t\tprivate readonly metaPath: MetaPath<PageTargetEntity>\n\t) {}\n\n\tgetFilterGroups(): Record<string, { group?: string; groupLabel?: string }> {\n\t\tconst filterFacets = this.metaPath.getClosestEntityType().annotations.UI?.FilterFacets;\n\t\tconst filterFieldsGroup: Record<string, { group?: string; groupLabel?: string }> = {};\n\t\tif (!filterFacets) {\n\t\t\tconst fieldGroups = Object.keys(this.metaPath.getClosestEntityType().annotations.UI ?? {})\n\t\t\t\t.filter((key) => {\n\t\t\t\t\treturn key.startsWith(\"FieldGroup\");\n\t\t\t\t})\n\t\t\t\t.map((key) => {\n\t\t\t\t\treturn this.metaPath.getClosestEntityType().annotations.UI?.[key as keyof EntityTypeAnnotations_UI];\n\t\t\t\t}) as FieldGroup[];\n\t\t\tfor (const fieldGroup of fieldGroups) {\n\t\t\t\tfieldGroup.Data.forEach((fieldGroupEntry) => {\n\t\t\t\t\tswitch (fieldGroupEntry.$Type) {\n\t\t\t\t\t\tcase UIAnnotationTypes.DataField: {\n\t\t\t\t\t\t\tconst fieldGroupValue = fieldGroupEntry.Value as unknown;\n\t\t\t\t\t\t\tif (isPathAnnotationExpression(fieldGroupValue) && fieldGroupValue.$target) {\n\t\t\t\t\t\t\t\tfilterFieldsGroup[fieldGroupValue.$target.fullyQualifiedName] = {\n\t\t\t\t\t\t\t\t\tgroup: fieldGroup.fullyQualifiedName,\n\t\t\t\t\t\t\t\t\tgroupLabel:\n\t\t\t\t\t\t\t\t\t\tfieldGroup.Label?.toString() ??\n\t\t\t\t\t\t\t\t\t\tfieldGroup.annotations?.Common?.Label?.toString() ??\n\t\t\t\t\t\t\t\t\t\tfieldGroup.qualifier\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\t// Not supported\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t} else {\n\t\t\tfilterFacets.forEach((filterFacet) => {\n\t\t\t\tconst filterFacetTarget = filterFacet.Target.$target;\n\t\t\t\tif (isAnnotationOfType<FieldGroup>(filterFacetTarget, UIAnnotationTypes.FieldGroupType)) {\n\t\t\t\t\tfilterFacetTarget.Data.forEach((fieldGroupEntry) => {\n\t\t\t\t\t\tswitch (fieldGroupEntry.$Type) {\n\t\t\t\t\t\t\tcase UIAnnotationTypes.DataField: {\n\t\t\t\t\t\t\t\tconst fieldGroupValue = fieldGroupEntry.Value as unknown;\n\t\t\t\t\t\t\t\tif (isPathAnnotationExpression(fieldGroupValue) && fieldGroupValue.$target) {\n\t\t\t\t\t\t\t\t\tfilterFieldsGroup[fieldGroupValue.$target.fullyQualifiedName] = {\n\t\t\t\t\t\t\t\t\t\tgroup: filterFacet.ID?.toString(),\n\t\t\t\t\t\t\t\t\t\tgroupLabel: filterFacet.Label?.toString()\n\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\t\t// Not supported\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\treturn filterFieldsGroup;\n\t}\n\n\tgetFilterFields(): FilterField[] {\n\t\tconst filterGroups = this.getFilterGroups();\n\t\tconst consideredProperties: Record<string, boolean> = {};\n\t\tconst fromSelectionField = this.selectionFields\n\t\t\t.filter(isValidPropertyPathExpression)\n\t\t\t.map((field) => {\n\t\t\t\tconst metaPathForProperty = this.metaPath.getMetaPathForPath<Property>(field.value);\n\t\t\t\tif (metaPathForProperty) {\n\t\t\t\t\tconsideredProperties[metaPathForProperty.getTarget().fullyQualifiedName] = true;\n\t\t\t\t\treturn new FilterField(metaPathForProperty, {\n\t\t\t\t\t\tgroup: filterGroups[metaPathForProperty.getTarget().fullyQualifiedName]?.group,\n\t\t\t\t\t\tgroupLabel: filterGroups[metaPathForProperty.getTarget().fullyQualifiedName]?.groupLabel,\n\t\t\t\t\t\tvisible: true\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t})\n\t\t\t.filter((field): field is FilterField => {\n\t\t\t\treturn !!field;\n\t\t\t});\n\t\tconst nonFilterableProperties = new _EntitySet(this.metaPath as MetaPath<EntitySet>).getNonFilterableProperties();\n\t\tthis.metaPath.getClosestEntityType().entityProperties.forEach((property) => {\n\t\t\tif (\n\t\t\t\t!consideredProperties[property.fullyQualifiedName] &&\n\t\t\t\t!nonFilterableProperties.includes(property) &&\n\t\t\t\tproperty.targetType === undefined &&\n\t\t\t\tproperty.annotations.UI?.Hidden?.valueOf() !== true\n\t\t\t) {\n\t\t\t\tconsideredProperties[property.fullyQualifiedName] = true;\n\t\t\t\tfromSelectionField.push(\n\t\t\t\t\tnew FilterField(this.metaPath.getMetaPathForPath<Property>(property.name)!, {\n\t\t\t\t\t\tgroup: filterGroups[property.fullyQualifiedName]?.group,\n\t\t\t\t\t\tgroupLabel: filterGroups[property.fullyQualifiedName]?.groupLabel,\n\t\t\t\t\t\tvisible: false\n\t\t\t\t\t})\n\t\t\t\t);\n\t\t\t}\n\t\t});\n\n\t\treturn fromSelectionField;\n\t}\n\n\tisSearchSupported(): boolean {\n\t\treturn new _EntitySet(this.metaPath as MetaPath<EntitySet>).isSearchAllowed();\n\t}\n}\n","import type { EntitySet, NavigationProperty, PropertyPath, Singleton } from \"@sap-ux/vocabularies-types\";\nimport type {\n\tLineItem,\n\tPresentationVariant,\n\tSelectionFields,\n\tSelectionPresentationVariant\n} from \"@sap-ux/vocabularies-types/vocabularies/UI\";\nimport { UIAnnotationTerms } from \"@sap-ux/vocabularies-types/vocabularies/UI\";\nimport type { FilterBarConfiguration } from \"../elements/FilterBar\";\nimport FilterBar from \"../elements/FilterBar\";\nimport type MetaPath from \"../MetaPath\";\nimport { _Identification } from \"../odata/annotations/UI/_Identification\";\nimport { _LineItem } from \"../odata/annotations/UI/_LineItem\";\n\nexport type PageTargetEntity = EntitySet | Singleton | NavigationProperty;\nexport class DefinitionPage {\n\tprivate requestSet: Set<string> = new Set();\n\n\tconstructor(private metaPath: MetaPath<PageTargetEntity>) {}\n\n\tgetMetaPath(): MetaPath<PageTargetEntity> {\n\t\treturn this.metaPath;\n\t}\n\n\t/**\n\t * Gets the target entity set identification annotation if available.\n\t *\n\t * @returns Identification annotation wrapper\n\t */\n\tpublic getIdentification(): _Identification | undefined {\n\t\tconst targetEntityType = this.metaPath.getClosestEntityType();\n\t\tconst idAnnotation = targetEntityType.annotations.UI?.Identification;\n\t\tif (idAnnotation) {\n\t\t\treturn new _Identification(idAnnotation, this.metaPath);\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\t/**\n\t * Retrieves the LineItem annotation for the target entity set\n\t * @returns LineItem annotation\n\t */\n\tpublic getTableVisualization(): _LineItem | undefined {\n\t\treturn _LineItem.fromSPV(this._getTableVisualizationAnnotation(), this.metaPath);\n\t}\n\n\tpublic getFilterBarDefinition(filterBarConfiguration: FilterBarConfiguration): FilterBar {\n\t\tconst targetEntityType = this.metaPath.getClosestEntityType();\n\t\t//this.tracer.markRequest(\"Page.getFilterBarDefinition\", targetEntityType);\n\t\tlet selectionField = targetEntityType.annotations.UI?.SelectionFields;\n\t\tif (!selectionField) {\n\t\t\tselectionField = Object.assign([] as PropertyPath[], {\n\t\t\t\tterm: UIAnnotationTerms.SelectionFields\n\t\t\t}) as SelectionFields;\n\t\t}\n\t\t//this.tracer.endMarkRequest(\"Page.getFilterBarDefinition\");\n\t\treturn new FilterBar(selectionField, filterBarConfiguration, this.metaPath);\n\t}\n\n\t/**\n\t * Create a default LineItem annotation for the target entity type based on properties\n\t * @returns LineItem annotation\n\t */\n\tpublic createDefaultTableVisualization(): _LineItem {\n\t\treturn _LineItem.createDefault(this.metaPath);\n\t}\n\n\tprivate _getTableVisualizationAnnotation(): LineItem | SelectionPresentationVariant | PresentationVariant | undefined {\n\t\tconst targetEntityType = this.metaPath.getClosestEntityType();\n\t\tconst spv = targetEntityType.annotations.UI?.SelectionPresentationVariant;\n\t\tif (spv) {\n\t\t\tif (spv.PresentationVariant.Visualizations.find((v) => v.$target?.term === UIAnnotationTerms.LineItem)) {\n\t\t\t\treturn spv;\n\t\t\t}\n\t\t}\n\t\tconst pv = targetEntityType.annotations.UI?.PresentationVariant;\n\t\tif (pv?.Visualizations) {\n\t\t\tif (pv.Visualizations.find((v) => v.$target?.term === UIAnnotationTerms.LineItem)) {\n\t\t\t\treturn pv;\n\t\t\t}\n\t\t}\n\t\treturn targetEntityType.annotations.UI?.LineItem;\n\t}\n\n\taddDataToRequest(propertyPath: string): void {\n\t\t// Add data to request\n\t\tthis.requestSet.add(propertyPath);\n\t}\n\n\tgetQueryComponents(): {\n\t\t$select: string;\n\t\t$expand?: string;\n\t\t$format: \"json\";\n\t} {\n\t\tconst select: string[] = [];\n\t\tconst expand: string[] = [];\n\t\tthis.requestSet.forEach((property) => {\n\t\t\tconst parts = property.split(\"/\");\n\t\t\tif (parts.length > 1 && parts[0]) {\n\t\t\t\texpand.push(parts[0]);\n\t\t\t} else {\n\t\t\t\tselect.push(property);\n\t\t\t}\n\t\t});\n\t\tconst query: {\n\t\t\t$select: string;\n\t\t\t$expand?: string;\n\t\t\t$format: \"json\";\n\t\t} = {\n\t\t\t$format: \"json\",\n\t\t\t$select: select.join(\",\")\n\t\t};\n\t\tif (expand.length > 0) {\n\t\t\tquery.$expand = expand.join(\",\");\n\t\t}\n\t\treturn query;\n\t}\n}\n","export { DefinitionPage } from \"./floorplans/DefinitionPage\";\nexport { _DataField } from \"./odata/annotations/UI/_DataField\";\nexport { _LineItem } from \"./odata/annotations/UI/_LineItem\";\nexport { DefinitionContext } from \"./odata/DefinitionContext\";\nexport * from \"./utils/TypeGuards\";\n","import type { ConvertedMetadata, EntitySet, NavigationProperty, Singleton } from \"@sap-ux/vocabularies-types\";\nimport type { SAPJSONSchemaForWebApplicationManifestFile as ApplicationManifest, Route } from \"@ui5/manifest/types/manifest\";\nimport MetaPath from \"../MetaPath\";\nimport { DefinitionPage } from \"../floorplans/DefinitionPage\";\n\nexport class DefinitionContext {\n\tprivate manifest?: ApplicationManifest;\n\n\tconstructor(private readonly convertedMetadata: ConvertedMetadata) {}\n\n\taddApplicationManifest(manifest: ApplicationManifest): void {\n\t\tthis.manifest = manifest;\n\t}\n\n\tgetEntitySets(): EntitySet[] {\n\t\treturn this.convertedMetadata.entitySets;\n\t}\n\n\tgetEntitySet(entitySetName: string): EntitySet | undefined {\n\t\treturn this.convertedMetadata.entitySets.by_name(entitySetName);\n\t}\n\n\tgetRootEntitySet(): EntitySet | Singleton | undefined {\n\t\tif (this.manifest) {\n\t\t\t// Use the ui5 routing config to identify the root entityset\n\t\t\tconst initialRoutePattern = \":?query:\";\n\t\t\tconst initialRoute = (this.manifest[\"sap.ui5\"]?.routing?.routes as Route[]).find((r) => r.pattern === initialRoutePattern);\n\t\t\tif (initialRoute?.target && this.manifest[\"sap.ui5\"]?.routing?.targets) {\n\t\t\t\tconst target = this.manifest[\"sap.ui5\"].routing.targets[initialRoute.target as string];\n\t\t\t\tif (target?.name) {\n\t\t\t\t\tconst options = target.options as\n\t\t\t\t\t\t| {\n\t\t\t\t\t\t\t\tsettings?: {\n\t\t\t\t\t\t\t\t\tcontextPath?: string;\n\t\t\t\t\t\t\t\t\tentitySet: string;\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t  }\n\t\t\t\t\t\t| undefined;\n\t\t\t\t\tconst settings = options?.settings;\n\t\t\t\t\tconst entitySet = this.convertedMetadata.resolvePath<EntitySet | Singleton>(\n\t\t\t\t\t\tsettings?.contextPath ?? `${settings?.entitySet}`\n\t\t\t\t\t);\n\t\t\t\t\treturn entitySet.target;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t// Try to determine the root entity set from the metadata\n\t}\n\n\tgetMetaPath<T>(metaPath: string, contextPath: string): MetaPath<T> {\n\t\treturn new MetaPath<T>(this.convertedMetadata, metaPath, contextPath);\n\t}\n\n\tgetPageFor(contextPath: string): DefinitionPage {\n\t\t// A page could point to\n\t\t// - An entitySet (/SalesOrder)\n\t\t// - A singleton (/Me)\n\t\t// - A navigation property (/SalesOrder/Set)\n\t\treturn new DefinitionPage(\n\t\t\tnew MetaPath<EntitySet | Singleton | NavigationProperty>(this.convertedMetadata, contextPath, contextPath)\n\t\t);\n\t}\n}\n","import type { EntitySet } from \"@sap-ux/vocabularies-types\";\nimport type { Property } from \"@sap-ux/vocabularies-types/Edm\";\nimport type { FilterExpressionType } from \"@sap-ux/vocabularies-types/vocabularies/Capabilities\";\nimport type { BaseConfiguration } from \"../BaseDefinition\";\nimport { BaseDefinition } from \"../BaseDefinition\";\nimport type MetaPath from \"../MetaPath\";\n\nexport default class _EntitySet extends BaseDefinition<BaseConfiguration> {\n\tconstructor(\n\t\tprivate readonly entitySet: MetaPath<EntitySet>,\n\t\tprivate readonly entitySetConfiguration: BaseConfiguration = {}\n\t) {\n\t\tsuper(entitySet, entitySetConfiguration);\n\t}\n\t//\n\t// @annotation({\n\t// \tterm: CapabilitiesAnnotationTerms.FilterRestrictions,\n\t// \tprocessor: (filterRestrictions?: FilterRestrictions): Property[] => {\n\t// \t\tconst requiredProperties =\n\t// \t\t\tfilterRestrictions?.RequiredProperties ?? [];\n\t// \t\treturn requiredProperties\n\t// \t\t\t.map((propertyPath) => {\n\t// \t\t\t\treturn propertyPath.$target;\n\t// \t\t\t})\n\t// \t\t\t.filter((property): property is Property => {\n\t// \t\t\t\treturn !!property;\n\t// \t\t\t});\n\t// \t}\n\t// })\n\t// requiredProperties: Property[];\n\n\t/**\n\t * Retrieves the required properties for the entity set.\n\t */\n\tgetRequiredProperties(): Property[] {\n\t\tconst requiredProperties = this.entitySet.getTarget().annotations.Capabilities?.FilterRestrictions?.RequiredProperties ?? [];\n\t\treturn requiredProperties\n\t\t\t.map((propertyPath) => {\n\t\t\t\treturn propertyPath.$target;\n\t\t\t})\n\t\t\t.filter((property): property is Property => {\n\t\t\t\treturn !!property;\n\t\t\t});\n\t}\n\n\t/**\n\t * Retrieves the required properties for the entity set.\n\t */\n\tgetNonFilterableProperties(): Property[] {\n\t\tconst nonFilterableProperties =\n\t\t\tthis.entitySet.getTarget().annotations.Capabilities?.FilterRestrictions?.NonFilterableProperties ?? [];\n\t\treturn nonFilterableProperties\n\t\t\t.map((propertyPath) => {\n\t\t\t\treturn propertyPath.$target;\n\t\t\t})\n\t\t\t.filter((property): property is Property => {\n\t\t\t\treturn !!property;\n\t\t\t});\n\t}\n\n\t/**\n\t * Retrieves the required properties for the entity set.\n\t * @param property\n\t */\n\tgetAllowedFilterExpression(property: Property): FilterExpressionType[] {\n\t\tconst filterExpressionRestrictions =\n\t\t\tthis.entitySet.getTarget().annotations.Capabilities?.FilterRestrictions?.FilterExpressionRestrictions ?? [];\n\t\tconst propertyRestrictions = filterExpressionRestrictions.filter(\n\t\t\t(filterExpressionRestriction) => filterExpressionRestriction.Property?.$target === property\n\t\t);\n\t\treturn propertyRestrictions\n\t\t\t.map((propertyRestriction) => {\n\t\t\t\treturn propertyRestriction.AllowedExpressions;\n\t\t\t})\n\t\t\t.filter((propertyRestriction): propertyRestriction is FilterExpressionType => {\n\t\t\t\treturn !!propertyRestriction;\n\t\t\t});\n\t}\n\n\tisSearchAllowed(): boolean {\n\t\treturn !!this.entitySet.getTarget().annotations.Capabilities?.SearchRestrictions?.Searchable;\n\t}\n}\n","import type { DynamicAnnotationExpression, Property, String } from \"@sap-ux/vocabularies-types\";\nimport type { DataFieldTypes } from \"@sap-ux/vocabularies-types/vocabularies/UI\";\nimport { TextArrangementType } from \"@sap-ux/vocabularies-types/vocabularies/UI\";\nimport type MetaPath from \"../../../MetaPath\";\nimport type { PageTargetEntity } from \"../../../floorplans/DefinitionPage\";\nimport type { Expression, PrimitiveType } from \"../../../utils/Expression\";\nimport {\n\tconcat,\n\tgetExpressionFromAnnotation,\n\tifElse,\n\tnotEqual,\n\ttransformRecursively,\n\tunresolvableExpression\n} from \"../../../utils/Expression\";\nimport { isPathAnnotationExpression } from \"../../../utils/TypeGuards\";\n\nexport class _DataField {\n\tconstructor(\n\t\tprivate readonly dataField: DataFieldTypes,\n\t\tprivate readonly pageMetaPath: MetaPath<PageTargetEntity>\n\t) {}\n\n\tgetValue(): Expression<PrimitiveType> {\n\t\treturn getExpressionFromAnnotation<PrimitiveType>(this.dataField.Value as DynamicAnnotationExpression<PrimitiveType>);\n\t}\n\n\tgetFormattedValue(): Expression<PrimitiveType> {\n\t\t// Compute display mode and then return the formatted value\n\t\t// Also consider units and currency\n\t\tconst targetValue = getExpressionFromAnnotation(this.dataField.Value as DynamicAnnotationExpression<PrimitiveType>);\n\t\treturn transformRecursively(targetValue, \"PathInModel\", (value): Expression<PrimitiveType> => {\n\t\t\tconst propertyMetaPath = this.pageMetaPath.getMetaPathForPath<Property>(value.path);\n\t\t\tif (!propertyMetaPath) {\n\t\t\t\treturn unresolvableExpression;\n\t\t\t}\n\n\t\t\tconst measure = this.getMeasure(propertyMetaPath);\n\t\t\tif (measure) {\n\t\t\t\treturn concat(value, \" \", measure);\n\t\t\t}\n\n\t\t\tconst displayMode = this.getDisplayMode(propertyMetaPath);\n\t\t\tif (displayMode !== \"Value\") {\n\t\t\t\tconst text = getExpressionFromAnnotation(propertyMetaPath.getTarget().annotations.Common?.Text);\n\t\t\t\tif (displayMode === \"Description\") {\n\t\t\t\t\treturn text;\n\t\t\t\t} else if (displayMode === \"DescriptionValue\") {\n\t\t\t\t\treturn concat(text, \" (\", value, \")\");\n\t\t\t\t} else if (displayMode === \"ValueDescription\") {\n\t\t\t\t\treturn concat(value, ifElse(notEqual(text, undefined), concat(\" (\", text, \")\"), \"\"));\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn value;\n\t\t}) as Expression<PrimitiveType>;\n\t}\n\n\t/**\n\t * Checks if the given property has a Unit or ISOCurrency annotation and returns it.\n\t *\n\t * @param property property to get the measure for\n\t * @returns the measure annotation or undefined\n\t */\n\tgetMeasure(property: MetaPath<Property>): Expression<String> | undefined {\n\t\tconst measures = property.getTarget().annotations.Measures;\n\t\tif (measures) {\n\t\t\tconst measure = measures.Unit ?? measures.ISOCurrency;\n\t\t\tif (measure) {\n\t\t\t\treturn getExpressionFromAnnotation(measure);\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n\n\tgetDisplayMode(property: MetaPath<Property>): \"Description\" | \"Value\" | \"DescriptionValue\" | \"ValueDescription\" {\n\t\tconst currentEntityType = property.getClosestEntityType();\n\t\tconst textAnnotation = property.getTarget().annotations.Common?.Text;\n\t\tconst textArrangement = textAnnotation?.annotations?.UI?.TextArrangement ?? currentEntityType.annotations.UI?.TextArrangement;\n\n\t\tlet displayMode: \"Description\" | \"Value\" | \"DescriptionValue\" | \"ValueDescription\" = textAnnotation ? \"DescriptionValue\" : \"Value\";\n\t\tif (textAnnotation && textArrangement != null) {\n\t\t\tif (textArrangement === TextArrangementType.TextOnly) {\n\t\t\t\tdisplayMode = \"Description\";\n\t\t\t} else if (textArrangement === TextArrangementType.TextLast) {\n\t\t\t\tdisplayMode = \"ValueDescription\";\n\t\t\t} else if (textArrangement === TextArrangementType.TextSeparate) {\n\t\t\t\tdisplayMode = \"Value\";\n\t\t\t} else {\n\t\t\t\t//Default should be TextFirst if there is a Text annotation and neither TextOnly nor TextLast are set\n\t\t\t\tdisplayMode = \"DescriptionValue\";\n\t\t\t}\n\t\t}\n\t\treturn displayMode;\n\t}\n\n\tgetLabel(): string {\n\t\tlet label = this.dataField.Label?.toString() ?? this.dataField.annotations?.Common?.Label?.toString();\n\t\tif (!label) {\n\t\t\tconst valueTarget = this.dataField.Value as DynamicAnnotationExpression<unknown>;\n\t\t\tif (isPathAnnotationExpression(valueTarget)) {\n\t\t\t\tlabel = valueTarget.$target?.annotations.Common?.Label?.toString() ?? valueTarget.$target?.name ?? valueTarget.path;\n\t\t\t} else {\n\t\t\t\tlabel = this.dataField.fullyQualifiedName;\n\t\t\t}\n\t\t}\n\t\treturn label;\n\t}\n\n\t/**\n\t * Retrieve a property from the data field IF it can be easily determined (no complex exression)\n\t */\n\tgetProperty(): Property | undefined {\n\t\tconst valueTarget = this.dataField.Value as DynamicAnnotationExpression<unknown>;\n\t\tif (isPathAnnotationExpression(valueTarget)) {\n\t\t\treturn valueTarget.$target;\n\t\t}\n\t}\n\n\tgetFullyQualifiedName(): string {\n\t\treturn this.dataField.fullyQualifiedName;\n\t}\n}\n","import {\n\tUIAnnotationTypes,\n\ttype DataFieldTypes,\n\ttype Identification,\n\ttype ImportanceType\n} from \"@sap-ux/vocabularies-types/vocabularies/UI\";\nimport type MetaPath from \"../../../MetaPath\";\nimport type { PageTargetEntity } from \"../../../floorplans/DefinitionPage\";\nimport { _DataField } from \"./_DataField\";\n\nexport class _Identification {\n\tconstructor(\n\t\tprotected readonly id: Identification,\n\t\tprotected readonly pageMetaPath: MetaPath<PageTargetEntity>\n\t) {}\n\n\tgetDataFields(options?: { importance?: ImportanceType[]; restrictTypes?: string[] }): _DataField[] {\n\t\treturn this.id\n\t\t\t.filter((item): item is DataFieldTypes => {\n\t\t\t\tif (options?.restrictTypes && !options.restrictTypes.includes(item.$Type)) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tswitch (item.$Type) {\n\t\t\t\t\tcase UIAnnotationTypes.DataField:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldWithUrl:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldWithAction:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldWithActionGroup:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldWithIntentBasedNavigation:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldWithNavigationPath:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldForAnnotation:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldForAction:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldForIntentBasedNavigation:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldForActionGroup:\n\t\t\t\t\t\treturn (\n\t\t\t\t\t\t\toptions?.importance === undefined ||\n\t\t\t\t\t\t\toptions.importance.includes(item.annotations?.UI?.Importance?.toString() as ImportanceType)\n\t\t\t\t\t\t);\n\t\t\t\t\tdefault:\n\t\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t})\n\t\t\t.map((item) => {\n\t\t\t\treturn new _DataField(item, this.pageMetaPath);\n\t\t\t});\n\t}\n}\n","import type {\n\tDataFieldForAction,\n\tDataFieldTypes,\n\tImportanceType,\n\tLineItem,\n\tPresentationVariant,\n\tSelectionPresentationVariant\n} from \"@sap-ux/vocabularies-types/vocabularies/UI\";\nimport { UIAnnotationTerms, UIAnnotationTypes } from \"@sap-ux/vocabularies-types/vocabularies/UI\";\nimport type MetaPath from \"../../../MetaPath\";\nimport type { PageTargetEntity } from \"../../../floorplans/DefinitionPage\";\nimport { _DataField } from \"./_DataField\";\n\nexport class _LineItem {\n\tconstructor(\n\t\tprivate readonly lineItem: LineItem,\n\t\tprivate readonly pageMetaPath: MetaPath<PageTargetEntity>\n\t) {}\n\n\tstatic createDefault(pageMetaPath: MetaPath<PageTargetEntity>): _LineItem {\n\t\tconst fakeLineItemAnnotation: LineItem = pageMetaPath.getClosestEntityType().entityProperties.map((prop) => {\n\t\t\tif (prop.annotations.UI?.DataFieldDefault) {\n\t\t\t\treturn prop.annotations.UI.DataFieldDefault;\n\t\t\t} else {\n\t\t\t\treturn {\n\t\t\t\t\t$Type: UIAnnotationTypes.DataField,\n\t\t\t\t\tValue: {\n\t\t\t\t\t\ttype: \"Path\",\n\t\t\t\t\t\tpath: prop.name,\n\t\t\t\t\t\t$target: prop\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t}\n\t\t}) as LineItem;\n\t\tfakeLineItemAnnotation.term = UIAnnotationTerms.LineItem;\n\t\treturn new _LineItem(fakeLineItemAnnotation, pageMetaPath);\n\t}\n\n\tstatic fromSPV(\n\t\tspv: LineItem | PresentationVariant | SelectionPresentationVariant | undefined,\n\t\tpageMetaPath: MetaPath<PageTargetEntity>\n\t): _LineItem | undefined {\n\t\tswitch (spv?.term) {\n\t\t\tcase UIAnnotationTerms.LineItem:\n\t\t\t\treturn new _LineItem(spv, pageMetaPath);\n\t\t\tcase UIAnnotationTerms.PresentationVariant:\n\t\t\t\treturn new _LineItem(spv.Visualizations[0]!.$target as LineItem, pageMetaPath);\n\t\t\tcase UIAnnotationTerms.SelectionPresentationVariant:\n\t\t\t\treturn new _LineItem(spv.PresentationVariant.Visualizations[0]!.$target as LineItem, pageMetaPath);\n\t\t\tcase undefined:\n\t\t\t\treturn undefined;\n\t\t}\n\t}\n\n\tgetActions(): DataFieldForAction[] {\n\t\treturn this.lineItem.filter((item): item is DataFieldForAction => item.$Type === UIAnnotationTypes.DataFieldForAction);\n\t}\n\n\tgetHeaderActions(): DataFieldForAction[] {\n\t\treturn this.getActions().filter((action) => action.Determining === true);\n\t}\n\n\tgetDataFields(options?: { importance?: ImportanceType[]; restrictTypes?: string[] }): _DataField[] {\n\t\treturn this.lineItem\n\t\t\t.filter((item): item is DataFieldTypes => {\n\t\t\t\tif (options?.restrictTypes && !options.restrictTypes.includes(item.$Type)) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tswitch (item.$Type) {\n\t\t\t\t\tcase UIAnnotationTypes.DataField:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldWithUrl:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldWithAction:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldWithActionGroup:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldWithIntentBasedNavigation:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldWithNavigationPath:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldForAnnotation:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldForAction:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldForIntentBasedNavigation:\n\t\t\t\t\tcase UIAnnotationTypes.DataFieldForActionGroup:\n\t\t\t\t\t\treturn (\n\t\t\t\t\t\t\toptions?.importance === undefined ||\n\t\t\t\t\t\t\toptions.importance.includes(item.annotations?.UI?.Importance?.toString() as ImportanceType)\n\t\t\t\t\t\t);\n\t\t\t\t\tdefault:\n\t\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t})\n\t\t\t.map((item) => {\n\t\t\t\treturn new _DataField(item, this.pageMetaPath);\n\t\t\t});\n\t}\n}\n","import type {\n\tAndAnnotationExpression,\n\tAndConditionalExpression,\n\tApplyAnnotationExpression,\n\tBoolean,\n\tConditionalCheckOrValue,\n\tEntitySet,\n\tEntityType,\n\tEqAnnotationExpression,\n\tEqConditionalExpression,\n\tGeAnnotationExpression,\n\tGeConditionalExpression,\n\tGtAnnotationExpression,\n\tGtConditionalExpression,\n\tIfAnnotationExpression,\n\tIfAnnotationExpressionValue,\n\tLeAnnotationExpression,\n\tLeConditionalExpression,\n\tLtAnnotationExpression,\n\tLtConditionalExpression,\n\tNeAnnotationExpression,\n\tNeConditionalExpression,\n\tNotAnnotationExpression,\n\tNotConditionalExpression,\n\tOrAnnotationExpression,\n\tOrConditionalExpression,\n\tPathAnnotationExpression,\n\tPathConditionExpression,\n\tProperty,\n\tPropertyAnnotationValue\n} from \"@sap-ux/vocabularies-types\";\nimport { CommonAnnotationTerms } from \"@sap-ux/vocabularies-types/vocabularies/Common\";\n\nexport type PrimitiveType = string | number | bigint | boolean | object | null | undefined;\ntype DefinedPrimitiveType = string | number | bigint | boolean | object;\ntype PrimitiveTypeCast<P> = P extends string ? string : P extends Boolean ? boolean : P extends number ? number : P;\ntype BaseExpression<_T> = {\n\t_type: string;\n};\n\nexport type FormatOptions = Partial<{\n\tcustomUnits: Record<string, object>;\n\tcustomCurrencies: Record<string, object>;\n\tdecimals: number;\n\temptyString: null | number | string;\n\tfiscalType: string;\n\tgroupingEnabled: boolean;\n\tmaxFractionDigits: number;\n\tmaxIntegerDigits: number;\n\tminFractionDigits: number;\n\tminIntegerDigits: number;\n\tparseAsString: boolean;\n\tparseKeepsEmptyString: boolean;\n\tpattern: string;\n\tprecision: number;\n\tpreserveDecimals: boolean;\n\tshortDecimals: number;\n\tshortRefNumber: number;\n\tshowMeasure: boolean;\n\tshowNumber: boolean;\n\tshowScale: boolean;\n\tstyle: string;\n}>;\n\nexport type ConstantExpression<T> = BaseExpression<T> & {\n\t_type: \"Constant\";\n\tvalue: T;\n};\n\ntype SetOperator = \"&&\" | \"||\";\nexport type SetExpression = BaseExpression<boolean> & {\n\t_type: \"Set\";\n\toperator: SetOperator;\n\toperands: Expression<boolean>[];\n};\n\nexport type NotExpression = BaseExpression<boolean> & {\n\t_type: \"Not\";\n\toperand: Expression<boolean>;\n};\n\nexport type TruthyExpression = BaseExpression<boolean> & {\n\t_type: \"Truthy\";\n\toperand: Expression<string>;\n};\n\nexport type ReferenceExpression = BaseExpression<object> & {\n\t_type: \"Ref\";\n\tref: string | null;\n};\n\nexport type FormatterExpression<T> = BaseExpression<T> & {\n\t_type: \"Formatter\";\n\tfn: string;\n\tparameters: Expression<unknown>[];\n};\n\ntype ComplexTypeExpression<T> = BaseExpression<T> & {\n\t_type: \"ComplexType\";\n\ttype: string;\n\tformatOptions: FormatOptions;\n\tparameters: object;\n\tbindingParameters: Expression<unknown>[];\n};\n\nexport type FunctionExpression<T> = BaseExpression<T> & {\n\t_type: \"Function\";\n\tobj?: Expression<object>;\n\tfn: string;\n\tisFormattingFn: boolean;\n\tparameters: Expression<unknown>[];\n};\n\nexport type ConcatExpression = BaseExpression<string> & {\n\t_type: \"Concat\";\n\texpressions: Expression<string>[];\n};\n\nexport type LengthExpression = BaseExpression<string> & {\n\t_type: \"Length\";\n\tpathInModel: PathInModelExpression<unknown>;\n};\n\ntype UnresolvablePathExpression = BaseExpression<string> & {\n\t_type: \"Unresolvable\";\n};\n\n/**\n */\nexport type PathInModelExpression<T> = BaseExpression<T> & {\n\t_type: \"PathInModel\";\n\tmodelName?: string;\n\tpath: string;\n\ttargetEntitySet?: EntitySet;\n\ttype?: string;\n\tparameters?: object;\n\ttargetType?: string;\n\tmode?: string;\n\tformatOptions?: FormatOptions;\n};\n\nexport type EmbeddedUI5BindingExpression<T> = BaseExpression<T> & {\n\t_type: \"EmbeddedBinding\";\n\tvalue: string;\n};\n\nexport type EmbeddedUI5ExpressionBindingExpression<T> = BaseExpression<T> & {\n\t_type: \"EmbeddedExpressionBinding\";\n\tvalue: string;\n};\n\nexport type ComparisonOperator = \"===\" | \"!==\" | \">=\" | \">\" | \"<=\" | \"<\";\nexport type ComparisonExpression = BaseExpression<boolean> & {\n\t_type: \"Comparison\";\n\toperator: ComparisonOperator;\n\toperand1: Expression<unknown>;\n\toperand2: Expression<unknown>;\n};\n\nexport type IfElseExpression<T> = BaseExpression<T> & {\n\t_type: \"IfElse\";\n\tcondition: Expression<boolean>;\n\tonTrue: Expression<T>;\n\tonFalse: Expression<T>;\n};\n\n/**\n * An expression that evaluates to type T.\n *\n */\nexport type Expression<T> =\n\t| UnresolvablePathExpression\n\t| ConstantExpression<T>\n\t| SetExpression\n\t| NotExpression\n\t| TruthyExpression\n\t| ConcatExpression\n\t| LengthExpression\n\t| PathInModelExpression<T>\n\t| EmbeddedUI5BindingExpression<T>\n\t| EmbeddedUI5ExpressionBindingExpression<T>\n\t| ComparisonExpression\n\t| IfElseExpression<T>\n\t| FormatterExpression<T>\n\t| ComplexTypeExpression<T>\n\t| ReferenceExpression\n\t| FunctionExpression<T>;\n\n/**\n * An expression that evaluates to type T, or a constant value of type T\n */\nexport type ExpressionOrPrimitive<T extends PrimitiveType> = Expression<T> | T;\n\nexport const unresolvableExpression: UnresolvablePathExpression = {\n\t_type: \"Unresolvable\"\n};\n\nexport function hasUnresolvableExpression(...expressions: Expression<unknown>[]): boolean {\n\treturn expressions.find((expr) => expr._type === \"Unresolvable\") !== undefined;\n}\n/**\n * Check two expressions for (deep) equality.\n *\n * @param a\n * @param b\n * @returns `true` if the two expressions are equal\n */\nexport function _checkExpressionsAreEqual<T>(a?: Expression<T>, b?: Expression<T>): boolean {\n\tif (!a || !b) {\n\t\treturn false;\n\t}\n\tif (a._type !== b._type) {\n\t\treturn false;\n\t}\n\n\tswitch (a._type) {\n\t\tcase \"Unresolvable\":\n\t\t\treturn false; // Unresolvable is never equal to anything even itself\n\t\tcase \"Constant\":\n\t\tcase \"EmbeddedBinding\":\n\t\tcase \"EmbeddedExpressionBinding\":\n\t\t\treturn a.value === (b as ConstantExpression<T>).value;\n\n\t\tcase \"Not\":\n\t\t\treturn _checkExpressionsAreEqual(a.operand, (b as NotExpression).operand);\n\t\tcase \"Truthy\":\n\t\t\treturn _checkExpressionsAreEqual(a.operand, (b as TruthyExpression).operand);\n\t\tcase \"Set\":\n\t\t\treturn (\n\t\t\t\ta.operator === (b as SetExpression).operator &&\n\t\t\t\ta.operands.length === (b as SetExpression).operands.length &&\n\t\t\t\ta.operands.every((expression) =>\n\t\t\t\t\t(b as SetExpression).operands.some((otherExpression) => _checkExpressionsAreEqual(expression, otherExpression))\n\t\t\t\t)\n\t\t\t);\n\n\t\tcase \"IfElse\":\n\t\t\treturn (\n\t\t\t\t_checkExpressionsAreEqual(a.condition, (b as IfElseExpression<T>).condition) &&\n\t\t\t\t_checkExpressionsAreEqual(a.onTrue, (b as IfElseExpression<T>).onTrue) &&\n\t\t\t\t_checkExpressionsAreEqual(a.onFalse, (b as IfElseExpression<T>).onFalse)\n\t\t\t);\n\n\t\tcase \"Comparison\":\n\t\t\treturn (\n\t\t\t\ta.operator === (b as ComparisonExpression).operator &&\n\t\t\t\t_checkExpressionsAreEqual(a.operand1, (b as ComparisonExpression).operand1) &&\n\t\t\t\t_checkExpressionsAreEqual(a.operand2, (b as ComparisonExpression).operand2)\n\t\t\t);\n\n\t\tcase \"Concat\": {\n\t\t\tconst aExpressions = a.expressions;\n\t\t\tconst bExpressions = (b as ConcatExpression).expressions;\n\t\t\tif (aExpressions.length !== bExpressions.length) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\treturn aExpressions.every((expression, index) => {\n\t\t\t\treturn _checkExpressionsAreEqual(expression, bExpressions[index]);\n\t\t\t});\n\t\t}\n\n\t\tcase \"Length\":\n\t\t\treturn _checkExpressionsAreEqual(a.pathInModel, (b as LengthExpression).pathInModel);\n\n\t\tcase \"PathInModel\":\n\t\t\treturn (\n\t\t\t\ta.modelName === (b as PathInModelExpression<T>).modelName &&\n\t\t\t\ta.path === (b as PathInModelExpression<T>).path &&\n\t\t\t\ta.targetEntitySet === (b as PathInModelExpression<T>).targetEntitySet\n\t\t\t);\n\n\t\tcase \"Formatter\":\n\t\t\treturn (\n\t\t\t\ta.fn === (b as FormatterExpression<T>).fn &&\n\t\t\t\ta.parameters.length === (b as FormatterExpression<T>).parameters.length &&\n\t\t\t\ta.parameters.every((value, index) => _checkExpressionsAreEqual((b as FormatterExpression<T>).parameters[index], value))\n\t\t\t);\n\t\tcase \"ComplexType\":\n\t\t\treturn (\n\t\t\t\ta.type === (b as ComplexTypeExpression<T>).type &&\n\t\t\t\ta.bindingParameters.length === (b as ComplexTypeExpression<T>).bindingParameters.length &&\n\t\t\t\ta.bindingParameters.every((value, index) =>\n\t\t\t\t\t_checkExpressionsAreEqual((b as ComplexTypeExpression<T>).bindingParameters[index], value)\n\t\t\t\t)\n\t\t\t);\n\t\tcase \"Function\":\n\t\t\tconst otherFunction = b as FunctionExpression<T>;\n\t\t\tif (a.obj === undefined || otherFunction.obj === undefined) {\n\t\t\t\treturn a.obj === otherFunction;\n\t\t\t}\n\n\t\t\treturn (\n\t\t\t\ta.fn === otherFunction.fn &&\n\t\t\t\t_checkExpressionsAreEqual(a.obj, otherFunction.obj) &&\n\t\t\t\ta.parameters.length === otherFunction.parameters.length &&\n\t\t\t\ta.parameters.every((value, index) => _checkExpressionsAreEqual(otherFunction.parameters[index], value))\n\t\t\t);\n\n\t\tcase \"Ref\":\n\t\t\treturn a.ref === (b as ReferenceExpression).ref;\n\t}\n\treturn false;\n}\n\n/**\n * Converts a nested SetExpression by inlining operands of type SetExpression with the same operator.\n *\n * @param expression The expression to flatten\n * @returns A new SetExpression with the same operator\n */\nfunction flattenSetExpression(expression: SetExpression): SetExpression {\n\treturn expression.operands.reduce<SetExpression>(\n\t\t(result: SetExpression, operand) => {\n\t\t\tconst candidatesForFlattening =\n\t\t\t\toperand._type === \"Set\" && operand.operator === expression.operator ? operand.operands : [operand];\n\t\t\tcandidatesForFlattening.forEach((candidate) => {\n\t\t\t\tif (result.operands.every((e) => !_checkExpressionsAreEqual(e, candidate))) {\n\t\t\t\t\tresult.operands.push(candidate);\n\t\t\t\t}\n\t\t\t});\n\t\t\treturn result;\n\t\t},\n\t\t{ _type: \"Set\", operator: expression.operator, operands: [] }\n\t);\n}\n\n/**\n * Detects whether an array of boolean expressions contains an expression and its negation.\n *\n * @param expressions Array of expressions\n * @returns `true` if the set of expressions contains an expression and its negation\n */\nfunction hasOppositeExpressions(expressions: Expression<boolean>[]): boolean {\n\tconst negatedExpressions = expressions.map(not);\n\treturn expressions.some((expression, index) => {\n\t\tfor (let i = index + 1; i < negatedExpressions.length; i++) {\n\t\t\tif (_checkExpressionsAreEqual(expression, negatedExpressions[i])) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t});\n}\n\n/**\n * Logical `and` expression.\n *\n * The expression is simplified to false if this can be decided statically (that is, if one operand is a constant\n * false or if the expression contains an operand and its negation).\n *\n * @param operands Expressions to connect by `and`\n * @returns Expression evaluating to boolean\n */\nexport function and(...operands: ExpressionOrPrimitive<boolean>[]): Expression<boolean> {\n\tconst expressions = flattenSetExpression({\n\t\t_type: \"Set\",\n\t\toperator: \"&&\",\n\t\toperands: operands.map(wrapPrimitive)\n\t}).operands;\n\n\tif (hasUnresolvableExpression(...expressions)) {\n\t\treturn unresolvableExpression;\n\t}\n\tlet isStaticFalse = false;\n\tconst nonTrivialExpression = expressions.filter((expression) => {\n\t\tif (isFalse(expression)) {\n\t\t\tisStaticFalse = true;\n\t\t}\n\t\treturn !isConstant(expression);\n\t});\n\tif (isStaticFalse) {\n\t\treturn constant(false);\n\t} else if (nonTrivialExpression.length === 0) {\n\t\t// Resolve the constant then\n\t\tconst isValid = expressions.reduce((result, expression) => result && isTrue(expression), true);\n\t\treturn constant(isValid);\n\t} else if (nonTrivialExpression.length === 1) {\n\t\treturn nonTrivialExpression[0]!;\n\t} else if (hasOppositeExpressions(nonTrivialExpression)) {\n\t\treturn constant(false);\n\t} else {\n\t\treturn {\n\t\t\t_type: \"Set\",\n\t\t\toperator: \"&&\",\n\t\t\toperands: nonTrivialExpression\n\t\t};\n\t}\n}\n\n// let tracer: any;\n// export function traceExpression(inTracer: never): void {\n// \ttracer = inTracer;\n// }\n//\n// export function pickFirstNonNull(\n// \t...operands: ExpressionOrPrimitive<PrimitiveType>[]\n// ): ExpressionOrPrimitive<PrimitiveType> {\n// \tconst result = operands.find((operand) => operand !== undefined);\n// \tif (tracer) {\n// \t\ttracer.logConditional(\"pickFirstNonNull\", operands, result);\n// \t}\n// \treturn result;\n// }\n/**\n * Logical `or` expression.\n *\n * The expression is simplified to true if this can be decided statically (that is, if one operand is a constant\n * true or if the expression contains an operand and its negation).\n *\n * @param operands Expressions to connect by `or`\n * @returns Expression evaluating to boolean\n */\nexport function or(...operands: ExpressionOrPrimitive<boolean>[]): Expression<boolean> {\n\tconst expressions = flattenSetExpression({\n\t\t_type: \"Set\",\n\t\toperator: \"||\",\n\t\toperands: operands.map(wrapPrimitive)\n\t}).operands;\n\tif (hasUnresolvableExpression(...expressions)) {\n\t\treturn unresolvableExpression;\n\t}\n\tlet isStaticTrue = false;\n\tconst nonTrivialExpression = expressions.filter((expression) => {\n\t\tif (isTrue(expression)) {\n\t\t\tisStaticTrue = true;\n\t\t}\n\t\treturn !isConstant(expression) || expression.value;\n\t});\n\tif (isStaticTrue) {\n\t\treturn constant(true);\n\t} else if (nonTrivialExpression.length === 0) {\n\t\t// Resolve the constant then\n\t\tconst isValid = expressions.reduce((result, expression) => result && isTrue(expression), true);\n\t\treturn constant(isValid);\n\t} else if (nonTrivialExpression.length === 1) {\n\t\treturn nonTrivialExpression[0]!;\n\t} else if (hasOppositeExpressions(nonTrivialExpression)) {\n\t\treturn constant(true);\n\t} else {\n\t\treturn {\n\t\t\t_type: \"Set\",\n\t\t\toperator: \"||\",\n\t\t\toperands: nonTrivialExpression\n\t\t};\n\t}\n}\n\n/**\n * Logical `not` operator.\n *\n * @param operand The expression to reverse\n * @returns The resulting expression that evaluates to boolean\n */\nexport function not(operand: ExpressionOrPrimitive<boolean>): Expression<boolean> {\n\toperand = wrapPrimitive(operand);\n\tif (hasUnresolvableExpression(operand)) {\n\t\treturn unresolvableExpression;\n\t} else if (isConstant(operand)) {\n\t\treturn constant(!operand.value);\n\t} else if (\n\t\ttypeof operand === \"object\" &&\n\t\toperand._type === \"Set\" &&\n\t\toperand.operator === \"||\" &&\n\t\toperand.operands.every((expression) => isConstant(expression) || isComparison(expression))\n\t) {\n\t\treturn and(...operand.operands.map((expression) => not(expression)));\n\t} else if (\n\t\ttypeof operand === \"object\" &&\n\t\toperand._type === \"Set\" &&\n\t\toperand.operator === \"&&\" &&\n\t\toperand.operands.every((expression) => isConstant(expression) || isComparison(expression))\n\t) {\n\t\treturn or(...operand.operands.map((expression) => not(expression)));\n\t} else if (isComparison(operand)) {\n\t\t// Create the reverse comparison\n\t\tswitch (operand.operator) {\n\t\t\tcase \"!==\":\n\t\t\t\treturn { ...operand, operator: \"===\" };\n\t\t\tcase \"<\":\n\t\t\t\treturn { ...operand, operator: \">=\" };\n\t\t\tcase \"<=\":\n\t\t\t\treturn { ...operand, operator: \">\" };\n\t\t\tcase \"===\":\n\t\t\t\treturn { ...operand, operator: \"!==\" };\n\t\t\tcase \">\":\n\t\t\t\treturn { ...operand, operator: \"<=\" };\n\t\t\tcase \">=\":\n\t\t\t\treturn { ...operand, operator: \"<\" };\n\t\t}\n\t} else if (operand._type === \"Not\") {\n\t\treturn operand.operand;\n\t}\n\n\treturn {\n\t\t_type: \"Not\",\n\t\toperand: operand\n\t};\n}\n\n/**\n * Evaluates whether a binding expression is equal to true with a loose equality.\n *\n * @param operand The expression to check\n * @returns The resulting expression that evaluates to boolean\n */\nexport function isTruthy(operand: Expression<string>): Expression<boolean> {\n\tif (isConstant(operand)) {\n\t\treturn constant(!!operand.value);\n\t} else {\n\t\treturn {\n\t\t\t_type: \"Truthy\",\n\t\t\toperand: operand\n\t\t};\n\t}\n}\n\n/**\n * Creates a binding expression that will be evaluated by the corresponding model.\n *\n * @param path\n * @param modelName\n * @param visitedNavigationPaths\n * @param pathVisitor\n * @returns An expression representating that path in the model\n */\nexport function objectPath<TargetType extends PrimitiveType>(\n\tpath: string,\n\tmodelName?: string,\n\tvisitedNavigationPaths: string[] = [],\n\tpathVisitor?: Function\n): PathInModelExpression<TargetType> | UnresolvablePathExpression {\n\treturn pathInModel(path, modelName, visitedNavigationPaths, pathVisitor);\n}\n\n/**\n * Creates a binding expression that will be evaluated by the corresponding model.\n *\n * @template TargetType\n * @param path The path on the model\n * @param [modelName] The name of the model\n * @param [visitedNavigationPaths] The paths from the root entitySet\n * @param [pathVisitor] A function to modify the resulting path\n * @returns An expression representating that path in the model\n */\nexport function pathInModel(\n\tpath: undefined,\n\tmodelName?: string,\n\tvisitedNavigationPaths?: string[],\n\tpathVisitor?: Function\n): UnresolvablePathExpression;\nexport function pathInModel<TargetType extends PrimitiveType>(\n\tpath: string,\n\tmodelName?: string,\n\tvisitedNavigationPaths?: string[],\n\tpathVisitor?: undefined\n): PathInModelExpression<TargetType>;\nexport function pathInModel<TargetType extends PrimitiveType>(\n\tpath: string | undefined,\n\tmodelName?: string,\n\tvisitedNavigationPaths?: string[],\n\tpathVisitor?: Function\n): UnresolvablePathExpression | PathInModelExpression<TargetType>;\nexport function pathInModel<TargetType extends PrimitiveType>(\n\tpath: string | undefined,\n\tmodelName?: string,\n\tvisitedNavigationPaths: string[] = [],\n\tpathVisitor?: Function\n): UnresolvablePathExpression | PathInModelExpression<TargetType> {\n\tif (path === undefined) {\n\t\treturn unresolvableExpression;\n\t}\n\tlet targetPath: string;\n\tif (pathVisitor) {\n\t\ttargetPath = pathVisitor(path) as string;\n\t\tif (targetPath === undefined) {\n\t\t\treturn unresolvableExpression;\n\t\t}\n\t} else {\n\t\tconst localPath = visitedNavigationPaths.concat();\n\t\tlocalPath.push(path);\n\t\ttargetPath = localPath.join(\"/\");\n\t}\n\treturn {\n\t\t_type: \"PathInModel\",\n\t\tmodelName: modelName,\n\t\tpath: targetPath\n\t};\n}\n\ntype PlainExpressionObject = { [index: string]: Expression<unknown> };\n\n/**\n * Creates a constant expression based on a primitive value.\n *\n * @template T\n * @param value The constant to wrap in an expression\n * @returns The constant expression\n */\nexport function constant<T extends PrimitiveType>(value: T): ConstantExpression<T> {\n\tlet constantValue: T;\n\n\tif (typeof value === \"object\" && value !== null && value !== undefined) {\n\t\tif (Array.isArray(value)) {\n\t\t\tconstantValue = value.map(wrapPrimitive) as T;\n\t\t} else if (isPrimitiveObject(value)) {\n\t\t\tconstantValue = value.valueOf() as T;\n\t\t} else {\n\t\t\tconstantValue = Object.entries(value).reduce((plainExpression, [key, val]) => {\n\t\t\t\tconst wrappedValue = wrapPrimitive(val);\n\t\t\t\tif (wrappedValue._type !== \"Constant\" || wrappedValue.value !== undefined) {\n\t\t\t\t\tplainExpression[key as keyof typeof plainExpression] = wrappedValue as never;\n\t\t\t\t}\n\t\t\t\treturn plainExpression;\n\t\t\t}, {} satisfies PlainExpressionObject) as T;\n\t\t}\n\t} else {\n\t\tconstantValue = value;\n\t}\n\n\treturn { _type: \"Constant\", value: constantValue };\n}\n\nexport function resolveBindingString<T extends PrimitiveType>(\n\tvalue: string | boolean | number,\n\ttargetType?: string\n): ConstantExpression<T> | PathInModelExpression<T> | EmbeddedUI5BindingExpression<T> | EmbeddedUI5ExpressionBindingExpression<T> {\n\tif (value !== undefined && typeof value === \"string\" && value.startsWith(\"{\")) {\n\t\tconst pathInModelRegex = /^{(.*)>(.+)}$/; // Matches model paths like \"model>path\" or \">path\" (default model)\n\t\tconst pathInModelRegexMatch = pathInModelRegex.exec(value);\n\n\t\tif (value.startsWith(\"{=\")) {\n\t\t\t// Expression binding, we can just remove the outer binding things\n\t\t\treturn {\n\t\t\t\t_type: \"EmbeddedExpressionBinding\",\n\t\t\t\tvalue: value\n\t\t\t};\n\t\t} else if (pathInModelRegexMatch) {\n\t\t\treturn pathInModel(pathInModelRegexMatch[2] || \"\", pathInModelRegexMatch[1] || undefined);\n\t\t} else {\n\t\t\treturn {\n\t\t\t\t_type: \"EmbeddedBinding\",\n\t\t\t\tvalue: value\n\t\t\t};\n\t\t}\n\t} else if (targetType === \"boolean\" && typeof value === \"string\" && (value === \"true\" || value === \"false\")) {\n\t\treturn constant(value === \"true\") as ConstantExpression<T>;\n\t} else if (targetType === \"number\" && typeof value === \"string\" && (!isNaN(Number(value)) || value === \"NaN\")) {\n\t\treturn constant(Number(value)) as ConstantExpression<T>;\n\t} else {\n\t\treturn constant(value) as ConstantExpression<T>;\n\t}\n}\n\n/**\n * A named reference.\n *\n * @see fn\n * @param reference Reference\n * @returns The object reference binding part\n */\nexport function ref(reference: string | null): ReferenceExpression {\n\treturn { _type: \"Ref\", ref: reference };\n}\n\n/**\n * Wrap a primitive into a constant expression if it is not already an expression.\n *\n * @template T\n * @param something The object to wrap in a Constant expression\n * @returns Either the original object or the wrapped one depending on the case\n */\nexport function wrapPrimitive<T extends PrimitiveType>(something: ExpressionOrPrimitive<T>): Expression<T> {\n\tif (isExpression(something as Expression<T>)) {\n\t\treturn something as Expression<T>;\n\t}\n\n\treturn constant(something as T);\n}\n\n/**\n * Checks if the expression or value provided is a binding tooling expression or not.\n *\n * Every object having a property named `_type` of some value is considered an expression, even if there is actually\n * no such expression type supported.\n *\n * @param expression\n * @returns `true` if the expression is a binding toolkit expression\n */\nexport function isExpression(expression: unknown): expression is Expression<unknown> {\n\treturn (expression as Expression<unknown> | undefined)?._type !== undefined;\n}\n\n/**\n * Checks if the expression or value provided is constant or not.\n *\n * @template T The target type\n * @param  maybeConstant The expression or primitive value that is to be checked\n * @returns `true` if it is constant\n */\nexport function isConstant<T extends PrimitiveType>(maybeConstant: ExpressionOrPrimitive<T>): maybeConstant is ConstantExpression<T> {\n\treturn typeof maybeConstant !== \"object\" || (maybeConstant as BaseExpression<T>)._type === \"Constant\";\n}\n\nfunction isTrue(expression: Expression<PrimitiveType>): boolean {\n\treturn isConstant(expression) && expression.value === true;\n}\n\nfunction isFalse(expression: Expression<PrimitiveType>): boolean {\n\treturn isConstant(expression) && expression.value === false;\n}\n\n/**\n * Checks if the expression or value provided is a path in model expression or not.\n *\n * @template T The target type\n * @param  maybeBinding The expression or primitive value that is to be checked\n * @returns `true` if it is a path in model expression\n */\nexport function isPathInModelExpression<T extends PrimitiveType>(\n\tmaybeBinding: ExpressionOrPrimitive<T>\n): maybeBinding is PathInModelExpression<T> {\n\treturn (maybeBinding as BaseExpression<T>)._type === \"PathInModel\";\n}\n\n/**\n * Checks if the expression or value provided is a complex type expression.\n *\n * @template T The target type\n * @param  maybeBinding The expression or primitive value that is to be checked\n * @returns `true` if it is a path in model expression\n */\nexport function isComplexTypeExpression<T extends PrimitiveType>(\n\tmaybeBinding: ExpressionOrPrimitive<T>\n): maybeBinding is ComplexTypeExpression<T> {\n\treturn (maybeBinding as BaseExpression<T>)._type === \"ComplexType\";\n}\n\n/**\n * Checks if the expression or value provided is a concat expression or not.\n *\n * @param expression\n * @returns `true` if the expression is a ConcatExpression\n */\nfunction isConcatExpression(expression: Expression<PrimitiveType>): expression is ConcatExpression {\n\treturn (expression as BaseExpression<PrimitiveType>)._type === \"Concat\";\n}\n\n/**\n * Checks if the expression or value provided is a IfElse expression or not.\n *\n * @param expression\n * @returns `true` if the expression is a IfElseExpression\n */\nfunction isIfElseExpression(expression: Expression<PrimitiveType>): expression is ConcatExpression {\n\treturn (expression as BaseExpression<PrimitiveType>)._type === \"IfElse\";\n}\n\n/**\n * Checks if the expression provided is a comparison or not.\n *\n * @template T The target type\n * @param expression The expression\n * @returns `true` if the expression is a ComparisonExpression\n */\nfunction isComparison<T extends PrimitiveType>(expression: Expression<T>): expression is ComparisonExpression {\n\treturn expression._type === \"Comparison\";\n}\n\n/**\n * Checks whether the input parameter is a constant expression of type undefined.\n *\n * @param expression The input expression or object in general\n * @returns `true` if the input is constant which has undefined for value\n */\nexport function isUndefinedExpression(expression: unknown): expression is ConstantExpression<undefined> {\n\tconst expressionAsExpression = expression as Expression<unknown>;\n\treturn expressionAsExpression._type === \"Constant\" && expressionAsExpression.value === undefined;\n}\n\ntype ComplexAnnotationExpression<P> =\n\t| PathAnnotationExpression<P>\n\t| ApplyAnnotationExpression<P>\n\t| IfAnnotationExpression<P>\n\t| OrAnnotationExpression<P>\n\t| AndAnnotationExpression<P>\n\t| NeAnnotationExpression<P>\n\t| EqAnnotationExpression<P>\n\t| NotAnnotationExpression<P>\n\t| GtAnnotationExpression<P>\n\t| GeAnnotationExpression<P>\n\t| LeAnnotationExpression<P>\n\t| LtAnnotationExpression<P>;\n\nfunction isPrimitiveObject(objectType: object): boolean {\n\tswitch (objectType.constructor.name) {\n\t\tcase \"String\":\n\t\tcase \"Number\":\n\t\tcase \"Boolean\":\n\t\t\treturn true;\n\t\tdefault:\n\t\t\treturn false;\n\t}\n}\n/**\n * Check if the passed annotation annotationValue is a ComplexAnnotationExpression.\n *\n * @template T The target type\n * @param  annotationValue The annotation annotationValue to evaluate\n * @returns `true` if the object is a {ComplexAnnotationExpression}\n */\nfunction isComplexAnnotationExpression<T>(annotationValue: PropertyAnnotationValue<T>): annotationValue is ComplexAnnotationExpression<T> {\n\treturn typeof annotationValue === \"object\" && !isPrimitiveObject(annotationValue as object);\n}\n\n/**\n * Generate the corresponding annotationValue for a given annotation annotationValue.\n *\n * @template T The target type\n * @param annotationValue The source annotation annotationValue\n * @param visitedNavigationPaths The path from the root entity set\n * @param defaultValue Default value if the annotationValue is undefined\n * @param pathVisitor A function to modify the resulting path\n * @returns The annotationValue equivalent to that annotation annotationValue\n */\nexport function getExpressionFromAnnotation<T extends PrimitiveType>(\n\tannotationValue: PropertyAnnotationValue<T> | undefined,\n\tvisitedNavigationPaths: string[] = [],\n\tdefaultValue?: ExpressionOrPrimitive<T>,\n\tpathVisitor?: Function\n): Expression<PrimitiveTypeCast<T>> {\n\tif (annotationValue === undefined) {\n\t\treturn wrapPrimitive(defaultValue as PrimitiveTypeCast<T>);\n\t}\n\tannotationValue = annotationValue.valueOf() as PropertyAnnotationValue<T>;\n\tif (!isComplexAnnotationExpression(annotationValue)) {\n\t\treturn constant(annotationValue);\n\t}\n\n\tswitch (annotationValue.type) {\n\t\tcase \"Path\":\n\t\t\treturn pathInModel(annotationValue.path, undefined, visitedNavigationPaths, pathVisitor);\n\t\tcase \"If\":\n\t\t\treturn annotationIfExpression(annotationValue.$If, visitedNavigationPaths, pathVisitor) as Expression<PrimitiveTypeCast<T>>;\n\t\tcase \"Not\":\n\t\t\treturn not(parseAnnotationCondition(annotationValue.$Not, visitedNavigationPaths, pathVisitor)) as Expression<\n\t\t\t\tPrimitiveTypeCast<T>\n\t\t\t>;\n\t\tcase \"Eq\":\n\t\t\treturn equal(\n\t\t\t\tparseAnnotationCondition(annotationValue.$Eq[0]!, visitedNavigationPaths, pathVisitor),\n\t\t\t\tparseAnnotationCondition(annotationValue.$Eq[1]!, visitedNavigationPaths, pathVisitor)\n\t\t\t) as Expression<PrimitiveTypeCast<T>>;\n\t\tcase \"Ne\":\n\t\t\treturn notEqual(\n\t\t\t\tparseAnnotationCondition(annotationValue.$Ne[0]!, visitedNavigationPaths, pathVisitor),\n\t\t\t\tparseAnnotationCondition(annotationValue.$Ne[1]!, visitedNavigationPaths, pathVisitor)\n\t\t\t) as Expression<PrimitiveTypeCast<T>>;\n\t\tcase \"Gt\":\n\t\t\treturn greaterThan(\n\t\t\t\tparseAnnotationCondition(annotationValue.$Gt[0]!, visitedNavigationPaths, pathVisitor),\n\t\t\t\tparseAnnotationCondition(annotationValue.$Gt[1]!, visitedNavigationPaths, pathVisitor)\n\t\t\t) as Expression<PrimitiveTypeCast<T>>;\n\t\tcase \"Ge\":\n\t\t\treturn greaterOrEqual(\n\t\t\t\tparseAnnotationCondition(annotationValue.$Ge[0]!, visitedNavigationPaths, pathVisitor),\n\t\t\t\tparseAnnotationCondition(annotationValue.$Ge[1]!, visitedNavigationPaths, pathVisitor)\n\t\t\t) as Expression<PrimitiveTypeCast<T>>;\n\t\tcase \"Lt\":\n\t\t\treturn lessThan(\n\t\t\t\tparseAnnotationCondition(annotationValue.$Lt[0]!, visitedNavigationPaths, pathVisitor),\n\t\t\t\tparseAnnotationCondition(annotationValue.$Lt[1]!, visitedNavigationPaths, pathVisitor)\n\t\t\t) as Expression<PrimitiveTypeCast<T>>;\n\t\tcase \"Le\":\n\t\t\treturn lessOrEqual(\n\t\t\t\tparseAnnotationCondition(annotationValue.$Le[0]!, visitedNavigationPaths, pathVisitor),\n\t\t\t\tparseAnnotationCondition(annotationValue.$Le[1]!, visitedNavigationPaths, pathVisitor)\n\t\t\t) as Expression<PrimitiveTypeCast<T>>;\n\t\tcase \"Or\":\n\t\t\treturn or(\n\t\t\t\t...annotationValue.$Or.map(function (orCondition) {\n\t\t\t\t\treturn parseAnnotationCondition<boolean>(orCondition, visitedNavigationPaths, pathVisitor);\n\t\t\t\t})\n\t\t\t) as Expression<PrimitiveTypeCast<T>>;\n\t\tcase \"And\":\n\t\t\treturn and(\n\t\t\t\t...annotationValue.$And.map(function (andCondition) {\n\t\t\t\t\treturn parseAnnotationCondition<boolean>(andCondition, visitedNavigationPaths, pathVisitor);\n\t\t\t\t})\n\t\t\t) as Expression<PrimitiveTypeCast<T>>;\n\t\tcase \"Apply\":\n\t\t\treturn annotationApplyExpression(\n\t\t\t\tannotationValue as ApplyAnnotationExpression<string>,\n\t\t\t\tvisitedNavigationPaths,\n\t\t\t\tpathVisitor\n\t\t\t) as Expression<PrimitiveTypeCast<T>>;\n\t}\n\treturn unresolvableExpression;\n}\n\n/**\n * Parse the annotation condition into an expression.\n *\n * @template T The target type\n * @param annotationValue The condition or value from the annotation\n * @param visitedNavigationPaths The path from the root entity set\n * @param pathVisitor A function to modify the resulting path\n * @returns An equivalent expression\n */\nfunction parseAnnotationCondition<T extends PrimitiveType>(\n\tannotationValue: ConditionalCheckOrValue,\n\tvisitedNavigationPaths: string[] = [],\n\tpathVisitor?: Function\n): Expression<T> {\n\tif (annotationValue === null || typeof annotationValue !== \"object\") {\n\t\treturn constant(annotationValue as T);\n\t} else if (annotationValue.hasOwnProperty(\"$Or\")) {\n\t\treturn or(\n\t\t\t...((annotationValue as OrConditionalExpression).$Or.map(function (orCondition) {\n\t\t\t\treturn parseAnnotationCondition(orCondition, visitedNavigationPaths, pathVisitor);\n\t\t\t}) as unknown as Expression<boolean>[])\n\t\t) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"$And\")) {\n\t\treturn and(\n\t\t\t...((annotationValue as AndConditionalExpression).$And.map(function (andCondition) {\n\t\t\t\treturn parseAnnotationCondition(andCondition, visitedNavigationPaths, pathVisitor);\n\t\t\t}) as unknown as Expression<boolean>[])\n\t\t) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"$Not\")) {\n\t\treturn not(\n\t\t\tparseAnnotationCondition((annotationValue as NotConditionalExpression).$Not, visitedNavigationPaths, pathVisitor)\n\t\t) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"$Eq\")) {\n\t\treturn equal(\n\t\t\tparseAnnotationCondition((annotationValue as EqConditionalExpression).$Eq[0], visitedNavigationPaths, pathVisitor),\n\t\t\tparseAnnotationCondition((annotationValue as EqConditionalExpression).$Eq[1], visitedNavigationPaths, pathVisitor)\n\t\t) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"$Ne\")) {\n\t\treturn notEqual(\n\t\t\tparseAnnotationCondition((annotationValue as NeConditionalExpression).$Ne[0], visitedNavigationPaths, pathVisitor),\n\t\t\tparseAnnotationCondition((annotationValue as NeConditionalExpression).$Ne[1], visitedNavigationPaths, pathVisitor)\n\t\t) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"$Gt\")) {\n\t\treturn greaterThan(\n\t\t\tparseAnnotationCondition((annotationValue as GtConditionalExpression).$Gt[0], visitedNavigationPaths, pathVisitor),\n\t\t\tparseAnnotationCondition((annotationValue as GtConditionalExpression).$Gt[1], visitedNavigationPaths, pathVisitor)\n\t\t) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"$Ge\")) {\n\t\treturn greaterOrEqual(\n\t\t\tparseAnnotationCondition((annotationValue as GeConditionalExpression).$Ge[0], visitedNavigationPaths, pathVisitor),\n\t\t\tparseAnnotationCondition((annotationValue as GeConditionalExpression).$Ge[1], visitedNavigationPaths, pathVisitor)\n\t\t) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"$Lt\")) {\n\t\treturn lessThan(\n\t\t\tparseAnnotationCondition((annotationValue as LtConditionalExpression).$Lt[0], visitedNavigationPaths, pathVisitor),\n\t\t\tparseAnnotationCondition((annotationValue as LtConditionalExpression).$Lt[1], visitedNavigationPaths, pathVisitor)\n\t\t) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"$Le\")) {\n\t\treturn lessOrEqual(\n\t\t\tparseAnnotationCondition((annotationValue as LeConditionalExpression).$Le[0], visitedNavigationPaths, pathVisitor),\n\t\t\tparseAnnotationCondition((annotationValue as LeConditionalExpression).$Le[1], visitedNavigationPaths, pathVisitor)\n\t\t) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"$Path\")) {\n\t\treturn pathInModel((annotationValue as PathConditionExpression<T>).$Path, undefined, visitedNavigationPaths, pathVisitor);\n\t} else if (annotationValue.hasOwnProperty(\"Path\")) {\n\t\treturn pathInModel((annotationValue as unknown as { Path: string }).Path, undefined, visitedNavigationPaths, pathVisitor);\n\t} else if (annotationValue.hasOwnProperty(\"$Apply\")) {\n\t\treturn getExpressionFromAnnotation(\n\t\t\t{\n\t\t\t\ttype: \"Apply\",\n\t\t\t\t$Function: (annotationValue as { $Function?: string }).$Function as \"odata.concat\",\n\t\t\t\t$Apply: (annotationValue as { $Apply?: PropertyAnnotationValue<T>[] }).$Apply!\n\t\t\t} satisfies ApplyAnnotationExpression<T>,\n\t\t\tvisitedNavigationPaths,\n\t\t\tundefined,\n\t\t\tpathVisitor\n\t\t) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"$If\")) {\n\t\treturn getExpressionFromAnnotation(\n\t\t\t{\n\t\t\t\ttype: \"If\",\n\t\t\t\t$If: (annotationValue as { $If?: IfAnnotationExpressionValue<T> }).$If!\n\t\t\t} satisfies IfAnnotationExpression<T>,\n\t\t\tvisitedNavigationPaths,\n\t\t\tundefined,\n\t\t\tpathVisitor\n\t\t) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"$EnumMember\")) {\n\t\treturn constant((annotationValue as { $EnumMember?: string }).$EnumMember as T);\n\t} else if (annotationValue.hasOwnProperty(\"String\")) {\n\t\treturn constant((annotationValue as unknown as { String: string }).String) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"Bool\")) {\n\t\treturn constant((annotationValue as unknown as { Bool: boolean }).Bool) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"Int\")) {\n\t\treturn constant((annotationValue as unknown as { Int: number }).Int) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"Decimal\")) {\n\t\treturn constant((annotationValue as unknown as { Decimal: number }).Decimal) as Expression<T>;\n\t} else if (annotationValue.hasOwnProperty(\"type\") && (annotationValue as unknown as { type: string }).type === \"Null\") {\n\t\treturn constant(null) as Expression<T>;\n\t}\n\treturn constant(false as T);\n}\n\n/**\n * Process the {IfAnnotationExpressionValue} into an expression.\n *\n * @template T The target type\n * @param annotationValue An If expression returning the type T\n * @param visitedNavigationPaths The path from the root entity set\n * @param pathVisitor A function to modify the resulting path\n * @returns The equivalent ifElse expression\n */\nexport function annotationIfExpression<T extends PrimitiveType>(\n\tannotationValue: IfAnnotationExpressionValue<T>,\n\tvisitedNavigationPaths: string[] = [],\n\tpathVisitor?: Function\n): Expression<T> {\n\treturn ifElse(\n\t\tparseAnnotationCondition(annotationValue[0], visitedNavigationPaths, pathVisitor),\n\t\tparseAnnotationCondition(annotationValue[1] as ConditionalCheckOrValue, visitedNavigationPaths, pathVisitor),\n\t\tparseAnnotationCondition(annotationValue[2] as ConditionalCheckOrValue, visitedNavigationPaths, pathVisitor)\n\t);\n}\n// This type is not recursively transformed from the metamodel content, as such we have some ugly things there\ntype SubApplyExpressionFromMetamodel = Record<string, unknown>;\nfunction convertSubApplyParameters(applyParam: SubApplyExpressionFromMetamodel): SubApplyExpressionFromMetamodel {\n\tlet applyParamConverted = applyParam;\n\tif (applyParam.hasOwnProperty(\"$Path\")) {\n\t\tapplyParamConverted = {\n\t\t\ttype: \"Path\",\n\t\t\tpath: applyParam.$Path as string\n\t\t} satisfies Partial<PathAnnotationExpression<string>>;\n\t} else if (applyParam.hasOwnProperty(\"$If\")) {\n\t\tapplyParamConverted = {\n\t\t\ttype: \"If\",\n\t\t\t$If: applyParam.$If as IfAnnotationExpressionValue<string>\n\t\t} satisfies IfAnnotationExpression<string>;\n\t} else if (applyParam.hasOwnProperty(\"$Apply\")) {\n\t\tapplyParamConverted = {\n\t\t\ttype: \"Apply\",\n\t\t\t$Function: applyParam.$Function as \"odata.concat\",\n\t\t\t$Apply: applyParam.$Apply as PropertyAnnotationValue<string>[]\n\t\t} satisfies ApplyAnnotationExpression<string>;\n\t}\n\treturn applyParamConverted;\n}\n\ntype ODataFunction = \"odata.concat\" | \"odata.fillUriTemplate\" | \"odata.uriEncode\";\nexport function annotationApplyExpression(\n\tapplyExpression: ApplyAnnotationExpression<string>,\n\tvisitedNavigationPaths: string[] = [],\n\tpathVisitor?: Function\n): Expression<string> {\n\tswitch (applyExpression.$Function as ODataFunction) {\n\t\tcase \"odata.concat\":\n\t\t\treturn concat(\n\t\t\t\t...applyExpression.$Apply.map((applyParam) => {\n\t\t\t\t\treturn getExpressionFromAnnotation(\n\t\t\t\t\t\tconvertSubApplyParameters(applyParam) as PropertyAnnotationValue<string>,\n\t\t\t\t\t\tvisitedNavigationPaths,\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\tpathVisitor\n\t\t\t\t\t);\n\t\t\t\t})\n\t\t\t);\n\t\tcase \"odata.uriEncode\":\n\t\t\tconst parameter = getExpressionFromAnnotation(\n\t\t\t\tconvertSubApplyParameters(\n\t\t\t\t\tapplyExpression.$Apply[0] as unknown as SubApplyExpressionFromMetamodel\n\t\t\t\t) as PropertyAnnotationValue<string>,\n\t\t\t\tvisitedNavigationPaths,\n\t\t\t\tundefined,\n\t\t\t\tpathVisitor\n\t\t\t);\n\t\t\t// The second parameter for uriEncode is always a string since the target evaluation is against a formatValue call in ODataUtils which expect the target type as second parameter\n\t\t\treturn fn(\"odata.uriEncode\", [parameter, \"Edm.String\"], undefined, true);\n\t\tcase \"odata.fillUriTemplate\":\n\t\t\tconst template = applyExpression.$Apply[0];\n\t\t\tconst templateParams = applyExpression.$Apply.slice(1) as unknown as SubApplyExpressionFromMetamodel[];\n\t\t\tconst targetObject: Record<string, Expression<unknown>> = {};\n\t\t\ttemplateParams.forEach((applyParam) => {\n\t\t\t\ttargetObject[applyParam.$Name as string] = getExpressionFromAnnotation(\n\t\t\t\t\tconvertSubApplyParameters(\n\t\t\t\t\t\tapplyParam.$LabeledElement as SubApplyExpressionFromMetamodel\n\t\t\t\t\t) as PropertyAnnotationValue<string>,\n\t\t\t\t\tvisitedNavigationPaths,\n\t\t\t\t\tundefined,\n\t\t\t\t\tpathVisitor\n\t\t\t\t);\n\t\t\t});\n\t\t\treturn fn(\"odata.fillUriTemplate\", [template, targetObject], undefined, true);\n\t}\n\treturn unresolvableExpression;\n}\n\n/**\n * Generic helper for the comparison operations (equal, notEqual, ...).\n *\n * @template T The target type\n * @param operator The operator to apply\n * @param leftOperand The operand on the left side of the operator\n * @param rightOperand The operand on the right side of the operator\n * @returns An expression representing the comparison\n */\nfunction comparison<T extends PrimitiveType>(\n\toperator: ComparisonOperator,\n\tleftOperand: ExpressionOrPrimitive<T>,\n\trightOperand: ExpressionOrPrimitive<T>\n): Expression<boolean> {\n\tconst leftExpression = wrapPrimitive(leftOperand);\n\tconst rightExpression = wrapPrimitive(rightOperand);\n\tif (hasUnresolvableExpression(leftExpression, rightExpression)) {\n\t\treturn unresolvableExpression;\n\t}\n\tif (isConstant(leftExpression) && isConstant(rightExpression)) {\n\t\tswitch (operator) {\n\t\t\tcase \"!==\":\n\t\t\t\treturn constant(leftExpression.value !== rightExpression.value);\n\t\t\tcase \"===\":\n\t\t\t\treturn constant(leftExpression.value === rightExpression.value);\n\t\t\tcase \"<\":\n\t\t\t\tif (\n\t\t\t\t\tleftExpression.value === null ||\n\t\t\t\t\tleftExpression.value === undefined ||\n\t\t\t\t\trightExpression.value === null ||\n\t\t\t\t\trightExpression.value === undefined\n\t\t\t\t) {\n\t\t\t\t\treturn constant(false);\n\t\t\t\t}\n\t\t\t\treturn constant(leftExpression.value < rightExpression.value);\n\t\t\tcase \"<=\":\n\t\t\t\tif (\n\t\t\t\t\tleftExpression.value === null ||\n\t\t\t\t\tleftExpression.value === undefined ||\n\t\t\t\t\trightExpression.value === null ||\n\t\t\t\t\trightExpression.value === undefined\n\t\t\t\t) {\n\t\t\t\t\treturn constant(false);\n\t\t\t\t}\n\t\t\t\treturn constant(leftExpression.value <= rightExpression.value);\n\t\t\tcase \">\":\n\t\t\t\tif (\n\t\t\t\t\tleftExpression.value === null ||\n\t\t\t\t\tleftExpression.value === undefined ||\n\t\t\t\t\trightExpression.value === null ||\n\t\t\t\t\trightExpression.value === undefined\n\t\t\t\t) {\n\t\t\t\t\treturn constant(false);\n\t\t\t\t}\n\t\t\t\treturn constant(leftExpression.value > rightExpression.value);\n\t\t\tcase \">=\":\n\t\t\t\tif (\n\t\t\t\t\tleftExpression.value === null ||\n\t\t\t\t\tleftExpression.value === undefined ||\n\t\t\t\t\trightExpression.value === null ||\n\t\t\t\t\trightExpression.value === undefined\n\t\t\t\t) {\n\t\t\t\t\treturn constant(false);\n\t\t\t\t}\n\t\t\t\treturn constant(leftExpression.value >= rightExpression.value);\n\t\t}\n\t} else {\n\t\treturn {\n\t\t\t_type: \"Comparison\",\n\t\t\toperator: operator,\n\t\t\toperand1: leftExpression,\n\t\t\toperand2: rightExpression\n\t\t};\n\t}\n}\n\n/**\n * Generic helper for the length of an expression.\n *\n * @param expression The input expression pointing to an array\n * @param checkUndefined Is the array potentially undefined\n * @returns An expression representing the length\n */\nexport function length(\n\texpression: PathInModelExpression<unknown> | UnresolvablePathExpression,\n\tcheckUndefined = false\n): Expression<number> {\n\tif (expression._type === \"Unresolvable\") {\n\t\treturn expression;\n\t}\n\tif (!checkUndefined) {\n\t\treturn {\n\t\t\t_type: \"Length\",\n\t\t\tpathInModel: expression\n\t\t};\n\t}\n\treturn ifElse(equal(expression, undefined), -1, length(expression));\n}\n\n/**\n * Comparison: \"equal\" (===).\n *\n * @template T The target type\n * @param leftOperand The operand on the left side\n * @param rightOperand The operand on the right side of the comparison\n * @returns An expression representing the comparison\n */\nexport function equal<T extends PrimitiveType>(\n\tleftOperand: ExpressionOrPrimitive<T>,\n\trightOperand: ExpressionOrPrimitive<T>\n): Expression<boolean> {\n\tconst leftExpression = wrapPrimitive(leftOperand);\n\tconst rightExpression = wrapPrimitive(rightOperand);\n\tif (hasUnresolvableExpression(leftExpression, rightExpression)) {\n\t\treturn unresolvableExpression;\n\t}\n\tif (_checkExpressionsAreEqual(leftExpression, rightExpression)) {\n\t\treturn constant(true);\n\t}\n\n\tfunction reduce(left: Expression<T>, right: Expression<T>): Expression<boolean> | undefined {\n\t\tif (left._type === \"Comparison\" && isTrue(right)) {\n\t\t\t// compare(a, b) === true ~~> compare(a, b)\n\t\t\treturn left;\n\t\t} else if (left._type === \"Comparison\" && isFalse(right)) {\n\t\t\t// compare(a, b) === false ~~> !compare(a, b)\n\t\t\treturn not(left);\n\t\t} else if (left._type === \"IfElse\" && _checkExpressionsAreEqual(left.onTrue, right)) {\n\t\t\t// (if (x) { a } else { b }) === a ~~> x || (b === a)\n\t\t\treturn or(left.condition, equal(left.onFalse, right));\n\t\t} else if (left._type === \"IfElse\" && _checkExpressionsAreEqual(left.onFalse, right)) {\n\t\t\t// (if (x) { a } else { b }) === b ~~> !x || (a === b)\n\t\t\treturn or(not(left.condition), equal(left.onTrue, right));\n\t\t} else if (\n\t\t\tleft._type === \"IfElse\" &&\n\t\t\tisConstant(left.onTrue) &&\n\t\t\tisConstant(left.onFalse) &&\n\t\t\tisConstant(right) &&\n\t\t\t!_checkExpressionsAreEqual(left.onTrue, right) &&\n\t\t\t!_checkExpressionsAreEqual(left.onFalse, right)\n\t\t) {\n\t\t\treturn constant(false);\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t// exploit symmetry: a === b <~> b === a\n\tconst reduced = reduce(leftExpression, rightExpression) ?? reduce(rightExpression, leftExpression);\n\treturn reduced ?? comparison(\"===\", leftExpression, rightExpression);\n}\n\n/**\n * Comparison: \"not equal\" (!==).\n *\n * @template T The target type\n * @param leftOperand The operand on the left side\n * @param rightOperand The operand on the right side of the comparison\n * @returns An expression representing the comparison\n */\nexport function notEqual<T extends PrimitiveType>(\n\tleftOperand: ExpressionOrPrimitive<T>,\n\trightOperand: ExpressionOrPrimitive<T>\n): Expression<boolean> {\n\treturn not(equal(leftOperand, rightOperand));\n}\n\n/**\n * Comparison: \"greater or equal\" (>=).\n *\n * @template T The target type\n * @param leftOperand The operand on the left side\n * @param rightOperand The operand on the right side of the comparison\n * @returns An expression representing the comparison\n */\nexport function greaterOrEqual<T extends DefinedPrimitiveType>(\n\tleftOperand: ExpressionOrPrimitive<T>,\n\trightOperand: ExpressionOrPrimitive<T>\n): Expression<boolean> {\n\treturn comparison(\">=\", leftOperand, rightOperand);\n}\n\n/**\n * Comparison: \"greater than\" (>).\n *\n * @template T The target type\n * @param leftOperand The operand on the left side\n * @param rightOperand The operand on the right side of the comparison\n * @returns An expression representing the comparison\n */\nexport function greaterThan<T extends DefinedPrimitiveType>(\n\tleftOperand: ExpressionOrPrimitive<T>,\n\trightOperand: ExpressionOrPrimitive<T>\n): Expression<boolean> {\n\treturn comparison(\">\", leftOperand, rightOperand);\n}\n\n/**\n * Comparison: \"less or equal\" (<=).\n *\n * @template T The target type\n * @param leftOperand The operand on the left side\n * @param rightOperand The operand on the right side of the comparison\n * @returns An expression representing the comparison\n */\nexport function lessOrEqual<T extends DefinedPrimitiveType>(\n\tleftOperand: ExpressionOrPrimitive<T>,\n\trightOperand: ExpressionOrPrimitive<T>\n): Expression<boolean> {\n\treturn comparison(\"<=\", leftOperand, rightOperand);\n}\n\n/**\n * Comparison: \"less than\" (<).\n *\n * @template T The target type\n * @param leftOperand The operand on the left side\n * @param rightOperand The operand on the right side of the comparison\n * @returns An expression representing the comparison\n */\nexport function lessThan<T extends DefinedPrimitiveType>(\n\tleftOperand: ExpressionOrPrimitive<T>,\n\trightOperand: ExpressionOrPrimitive<T>\n): Expression<boolean> {\n\treturn comparison(\"<\", leftOperand, rightOperand);\n}\n\n/**\n * If-then-else expression.\n *\n * Evaluates to onTrue if the condition evaluates to true, else evaluates to onFalse.\n *\n * @template T The target type\n * @param condition The condition to evaluate\n * @param onTrue Expression result if the condition evaluates to true\n * @param onFalse Expression result if the condition evaluates to false\n * @returns The expression that represents this conditional check\n */\nexport function ifElse<T extends PrimitiveType>(\n\tcondition: ExpressionOrPrimitive<boolean>,\n\tonTrue: ExpressionOrPrimitive<T>,\n\tonFalse: ExpressionOrPrimitive<T>\n): Expression<T> {\n\tlet conditionExpression = wrapPrimitive(condition);\n\tlet onTrueExpression = wrapPrimitive(onTrue);\n\tlet onFalseExpression = wrapPrimitive(onFalse);\n\n\t// swap branches if the condition is a negation\n\tif (conditionExpression._type === \"Not\") {\n\t\t// ifElse(not(X), a, b) --> ifElse(X, b, a)\n\t\t[onTrueExpression, onFalseExpression] = [onFalseExpression, onTrueExpression];\n\t\tconditionExpression = not(conditionExpression);\n\t}\n\n\t// inline nested if-else expressions: onTrue branch\n\t// ifElse(X, ifElse(X, a, b), c) ==> ifElse(X, a, c)\n\tif (onTrueExpression._type === \"IfElse\" && _checkExpressionsAreEqual(conditionExpression, onTrueExpression.condition)) {\n\t\tonTrueExpression = onTrueExpression.onTrue;\n\t}\n\n\t// inline nested if-else expressions: onFalse branch\n\t// ifElse(X, a, ifElse(X, b, c)) ==> ifElse(X, a, c)\n\tif (onFalseExpression._type === \"IfElse\" && _checkExpressionsAreEqual(conditionExpression, onFalseExpression.condition)) {\n\t\tonFalseExpression = onFalseExpression.onFalse;\n\t}\n\n\t// (if true then a else b)  ~~> a\n\t// (if false then a else b) ~~> b\n\tif (isConstant(conditionExpression)) {\n\t\treturn conditionExpression.value ? onTrueExpression : onFalseExpression;\n\t}\n\n\t// if (isConstantBoolean(onTrueExpression) || isConstantBoolean(onFalseExpression)) {\n\t// \treturn or(and(condition, onTrueExpression as Expression<boolean>), and(not(condition), onFalseExpression as Expression<boolean>)) as Expression<T>\n\t// }\n\n\t// (if X then a else a) ~~> a\n\tif (_checkExpressionsAreEqual(onTrueExpression, onFalseExpression)) {\n\t\treturn onTrueExpression;\n\t}\n\n\t// if X then a else false ~~> X && a\n\tif (isFalse(onFalseExpression)) {\n\t\treturn and(conditionExpression, onTrueExpression as Expression<boolean>) as Expression<T>;\n\t}\n\n\t// if X then a else true ~~> !X || a\n\tif (isTrue(onFalseExpression)) {\n\t\treturn or(not(conditionExpression), onTrueExpression as Expression<boolean>) as Expression<T>;\n\t}\n\n\t// if X then false else a ~~> !X && a\n\tif (isFalse(onTrueExpression)) {\n\t\treturn and(not(conditionExpression), onFalseExpression as Expression<boolean>) as Expression<T>;\n\t}\n\n\t// if X then true else a ~~> X || a\n\tif (isTrue(onTrueExpression)) {\n\t\treturn or(conditionExpression, onFalseExpression as Expression<boolean>) as Expression<T>;\n\t}\n\tif (hasUnresolvableExpression(conditionExpression, onTrueExpression, onFalseExpression)) {\n\t\treturn unresolvableExpression;\n\t}\n\tif (isComplexTypeExpression(condition) || isComplexTypeExpression(onTrue) || isComplexTypeExpression(onFalse)) {\n\t\tlet pathIdx = 0;\n\t\tconst myIfElseExpression = formatResult([condition, onTrue, onFalse], \"sap.fe.core.formatters.StandardFormatter#ifElse\");\n\t\tconst allParts = [];\n\t\ttransformRecursively(\n\t\t\tmyIfElseExpression as Expression<PrimitiveType>,\n\t\t\t\"PathInModel\",\n\t\t\t(constantPath: PathInModelExpression<unknown>) => {\n\t\t\t\tallParts.push(constantPath);\n\t\t\t\treturn pathInModel(`$${pathIdx++}`, \"$\");\n\t\t\t},\n\t\t\ttrue\n\t\t);\n\t\tallParts.unshift(constant(JSON.stringify(myIfElseExpression)));\n\t\treturn formatResult(allParts, \"sap.fe.core.formatters.StandardFormatter#evaluateComplexExpression\", undefined, true);\n\t}\n\treturn {\n\t\t_type: \"IfElse\",\n\t\tcondition: conditionExpression,\n\t\tonTrue: onTrueExpression,\n\t\tonFalse: onFalseExpression\n\t};\n}\n\n/**\n * Checks whether the current expression has a reference to the default model (undefined).\n *\n * @param expression The expression to evaluate\n * @returns `true` if there is a reference to the default context\n */\nfunction hasReferenceToDefaultContext(expression: Expression<unknown>): boolean {\n\tswitch (expression._type) {\n\t\tcase \"Constant\":\n\t\tcase \"Formatter\":\n\t\tcase \"ComplexType\":\n\t\t\treturn false;\n\t\tcase \"Set\":\n\t\t\treturn expression.operands.some(hasReferenceToDefaultContext);\n\t\tcase \"PathInModel\":\n\t\t\treturn expression.modelName === undefined;\n\t\tcase \"Comparison\":\n\t\t\treturn hasReferenceToDefaultContext(expression.operand1) || hasReferenceToDefaultContext(expression.operand2);\n\t\tcase \"IfElse\":\n\t\t\treturn (\n\t\t\t\thasReferenceToDefaultContext(expression.condition) ||\n\t\t\t\thasReferenceToDefaultContext(expression.onTrue) ||\n\t\t\t\thasReferenceToDefaultContext(expression.onFalse)\n\t\t\t);\n\t\tcase \"Not\":\n\t\tcase \"Truthy\":\n\t\t\treturn hasReferenceToDefaultContext(expression.operand);\n\t\tdefault:\n\t\t\treturn false;\n\t}\n}\n\n// This is one case where any does make sense...\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Fn<T> = ((...params: any) => T | Promise<T>) & {\n\t__functionName: string;\n};\n\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\ntype WrappedTuple<T> = {\n\t[K in keyof T]:\n\t\t| WrappedTuple<T[K]>\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-ignore\n\t\t| ExpressionOrPrimitive<T[K]>\n\t\t| undefined;\n};\n\n// So, this works but I cannot get it to compile :D, but it still does what is expected...\n\n/**\n * A function reference or a function name.\n */\ntype FunctionOrName<T> = Fn<T> | string;\n\n/**\n * Function parameters, either derived from the function or an untyped array.\n */\ntype FunctionParameters<T, F extends FunctionOrName<T>> = F extends Fn<T> ? Parameters<F> : unknown[];\n\n/**\n * Calls a formatter function to process the parameters.\n * If requireContext is set to true and no context is passed a default context will be added automatically.\n *\n * @template T\n * @template U\n * @param parameters The list of parameter that should match the type and number of the formatter function\n * @param formatterFunction The function to call\n * @param [contextEntityType] If no parameter refers to the context then we use this information to add a reference to the keys from the entity type.\n * @param [ignoreComplexType] Whether to ignore the transgformation to the StandardFormatter or not\n * @returns The corresponding expression\n */\nexport function formatResult<T, U extends Fn<T>>(\n\tparameters: WrappedTuple<Parameters<U>>,\n\tformatterFunction: U | string,\n\tcontextEntityType?: EntityType,\n\tignoreComplexType = false\n): Expression<T> {\n\tconst parameterExpressions = (parameters as ExpressionOrPrimitive<PrimitiveType>[]).map(wrapPrimitive);\n\n\tif (hasUnresolvableExpression(...parameterExpressions)) {\n\t\treturn unresolvableExpression;\n\t}\n\tif (contextEntityType) {\n\t\t// Otherwise, if the context is required and no context is provided make sure to add the default binding\n\t\tif (!parameterExpressions.some(hasReferenceToDefaultContext)) {\n\t\t\tcontextEntityType.keys.forEach((key) => parameterExpressions.push(pathInModel(key.name, \"\")));\n\t\t}\n\t}\n\tlet functionName = \"\";\n\tif (typeof formatterFunction === \"string\") {\n\t\tfunctionName = formatterFunction;\n\t} else {\n\t\tfunctionName = formatterFunction.__functionName;\n\t}\n\t// FormatterName can be of format sap.fe.core.xxx#methodName to have multiple formatter in one class\n\tconst [formatterClass, formatterName] = functionName.split(\"#\");\n\n\t// In some case we also cannot call directly a function because of too complex input, in that case we need to convert to a simpler function call\n\tif (\n\t\t!ignoreComplexType &&\n\t\t(parameterExpressions.some(isComplexTypeExpression) ||\n\t\t\tparameterExpressions.some(isConcatExpression) ||\n\t\t\tparameterExpressions.some(isIfElseExpression))\n\t) {\n\t\tlet pathIdx = 0;\n\t\tconst myFormatExpression = formatResult(parameterExpressions, functionName, undefined, true);\n\t\tconst allParts = [];\n\t\ttransformRecursively(\n\t\t\tmyFormatExpression as Expression<PrimitiveType>,\n\t\t\t\"PathInModel\",\n\t\t\t(constantPath: PathInModelExpression<unknown>) => {\n\t\t\t\tallParts.push(constantPath);\n\t\t\t\treturn pathInModel(`$${pathIdx++}`, \"$\");\n\t\t\t},\n\t\t\ttrue\n\t\t);\n\t\tallParts.unshift(constant(JSON.stringify(myFormatExpression)));\n\t\treturn formatResult(allParts, \"sap.fe.core.formatters.StandardFormatter#evaluateComplexExpression\", undefined, true);\n\t} else if (!!formatterName && formatterName.length > 0) {\n\t\tparameterExpressions.unshift(constant(formatterName));\n\t}\n\n\treturn {\n\t\t_type: \"Formatter\",\n\t\tfn: formatterClass!,\n\t\tparameters: parameterExpressions\n\t};\n}\n\nexport const getFiscalType = function (property: Property): string | undefined {\n\tif (property.annotations.Common?.IsFiscalYear) {\n\t\treturn CommonAnnotationTerms.IsFiscalYear;\n\t}\n\tif (property.annotations.Common?.IsFiscalPeriod) {\n\t\treturn CommonAnnotationTerms.IsFiscalPeriod;\n\t}\n\tif (property.annotations.Common?.IsFiscalYearPeriod) {\n\t\treturn CommonAnnotationTerms.IsFiscalYearPeriod;\n\t}\n\tif (property.annotations.Common?.IsFiscalQuarter) {\n\t\treturn CommonAnnotationTerms.IsFiscalQuarter;\n\t}\n\tif (property.annotations.Common?.IsFiscalYearQuarter) {\n\t\treturn CommonAnnotationTerms.IsFiscalYearQuarter;\n\t}\n\tif (property.annotations.Common?.IsFiscalWeek) {\n\t\treturn CommonAnnotationTerms.IsFiscalWeek;\n\t}\n\tif (property.annotations.Common?.IsFiscalYearWeek) {\n\t\treturn CommonAnnotationTerms.IsFiscalYearWeek;\n\t}\n\tif (property.annotations.Common?.IsDayOfFiscalYear) {\n\t\treturn CommonAnnotationTerms.IsDayOfFiscalYear;\n\t}\n};\n\n/**\n * Function call, optionally with arguments.\n *\n * @param func Function name or reference to function\n * @param parameters Arguments\n * @param on Object to call the function on\n * @param isFormattingFn\n * @returns Expression representing the function call (not the result of the function call!)\n */\nexport function fn<T, U extends FunctionOrName<T>>(\n\tfunc: U,\n\tparameters: WrappedTuple<FunctionParameters<T, U>>,\n\ton?: ExpressionOrPrimitive<object>,\n\tisFormattingFn = false\n): FunctionExpression<T> {\n\tconst functionName = typeof func === \"string\" ? func : func.__functionName;\n\treturn {\n\t\t_type: \"Function\",\n\t\tobj: on !== undefined ? wrapPrimitive(on) : undefined,\n\t\tfn: functionName,\n\t\tisFormattingFn: isFormattingFn,\n\t\tparameters: (parameters as ExpressionOrPrimitive<PrimitiveType>[]).map(wrapPrimitive)\n\t};\n}\n\n/**\n * Shortcut function to determine if a binding value is null, undefined or empty.\n *\n * @param expression\n * @returns A Boolean expression evaluating the fact that the current element is empty\n */\nexport function isEmpty(expression: Expression<string>): Expression<boolean> {\n\tconst aBindings: ExpressionOrPrimitive<boolean>[] = [];\n\ttransformRecursively(expression, \"PathInModel\", (expr) => {\n\t\taBindings.push(or(equal(expr, \"\"), equal(expr, undefined), equal(expr, null)));\n\t\treturn expr;\n\t});\n\treturn and(...aBindings);\n}\n\nexport function concat(\n\t//eslint-disable-next-line @typescript-eslint/no-wrapper-object-types\n\t...inExpressions: ExpressionOrPrimitive<string | String>[]\n): Expression<string> {\n\tconst expressions = inExpressions.map(wrapPrimitive);\n\tif (hasUnresolvableExpression(...expressions)) {\n\t\treturn unresolvableExpression;\n\t}\n\tif (expressions.every(isConstant)) {\n\t\treturn constant(\n\t\t\texpressions.reduce((concatenated: string, value) => {\n\t\t\t\tif (value.value !== undefined && value.value !== null) {\n\t\t\t\t\treturn concatenated + value.value.toString();\n\t\t\t\t}\n\t\t\t\treturn concatenated;\n\t\t\t}, \"\")\n\t\t);\n\t} else if (expressions.some(isComplexTypeExpression)) {\n\t\tlet pathIdx = 0;\n\t\tconst myConcatExpression = formatResult(expressions, \"sap.fe.core.formatters.StandardFormatter#concat\", undefined, true);\n\t\tconst allParts = [];\n\t\ttransformRecursively(\n\t\t\tmyConcatExpression as Expression<PrimitiveType>,\n\t\t\t\"PathInModel\",\n\t\t\t(constantPath: PathInModelExpression<unknown>) => {\n\t\t\t\tallParts.push(constantPath);\n\t\t\t\treturn pathInModel(`$${pathIdx++}`, \"$\");\n\t\t\t}\n\t\t);\n\t\tallParts.unshift(constant(JSON.stringify(myConcatExpression)));\n\t\treturn formatResult(allParts, \"sap.fe.core.formatters.StandardFormatter#evaluateComplexExpression\", undefined, true);\n\t}\n\treturn {\n\t\t_type: \"Concat\",\n\t\texpressions: expressions as Expression<string>[]\n\t};\n}\n\ntype ExpressionTypeToExpression<T extends ExpressionType, V> = T extends \"Constant\"\n\t? ConstantExpression<V>\n\t: T extends \"PathInModel\"\n\t\t? PathInModelExpression<V>\n\t\t: T extends \"Function\"\n\t\t\t? FunctionExpression<V>\n\t\t\t: T extends \"Unresolvable\"\n\t\t\t\t? UnresolvablePathExpression\n\t\t\t\t: Expression<V>;\n\nexport type TransformFunction<T, V> = (expressionPart: T) => Expression<V>;\nexport type ExpressionType = Pick<Expression<unknown>, \"_type\">[\"_type\"];\nexport function transformRecursively<T extends PrimitiveType, ET extends ExpressionType>(\n\tinExpression: Expression<T>,\n\texpressionType: ET,\n\ttransformFunction: TransformFunction<ExpressionTypeToExpression<ET, T>, T>,\n\tincludeAllExpression = false\n): Expression<T> {\n\tlet expression: Expression<T> = inExpression;\n\tswitch (expression._type) {\n\t\tcase \"Function\":\n\t\tcase \"Formatter\":\n\t\t\texpression.parameters = expression.parameters.map((parameter) =>\n\t\t\t\ttransformRecursively(parameter as Expression<T>, expressionType, transformFunction, includeAllExpression)\n\t\t\t);\n\t\t\tbreak;\n\t\tcase \"Concat\":\n\t\t\texpression.expressions = expression.expressions.map((subExpression) =>\n\t\t\t\ttransformRecursively(\n\t\t\t\t\tsubExpression,\n\t\t\t\t\texpressionType,\n\t\t\t\t\ttransformFunction as unknown as TransformFunction<ExpressionTypeToExpression<ET, string>, string>,\n\t\t\t\t\tincludeAllExpression\n\t\t\t\t)\n\t\t\t);\n\t\t\texpression = concat(...expression.expressions) as Expression<T>;\n\t\t\tbreak;\n\t\tcase \"ComplexType\":\n\t\t\texpression.bindingParameters = expression.bindingParameters.map((bindingParameter) =>\n\t\t\t\ttransformRecursively(bindingParameter as Expression<T>, expressionType, transformFunction, includeAllExpression)\n\t\t\t);\n\t\t\tbreak;\n\t\tcase \"IfElse\": {\n\t\t\tconst onTrue = transformRecursively(expression.onTrue, expressionType, transformFunction, includeAllExpression);\n\t\t\tconst onFalse = transformRecursively(expression.onFalse, expressionType, transformFunction, includeAllExpression);\n\t\t\tlet condition = expression.condition;\n\t\t\tif (includeAllExpression) {\n\t\t\t\tcondition = transformRecursively(\n\t\t\t\t\texpression.condition,\n\t\t\t\t\texpressionType,\n\t\t\t\t\ttransformFunction as unknown as TransformFunction<ExpressionTypeToExpression<ET, boolean>, boolean>,\n\t\t\t\t\tincludeAllExpression\n\t\t\t\t);\n\t\t\t}\n\t\t\texpression = ifElse(condition, onTrue, onFalse);\n\t\t\tbreak;\n\t\t}\n\t\tcase \"Not\":\n\t\t\tif (includeAllExpression) {\n\t\t\t\tconst operand = transformRecursively(\n\t\t\t\t\texpression.operand,\n\t\t\t\t\texpressionType,\n\t\t\t\t\ttransformFunction as unknown as TransformFunction<ExpressionTypeToExpression<ET, boolean>, boolean>,\n\t\t\t\t\tincludeAllExpression\n\t\t\t\t);\n\t\t\t\texpression = not(operand) as Expression<T>;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase \"Truthy\":\n\t\t\tbreak;\n\t\tcase \"Set\":\n\t\t\tif (includeAllExpression) {\n\t\t\t\tconst operands = expression.operands.map((operand) =>\n\t\t\t\t\ttransformRecursively(\n\t\t\t\t\t\toperand,\n\t\t\t\t\t\texpressionType,\n\t\t\t\t\t\ttransformFunction as unknown as TransformFunction<ExpressionTypeToExpression<ET, boolean>, boolean>,\n\t\t\t\t\t\tincludeAllExpression\n\t\t\t\t\t)\n\t\t\t\t);\n\t\t\t\texpression = expression.operator === \"||\" ? (or(...operands) as Expression<T>) : (and(...operands) as Expression<T>);\n\t\t\t}\n\t\t\tbreak;\n\t\tcase \"Comparison\":\n\t\t\tif (includeAllExpression) {\n\t\t\t\tconst operand1 = transformRecursively(\n\t\t\t\t\texpression.operand1 as Expression<T>,\n\t\t\t\t\texpressionType,\n\t\t\t\t\ttransformFunction,\n\t\t\t\t\tincludeAllExpression\n\t\t\t\t);\n\t\t\t\tconst operand2 = transformRecursively(\n\t\t\t\t\texpression.operand2 as Expression<T>,\n\t\t\t\t\texpressionType,\n\t\t\t\t\ttransformFunction,\n\t\t\t\t\tincludeAllExpression\n\t\t\t\t);\n\t\t\t\texpression = comparison(expression.operator, operand1, operand2) as Expression<T>;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase \"Constant\": {\n\t\t\tconst constantValue: Record<string, Expression<unknown>> = expression.value as Record<string, Expression<unknown>>;\n\t\t\tif (typeof constantValue === \"object\" && constantValue) {\n\t\t\t\tObject.keys(constantValue).forEach((key) => {\n\t\t\t\t\tconstantValue[key] = transformRecursively(\n\t\t\t\t\t\tconstantValue[key] as ConstantExpression<T>,\n\t\t\t\t\t\texpressionType,\n\t\t\t\t\t\ttransformFunction,\n\t\t\t\t\t\tincludeAllExpression\n\t\t\t\t\t);\n\t\t\t\t});\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\tcase \"Ref\":\n\t\tcase \"Length\":\n\t\tcase \"PathInModel\":\n\t\tcase \"EmbeddedBinding\":\n\t\tcase \"EmbeddedExpressionBinding\":\n\t\tcase \"Unresolvable\":\n\t\t\t// Do nothing\n\t\t\tbreak;\n\t}\n\tif (expressionType === expression._type) {\n\t\texpression = transformFunction(inExpression as ExpressionTypeToExpression<ET, T>);\n\t}\n\treturn expression;\n}\n","import type {\n\tAnnotationTerm,\n\tComplexType,\n\tEntityContainer,\n\tEntitySet,\n\tEntityType,\n\tMultipleNavigationProperty,\n\tNavigationProperty,\n\tPathAnnotationExpression,\n\tProperty,\n\tPropertyPath,\n\tServiceObject,\n\tSingleNavigationProperty,\n\tSingleton,\n\tTypeDefinition\n} from \"@sap-ux/vocabularies-types\";\nimport type { AnnotationPath } from \"@sap-ux/vocabularies-types/Edm\";\n\ntype AnnotationType = {\n\t$Type?: string;\n\tfullyQualifiedName?: string;\n};\nexport type _AnnotationTerm = {\n\tterm: string;\n\tqualifier?: string;\n};\n\n/**\n * Checks whether the argument is an annotation of the given type.\n * @param potentialAnnotationType The annotation to check\n * @param typeName The type to check for\n * @returns Whether the argument is an annotation of the given type\n */\nexport function isAnnotationOfType<T extends object & AnnotationType>(\n\tpotentialAnnotationType: unknown,\n\ttypeName: T[\"$Type\"] | T[\"$Type\"][]\n): potentialAnnotationType is T {\n\tif (Array.isArray(typeName)) {\n\t\treturn typeName.includes((potentialAnnotationType as AnnotationType).$Type);\n\t}\n\treturn (potentialAnnotationType as AnnotationType).$Type === typeName;\n}\n\n/**\n * Checks whether the argument is an annotation of the given term.\n * @param potentialAnnotation The annotation to check\n * @param termName The term to check for\n * @returns Whether the argument is an annotation of the given term\n */\nexport function isAnnotationOfTerm<T extends object & _AnnotationTerm>(\n\tpotentialAnnotation: unknown,\n\ttermName: T[\"term\"]\n): potentialAnnotation is AnnotationTerm<T> {\n\treturn (potentialAnnotation as _AnnotationTerm).term === termName;\n}\n\nexport function isAnnotationTerm(potentialAnnotation: unknown): potentialAnnotation is _AnnotationTerm {\n\treturn (potentialAnnotation as _AnnotationTerm).hasOwnProperty(\"term\");\n}\n\n/**\n * Checks whether the argument is a {@link ServiceObject}.\n *\n * @param serviceObject The object to be checked.\n * @returns Whether the argument is a {@link ServiceObject}.\n */\nexport function isServiceObject(serviceObject: unknown): serviceObject is ServiceObject {\n\treturn serviceObject?.hasOwnProperty(\"_type\") ?? false;\n}\n\n/**\n * Checks whether the argument is a {@link ComplexType}.\n *\n * @param serviceObject The object to be checked.\n * @returns Whether the argument is a {@link ComplexType}.\n */\nexport function isComplexType(serviceObject: unknown): serviceObject is ComplexType {\n\treturn (serviceObject as { _type: string })._type === \"ComplexType\";\n}\n\n/**\n * Checks whether the argument is a {@link TypeDefinition}.\n *\n * @param serviceObject The object to be checked.\n * @returns Whether the argument is a {@link TypeDefinition}.\n */\nexport function isTypeDefinition(serviceObject: unknown): serviceObject is TypeDefinition {\n\treturn (serviceObject as { _type: string })._type === \"TypeDefinition\";\n}\n\n/**\n * Checks whether the argument is an {@link EntityContainer}.\n *\n * @param serviceObject The object to be checked.\n * @returns Whether the argument is an {@link EntityContainer}.\n */\nexport function isEntityContainer(serviceObject: unknown): serviceObject is EntityContainer {\n\treturn (serviceObject as { _type: string })._type === \"EntityContainer\";\n}\n\n/**\n * Checks whether the argument is an {@link EntitySet}.\n *\n * @param serviceObject The object to be checked.\n * @returns Whether the argument is an {@link EntitySet}.\n */\nexport function isEntitySet(serviceObject: unknown): serviceObject is EntitySet {\n\treturn (serviceObject as { _type: string })._type === \"EntitySet\";\n}\n\n/**\n * Checks whether the argument is a {@link Singleton}.\n *\n * @param serviceObject The object to be checked.\n * @returns Whether the argument is a {@link Singleton}\n */\nexport function isSingleton(serviceObject: unknown): serviceObject is Singleton {\n\treturn (serviceObject as { _type: string })._type === \"Singleton\";\n}\n\n/**\n * Checks whether the argument is an {@link EntityType}.\n *\n * @param serviceObject The object to be checked.\n * @returns Whether the argument is an {@link EntityType}\n */\nexport function isEntityType(serviceObject: unknown): serviceObject is EntityType {\n\treturn (serviceObject as { _type: string })._type === \"EntityType\";\n}\n\n/**\n * Checks whether the argument is a {@link Property}.\n *\n * @param serviceObject The object to be checked.\n * @returns Whether the argument is a {@link Property}.\n */\nexport function isProperty(serviceObject: unknown): serviceObject is Property {\n\treturn (serviceObject as { _type: string })._type === \"Property\";\n}\n\n/**\n * Checks whether the argument is a {@link NavigationProperty}.\n *\n * Hint: There are also the more specific functions {@link isSingleNavigationProperty} and {@link isMultipleNavigationProperty}. These can be\n * used to check for to-one and to-many navigation properties, respectively.\n *\n * @param serviceObject The object to be checked.\n * @returns Whether the argument is a {@link NavigationProperty}.\n */\nexport function isNavigationProperty(serviceObject: unknown): serviceObject is NavigationProperty {\n\treturn (serviceObject as { _type: string })._type === \"NavigationProperty\";\n}\n\n/**\n * Checks whether the argument is a {@link SingleNavigationProperty}.\n *\n * @param serviceObject The object to be checked.\n * @returns Whether the argument is a {@link SingleNavigationProperty}.\n */\nexport function isSingleNavigationProperty(serviceObject: unknown): serviceObject is SingleNavigationProperty {\n\treturn isNavigationProperty(serviceObject) && !serviceObject.isCollection;\n}\n\n/**\n * Checks whether the argument is a {@link MultipleNavigationProperty}.\n *\n * @param serviceObject The object to be checked.\n * @returns Whether the argument is a {@link MultipleNavigationProperty}.\n */\nexport function isMultipleNavigationProperty(serviceObject: unknown): serviceObject is MultipleNavigationProperty {\n\treturn isNavigationProperty(serviceObject) && serviceObject.isCollection;\n}\n\n/**\n * Checks whether the argument is a {@link PathAnnotationExpression}.\n *\n * @param expression The object to be checked.\n * @returns Whether the argument is a {@link PathAnnotationExpression}.\n */\nexport function isPathAnnotationExpression<T>(expression: unknown): expression is PathAnnotationExpression<T> {\n\treturn (expression as { type: string }).type === \"Path\";\n}\n\n/**\n * Checks whether the argument is a {@link AnnotationPathExpression}.\n *\n * @param expression The object to be checked.\n * @returns Whether the argument is a {@link AnnotationPathExpression}.\n */\nexport function isAnnotationPath<T>(expression: unknown): expression is AnnotationPath<T> {\n\treturn (expression as { type: string }).type == \"AnnotationPath\";\n}\n\n/**\n * Checks whether the argument is a {@link PropertyPath}.\n *\n * @param expression The object to be checked.\n * @returns Whether the argument is a {@link PropertyPath}.\n */\nexport function isPropertyPathExpression(expression: unknown): expression is PropertyPath {\n\treturn (expression as { type: string }).type === \"PropertyPath\";\n}\nexport type ValidPropertyPath = PropertyPath & { $target: Property };\n\n/**\n * Checks whether the argument is a {@link PropertyPath}.\n *\n * @param expression The object to be checked.\n * @returns Whether the argument is a {@link PropertyPath}.\n */\nexport function isValidPropertyPathExpression(expression: unknown): expression is ValidPropertyPath {\n\treturn (expression as { type: string }).type === \"PropertyPath\" && !!(expression as { $target: Property }).$target;\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","","// startup\n// Load entry module and return exports\n// This entry module is referenced by other modules so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(829);\n",""]}