@sapui5/sap.cux.home 1.135.0 → 1.136.0

package/src/sap/cux/home/utils/RecommendedCardUtil-dbg.js

@@ -0,0 +1,1599 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *  * (c) Copyright 2009-2025 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/i18n/Formatting", "sap/base/Log", "sap/base/security/encodeURL", "sap/base/strings/formatMessage", "sap/base/util/deepExtend", "sap/ui/base/Object", "sap/ui/core/library", "../interface/CardsInterface", "./Constants", "./DataFormatUtils"], function (Formatting, Log, encodeURL, formatMessage, deepExtend, BaseObject, CoreLib, ___interface_CardsInterface, ___Constants, ___DataFormatUtils) {
+  "use strict";
+
+  const UIAnnotations = ___interface_CardsInterface["UIAnnotations"];
+  const TABLE_TYPES = ___Constants["TABLE_TYPES"];
+  const sortCollectionByImportance = ___DataFormatUtils["sortCollectionByImportance"];
+  const COLUMN_LENGTH = 3;
+  const ValueState = CoreLib.ValueState;
+  var FieldAnnotationsType = /*#__PURE__*/function (FieldAnnotationsType) {
+    FieldAnnotationsType["DataField"] = "com.sap.vocabularies.UI.v1.DataField";
+    FieldAnnotationsType["Importance"] = "com.sap.vocabularies.UI.v1.Importance";
+    FieldAnnotationsType["DataFieldWithNavigationPath"] = "com.sap.vocabularies.UI.v1.DataFieldWithNavigationPath";
+    FieldAnnotationsType["DataFieldWithIntentBasedNavigation"] = "com.sap.vocabularies.UI.v1.DataFieldWithIntentBasedNavigation";
+    FieldAnnotationsType["DataFieldForIntentBasedNavigation"] = "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation";
+    FieldAnnotationsType["Chart"] = "@com.sap.vocabularies.UI.v1.Chart";
+    FieldAnnotationsType["FieldGroup"] = "@com.sap.vocabularies.UI.v1.FieldGroup";
+    FieldAnnotationsType["DataPoint"] = "@com.sap.vocabularies.UI.v1.DataPoint";
+    FieldAnnotationsType["Contact"] = "@com.sap.vocabularies.Communication.v1.Contact";
+    FieldAnnotationsType["DataFieldForAction"] = "com.sap.vocabularies.UI.v1.DataFieldForAction";
+    FieldAnnotationsType["DataFieldForAnnotation"] = "com.sap.vocabularies.UI.v1.DataFieldForAnnotation";
+    FieldAnnotationsType["DataFieldWithUrl"] = "com.sap.vocabularies.UI.v1.DataFieldWithUrl";
+    FieldAnnotationsType["CriticalityRepresentationTypeWithoutIcon"] = "com.sap.vocabularies.UI.v1.CriticalityRepresentationType/WithoutIcon";
+    FieldAnnotationsType["FieldControlHiddenType"] = "com.sap.vocabularies.Common.v1.FieldControlType/Hidden";
+    return FieldAnnotationsType;
+  }(FieldAnnotationsType || {});
+  var FieldTypes = /*#__PURE__*/function (FieldTypes) {
+    FieldTypes["DataFieldWithNavigationPath"] = "DataFieldWithNavigationPath";
+    FieldTypes["DataFieldWithIntentBasedNavigation"] = "DataFieldWithIntentBasedNavigation";
+    FieldTypes["DataFieldForIntentBasedNavigation"] = "DataFieldForIntentBasedNavigation";
+    FieldTypes["DataFieldForAction"] = "DataFieldForAction";
+    FieldTypes["DataFieldForAnnotation"] = "DataFieldForAnnotation";
+    return FieldTypes;
+  }(FieldTypes || {});
+  class RecommendedCardUtil extends BaseObject {
+    static getInstance() {
+      if (!RecommendedCardUtil.Instance) {
+        RecommendedCardUtil.Instance = new RecommendedCardUtil();
+      }
+      return RecommendedCardUtil.Instance;
+    }
+
+    /**
+     * @param {object} metaModel - metamodel object
+     * @param {object} originalManifest - manifest of original app
+     * @param {string} leadingEntitySet - main entitySet of the application as in manifest
+     * @returns {object} - returns the lineItem details for the application based on manifest, annotations and metadata
+     * @private
+     */
+    getLineItemDetails(metaModel, originalManifest, leadingEntitySet) {
+      const leadingEntitySetDetails = metaModel.getODataEntitySet(leadingEntitySet);
+      const variantInfo = this.getLineItemFromVariant(metaModel, leadingEntitySetDetails.entityType);
+      const lineItemDefault = variantInfo.lineItem;
+      const pages = originalManifest["sap.ui.generic.app"]?.pages;
+      const lrSettings = this.getSettingsForPage(pages);
+
+      //if there is no quickVariantSelectionX setting in manifest, then return default line item details
+      if (!lrSettings.quickVariantSelectionX) {
+        return this.createDefaultLineItemDetails(metaModel, variantInfo, lrSettings, leadingEntitySet, lineItemDefault);
+      }
+
+      // if there is a variant settings then find the first non-smart chart variant
+      const oVariants = lrSettings.quickVariantSelectionX.variants || {};
+      const {
+        firstAvailableKey,
+        sEntitySet,
+        oVariant
+      } = this.findFirstNonSmartChartVariant(metaModel, oVariants, leadingEntitySet);
+      if (oVariant.isSmartChart) {
+        return this.createDefaultLineItemDetails(metaModel, variantInfo, lrSettings, leadingEntitySet, lineItemDefault);
+      }
+      delete lrSettings.requestAtLeastFields;
+      const defaultTableSettings = this.getNormalizedTableSettings(metaModel, lrSettings, leadingEntitySet);
+      const entitySet = metaModel?.getODataEntitySet(sEntitySet);
+      const quickVariantInfo = this.getLineItemFromVariant(metaModel, entitySet.entityType, oVariant.annotationPath?.split("#")[1]);
+      const lineItem = quickVariantInfo.lineItem;
+      const presentationVariant = quickVariantInfo.presentationVariant;
+      lrSettings.requestAtLeastFields = presentationVariant?.RequestAtLeast?.length ? presentationVariant.RequestAtLeast : this._getRequestAtLeastFields(presentationVariant);
+      oVariant.tableSettings = this.getNormalizedTableSettings(metaModel, {
+        ...oVariant,
+        tableSettings: oVariant.tableSettings || defaultTableSettings
+      }, sEntitySet);
+      this.validateResponsiveTable(lrSettings, oVariant, firstAvailableKey);
+      delete lrSettings.tableSettings;
+      lrSettings.isResponsiveTable = lrSettings.isResponsiveTable === undefined || lrSettings.isResponsiveTable;
+      const lineItemDetail = {
+        quickVariant: oVariant,
+        lrSettings: lrSettings,
+        lineItem: lineItem,
+        entitySet: sEntitySet,
+        headerInfo: oVariant?.tableSettings?.headerInfo || ""
+      };
+      return lineItem ? lineItemDetail : this.createDefaultLineItemDetails(metaModel, variantInfo, lrSettings, leadingEntitySet, lineItemDefault);
+    }
+
+    /**
+     * Finds the first non-smart chart variant from the provided variants.
+     *
+     * This method iterates through the given variants to identify the first variant that is not a smart chart.
+     * It also determines the associated entity set and updates the variant's metadata to indicate whether it is a smart chart.
+     *
+     * @param {ODataMetaModel} metaModel - The OData meta model containing metadata about entities and annotations.
+     * @param {Record<string, IVariantSetting>} oVariants - A record of variants, where each key represents a variant and its associated metadata.
+     * @param {string} leadingEntitySet - The name of the leading entity set for the application.
+     * @returns {NonChartDetail}
+    }
+     * An object containing:
+     * - `firstAvailableKey`: The key of the first non-smart chart variant, or `null` if none is found.
+     * - `sEntitySet`: The entity set associated with the first non-smart chart variant.
+     * - `oVariant`: The metadata of the first non-smart chart variant.
+     * @private
+     */
+    findFirstNonSmartChartVariant(metaModel, oVariants, leadingEntitySet) {
+      let firstAvailableKey = null;
+      let sEntitySet = leadingEntitySet;
+      let oVariant = {};
+      for (const sKey in oVariants) {
+        if (!Object.prototype.hasOwnProperty.call(oVariants, sKey)) continue;
+        oVariant = oVariants[sKey];
+        sEntitySet = oVariant.entitySet || leadingEntitySet;
+        const oEntitySet = metaModel.getODataEntitySet(sEntitySet);
+        if (oEntitySet) {
+          oVariant.isSmartChart = this.checkIfSmartChart(metaModel, sEntitySet, oVariant);
+          if (!oVariant.isSmartChart) {
+            firstAvailableKey = sKey;
+            break;
+          }
+        } else {
+          oVariant.isSmartChart = true;
+        }
+      }
+      return {
+        firstAvailableKey,
+        sEntitySet,
+        oVariant
+      };
+    }
+
+    /**
+     * Validates the responsive table type for a given variant and updates the List Report (LR) settings.
+     *
+     * @param {ILrSettings} lrSettings - The settings object for the List Report, including table settings and configurations.
+     * @param {IVariantSetting} oVariant - The variant object containing table settings and metadata.
+     * @param {string | null} firstAvailableKey - The key of the first available variant, used for logging errors.
+     * @returns {void}
+     * @private
+     */
+    validateResponsiveTable(lrSettings, oVariant, firstAvailableKey) {
+      const isResponsive = oVariant.tableSettings?.type === TABLE_TYPES.RESPONSIVE;
+      if (lrSettings.isResponsiveTable === undefined) {
+        lrSettings.isResponsiveTable = isResponsive;
+      } else if (lrSettings.isResponsiveTable !== isResponsive) {
+        Log.error(`Variant with key ${firstAvailableKey} resulted in invalid Table Type combination.`);
+      }
+    }
+
+    /**
+     *
+     * This method generates the default configuration for line item details, including table settings,
+     * responsive table type, and request-at-least fields based on the provided metadata, variant information,
+     * and settings.
+     *
+     * @param {ODataMetaModel} metaModel - The OData meta model containing metadata about entities and annotations.
+     * @param {VariantInfo} variantInfo - The variant information containing presentation variant and line item details.
+     * @param {ILrSettings} lrSettings - The settings object for the List Report, including table settings and other configurations.
+     * @param {string} leadingEntitySet - The name of the leading entity set for the application.
+     * @param {ILineItem[] | string | undefined} lineItemDefault - The default line item details, which can be an array of line items, a string, or undefined.
+     * @returns {ILineItemDetails} The default line item details object, including quick variant, settings, line item, entity set, and header info.
+     * @private
+     */
+    createDefaultLineItemDetails(metaModel, variantInfo, lrSettings, leadingEntitySet, lineItemDefault) {
+      lrSettings.tableSettings = this.getNormalizedTableSettings(metaModel, lrSettings, leadingEntitySet);
+      lrSettings.isResponsiveTable = lrSettings.tableSettings.type === TABLE_TYPES.RESPONSIVE;
+      if (variantInfo?.presentationVariant?.RequestAtLeast?.length) {
+        lrSettings.requestAtLeastFields = variantInfo.presentationVariant.RequestAtLeast;
+      }
+      return {
+        quickVariant: {},
+        lrSettings: lrSettings,
+        lineItem: lineItemDefault,
+        entitySet: leadingEntitySet,
+        headerInfo: lrSettings?.tableSettings?.headerInfo || ""
+      };
+    }
+
+    /**
+     * @param {object} oMetaModel - metamodel object
+     * @param {string} entityType - entity type of the application
+     * @param {string} qualifier - qualifier of the variant
+     * @returns {object} - returns the lineItem, presentationVariant, qualifierPath from the variant for the application based on manifest, annotations and metadata
+     * @private
+     */
+    getLineItemFromVariant(oMetaModel, entityType, qualifier) {
+      const oSelectionPresentationVariant = this.getAnnotation(oMetaModel, entityType, UIAnnotations.UISelectionPresentationVariant, qualifier);
+      let oPresentationVariant;
+      if (oSelectionPresentationVariant?.PresentationVariant) {
+        oPresentationVariant = this.getPresentationVariant(oMetaModel, entityType, oSelectionPresentationVariant.PresentationVariant);
+      } else {
+        oPresentationVariant = this.getAnnotation(oMetaModel, entityType, UIAnnotations.UIPresentationVariant, qualifier);
+      }
+      const oDetails = oPresentationVariant ? this.getLineItem(oMetaModel, entityType, oPresentationVariant) : null;
+      const lineItem = oDetails?.lineItem || this.getAnnotation(oMetaModel, entityType, UIAnnotations.UILineItem, "");
+      return {
+        presentationVariant: oPresentationVariant,
+        lineItem: lineItem,
+        qualifierPath: oDetails?.annotationPath || ""
+      };
+    }
+
+    // get the annotation , sAnnotation from the entityType, sEntityType
+    getAnnotation(metaModel, entityType, annotation, qualifierName) {
+      const fullAnnotation = `${annotation}${qualifierName ? `#${qualifierName}` : ""}`;
+      const entityTypeData = metaModel.getODataEntityType(entityType);
+      return entityTypeData?.[fullAnnotation];
+    }
+
+    /**
+     * This method determines the presentation variant based on the provided selection presentation variant.
+     * If the presentation variant is defined via a `Path`, it resolves the path to retrieve the corresponding object
+     * from the OData meta model. If the presentation variant is defined inline (i.e., without a `Path`), it directly
+     * returns the inline object.
+     *
+     * @param {ODataMetaModel} metaModel - The OData meta model containing metadata about entities and annotations.
+     * @param {string} entityTypeData - The entity type for which the presentation variant is to be retrieved.
+     * @param {IPresentationVariant} selectionPresentationVariant -
+     * The selection presentation variant object, which may contain a `Path` or an inline `PresentationVariant`.
+     * @returns {IPresentationVariant} The resolved presentation variant object.
+     * @private
+     */
+    getPresentationVariant(metaModel, entityTypeData, selectionPresentationVariant) {
+      // PresentationVariant must be defined (according to vocabulary) either via "Path" or inline (i.e. Path is not defined).
+      // For compatibility, just ignore if not provided (leading to fallback to use LineItem without qualifier)
+      const presentationVariant = selectionPresentationVariant?.PresentationVariant;
+      if (presentationVariant?.Path) {
+        return this.getObject(metaModel, entityTypeData, presentationVariant.Path);
+      }
+      return presentationVariant;
+    }
+
+    /**
+     * Retrieves the line item annotation details for a given entity type and presentation variant.
+     *
+     * This method searches for the `com.sap.vocabularies.UI.v1.LineItem` annotation within the visualizations
+     * of the provided presentation variant. If found, it returns the line item details, including the annotation path
+     * and qualifier.
+     *
+     * @param {ODataMetaModel} metaModel - The OData meta model containing metadata about the entity type.
+     * @param {string} entityTypeData - The entity type for which the line item annotation is to be retrieved.
+     * @param {IPresentationVariant} presentationVariantData - The presentation variant containing visualizations.
+     * @returns { IUIVisualizations | IUIVisualizations[] | null}
+     * - An object containing the line item details, annotation path, and qualifier if the annotation is found.
+     * - An array of UI annotations if applicable.
+     * - `null` if no valid line item annotation is found.
+     * @private
+     */
+    getLineItem(metaModel, entityTypeData, presentationVariantData) {
+      // Visualizations must be defined (according to vocabulary)
+      // however, this is not given at least in all demokit apps (presentationVariant consisting only of sortOrder)
+      let visualizationData = presentationVariantData.Visualizations?.find(function (oVis) {
+        return oVis.AnnotationPath?.includes(UIAnnotations.UILineItem);
+      });
+      return visualizationData ? {
+        lineItem: this.getObject(metaModel, entityTypeData, visualizationData.AnnotationPath),
+        annotationPath: visualizationData.AnnotationPath,
+        sQualifier: visualizationData.AnnotationPath?.split("#")[1]
+      } : null;
+    }
+
+    /**
+     * Extracts relevant column paths for `$select` and `$expand` OData query options.
+     *
+     * This method processes the provided column definitions to extract paths for the `$select` and `$expand` query options.
+     * It ensures that paths are unique and properly formatted for OData requests.
+     *
+     * @param {Array<Record<string,unknown>>} columns - An array of column definitions.
+     * Each column definition may include properties like `leadingProperty`, `additionalProperty`, and `navigationProperty`.
+     * @returns {SelectExpand} An object containing two arrays:
+     * - `select`: An array of unique paths for the `$select` query option.
+     * - `expand`: An array of unique paths for the `$expand` query option.
+     * @private
+     */
+    _getRelevantColumnPaths(columns) {
+      columns = Array.isArray(columns) ? columns : [];
+      const selectSet = new Set();
+      const expandSet = new Set();
+      columns.forEach(oColumnData => {
+        if (oColumnData) {
+          const sPath = oColumnData["leadingProperty"];
+          const sAdditionalPath = oColumnData["additionalProperty"];
+          const sExpandPath = oColumnData["navigationProperty"];
+          if (sPath) {
+            selectSet.add(sPath);
+          }
+          this.extractPathAndInsertToSet(sAdditionalPath, selectSet);
+          this.extractPathAndInsertToSet(sExpandPath, expandSet);
+        }
+      });
+      return {
+        select: Array.from(selectSet),
+        expand: Array.from(expandSet)
+      };
+    }
+
+    /**
+     * Extracts and inserts unique paths into the provided array.
+     *
+     * This method splits the given path string by commas, iterates through the resulting paths,
+     * and adds each unique path to the provided array. Duplicate paths are ignored.
+     *
+     * @param {string} sPath - A comma-separated string of paths to be processed.
+     * @param {Set<string>}  - The array to which unique paths will be added.
+     * @private
+     */
+    extractPathAndInsertToSet(sPath, pathSet) {
+      sPath?.split(",").forEach(path => {
+        if (path) {
+          pathSet.add(path);
+          // currently not doing transitive dependencies
+        }
+      });
+    }
+
+    /**
+     * Expands navigation properties for the given entity set and selected properties.
+     *
+     * This method processes the provided `selects` array to identify navigation properties
+     * that need to be expanded. If a navigation property is found, it is added to the `expands` array.
+     *
+     * @param {string} entitySetName - The name of the entity set being processed.
+     * @param {string[]} selects - An array of selected property paths to be checked for navigation properties.
+     * @param {string[]} expands - An array to which navigation properties requiring expansion will be added.
+     * @param {ODataMetaModel} metaModel - The OData meta model containing metadata about entities and properties.
+     * @private
+     */
+    extractAndExpandNavigationProperty(entitySetName, selects, expands, metaModel) {
+      const mNavigationProperties = {};
+
+      // check if any expand is necessary
+      for (const sPath of selects) {
+        let iPos = sPath.lastIndexOf("/");
+        let sNavigation;
+        if (iPos < 0) {
+          // sPath contains no '/' but still could be a navigationProperty
+          if (!this.getNavigationProperty(entitySetName, sPath, metaModel, mNavigationProperties)) {
+            continue; //not a navproperty hence continue to next iteration
+          }
+          sNavigation = sPath;
+        } else {
+          sNavigation = sPath.substring(0, iPos);
+        }
+        if (!expands.includes(sNavigation)) {
+          expands.push(sNavigation);
+        }
+      }
+    }
+
+    //get the navigation property details for the given property from entityset, sEntitySet
+    getNavigationProperty(entitySetName, navProperty, metaModel, mNavigationProperties) {
+      let mMyNavigationProperties = mNavigationProperties?.[entitySetName];
+
+      // If navigation properties not already fetched, then fetch them
+      if (!mMyNavigationProperties) {
+        mMyNavigationProperties = {};
+        mNavigationProperties[entitySetName] = mMyNavigationProperties;
+        const oEntitySet = metaModel.getODataEntitySet(entitySetName);
+        if (oEntitySet) {
+          const oEntityType = metaModel.getODataEntityType(oEntitySet.entityType);
+          if (oEntityType) {
+            const aNavigationProperty = oEntityType.navigationProperty || [];
+            aNavigationProperty.forEach(oNavigationProperty => {
+              const navName = oNavigationProperty.name;
+              mMyNavigationProperties[navName] = oNavigationProperty;
+            });
+          }
+        }
+      }
+      return mMyNavigationProperties?.[navProperty] || undefined;
+    }
+
+    // add all necessary fields to the select array
+    _addNecessaryFields(aSelects, oInfo, oMetaModel) {
+      let oEntitySet = oMetaModel.getODataEntitySet(oInfo.entitySet);
+      let oEntityType = oMetaModel.getODataEntityType(oEntitySet.entityType);
+      let aProperties = [];
+      if (aSelects.length > 0) {
+        if (oInfo.lineItem && typeof oInfo.lineItem !== "string") {
+          oInfo.lineItem.forEach(lineItem => {
+            if (lineItem.RecordType === FieldAnnotationsType.DataFieldWithIntentBasedNavigation || lineItem.RecordType === FieldAnnotationsType.DataFieldWithNavigationPath) {
+              const aDataFieldsWithNavigation = this.getDataFieldsWithNavigation(lineItem, oMetaModel, oEntityType);
+              if (aDataFieldsWithNavigation?.length) {
+                aProperties = aProperties.concat(aDataFieldsWithNavigation);
+              }
+            }
+          });
+        }
+        //add the fieldcontrol path of the properties
+        this.getFieldControlsPath(aSelects, oMetaModel, oEntityType, aProperties);
+      }
+      aProperties.forEach(property => {
+        this.ensureSelectionProperty(property, aSelects);
+      });
+    }
+
+    /**
+     * Collects the paths for field controls based on the selected properties.
+     * This function iterates over the given selection of properties, aSelects, retrieves the corresponding
+     * property metadata from the OData model, and if a field control annotation exists for a property,
+     * it adds the path of this field control to the provided array of properties.
+     * @param {string[]} selects - An array of property names to be checked for field control paths.
+     * @param {object} metaModel - The OData meta model instance used to retrieve property metadata.
+     * @param {object} entityType - The entity type from the OData model that contains the properties.
+     * @param {string[]} aProperties - An array to which the field control paths will be added.
+     * @private
+     */
+    getFieldControlsPath(selects, metaModel, entityType, aProperties) {
+      selects.forEach(sSelect => {
+        if (sSelect) {
+          //needed for activating field control for DataField Annotation & when using the setting to add new columns
+          let oProperty = metaModel.getODataProperty(entityType, sSelect) || {};
+          if (UIAnnotations.CommonFieldControl in oProperty) {
+            let oFieldControl = oProperty[UIAnnotations.CommonFieldControl];
+            if (oFieldControl?.Path) {
+              aProperties.push(oFieldControl.Path);
+            }
+          }
+        }
+      });
+    }
+
+    /**
+     * Handling for DataFieldWithNavigationPath and DataFieldWithIntentBasedNavigation
+     * @param {object} lineItem - LineItem object
+     * @param {object} metaModel - OData metamodel
+     * @param {object} entityType - EntityType object
+     * @returns {Array} - Array of properties to be selected in case field type is DataFieldWithNavigationPath or DataFieldWithIntentBasedNavigation
+     * @private
+     */
+    getDataFieldsWithNavigation(lineItem, metaModel, entityType) {
+      const requestFields = [];
+
+      // Handle Value.Path
+      const valuePath = lineItem.Value?.Path;
+      if (valuePath) {
+        const lineItemProperty = metaModel.getODataProperty(entityType, valuePath);
+        const textAnnotation = lineItemProperty?.[UIAnnotations.CommonText]?.Path;
+        const sapTextAnnotation = lineItemProperty?.["sap:text"];
+        requestFields.push(sapTextAnnotation || textAnnotation || valuePath);
+      }
+
+      // Handle SemanticObject.Path
+      if (lineItem.SemanticObject?.Path) {
+        requestFields.push(lineItem.SemanticObject.Path);
+      }
+
+      // Handle Action.Path
+      if (lineItem.Action?.Path) {
+        requestFields.push(lineItem.Action.Path);
+      }
+      return requestFields;
+    }
+
+    // Section: Parameter Handling
+    getParameters(oInfo, metaModel, entitySet, oSelectExpand) {
+      let aSelects = oSelectExpand.select || [];
+      let aExpands = oSelectExpand.expand || [];
+      let alwaysSelectField = oInfo?.lrSettings?.requestAtLeastFields || [];
+      if (alwaysSelectField.length > 0) {
+        aSelects = this._ensureSelectionProperties(aSelects, alwaysSelectField);
+      }
+      this._handleMandatorySelectionFields(entitySet, aSelects, metaModel);
+      this._addNecessaryFields(aSelects, oInfo, metaModel);
+      this.extractAndExpandNavigationProperty(entitySet, aSelects, aExpands, metaModel);
+      return {
+        expand: aExpands.join(",") || undefined,
+        select: aSelects.join(",") || undefined
+      };
+    }
+
+    /**
+     *
+     * @param {Array} aSelects , select parameters
+     * @param {SelectionProperties} alwaysSelectField, all the fields that are marked as requestAtLeastFields
+     * @returns {Array} aSelects, updated select parameters
+     * @private
+     */
+
+    _ensureSelectionProperties(aSelects, alwaysSelectField) {
+      for (const item of alwaysSelectField) {
+        if (typeof item === "object" && item?.PropertyPath && !aSelects.includes(item.PropertyPath)) {
+          aSelects.push(item.PropertyPath);
+        }
+      }
+      return aSelects;
+    }
+
+    /**
+     * Handles the mandatory selection fields for the given entity set and properties.
+     *
+     * @param {object} entitySet - The entity set object.
+     * @param {array} aSelects - The array of properties.
+     * @returns {boolean} True if the entity set or properties have mandatory fields, false otherwise.
+     * @private
+     */
+    _handleMandatorySelectionFields(entitySet, aSelects, oMetaModel) {
+      const oEntitySet = oMetaModel.getODataEntitySet(entitySet, false);
+      const oEntityType = oMetaModel.getODataEntityType(oEntitySet.entityType, false);
+      oEntityType.key.propertyRef.forEach(field => {
+        this.ensureSelectionProperty(field.name, aSelects);
+      });
+    }
+
+    // push the selection properties to the select array
+    ensureSelectionProperty(sProperty, aSelects) {
+      sProperty?.split(",").forEach(function (sElement) {
+        if (sElement && !aSelects.includes(sElement)) {
+          aSelects.push(sElement);
+        }
+      });
+    }
+
+    /**
+     * Creates a card manifest for a recommended card.
+     *
+     * This method generates a new card manifest based on the provided input data, version information, and app manifest.
+     * It also processes the columns to set attributes or titles for the card content and handles row navigation suppression if required.
+     *
+     * @param {IManifestCardData} oInput - The input data for the card, including card title, subtitle, columns, and entity set.
+     * @param {IVersionInfo} oVersionInfo - The version information, including the version and build timestamp.
+     * @param {IAppManifest} manifest - The original app manifest.
+     * @param {boolean} [bSuppressRowNavigation] - Optional flag to suppress row navigation actions in the card content.
+     * @returns {ICardManifest} The generated card manifest object.
+     * @private
+     */
+    _createCardManifest(oInput, oVersionInfo, manifest, bSuppressRowNavigation) {
+      let oUIManifest = manifest["sap.ui"];
+      let oAppManifest = manifest["sap.app"];
+      let attributeIndex = 0;
+      if (oAppManifest?.["crossNavigation"]) {
+        delete oAppManifest["crossNavigation"];
+      }
+      if (oAppManifest) {
+        Object.assign(oAppManifest, {
+          type: "card",
+          id: `user.${oInput.id}.${Date.now()}`,
+          title: oInput.cardTitle || "",
+          subTitle: oInput.subTitle
+        });
+      }
+      let oNewManifest = {
+        "sap.ui": oUIManifest,
+        "sap.app": this.createManifestSapApp(oAppManifest),
+        "sap.card": this.createManifestSapCard(manifest, oInput),
+        "sap.ui5": this.createSapui5()
+      };
+      const oContent = oNewManifest?.["sap.card"]?.content;
+      oInput.columns.slice(0, COLUMN_LENGTH).forEach(column => {
+        const columnValue = this._getAttributeValue(column);
+        if (column.identifier && oContent?.item) {
+          // If column.identifier is true, set it as the title
+          oContent.item.title = {
+            value: columnValue,
+            identifier: true
+          };
+        } else if (oContent?.item?.attributes) {
+          // Otherwise, add it to the attributes
+          oContent.item.attributes[attributeIndex] = {
+            value: columnValue,
+            visible: true,
+            ...(column.state && {
+              state: column.state,
+              showStateIcon: column.showStateIcon
+            })
+          };
+          attributeIndex++;
+        }
+      });
+
+      // if bSuppressRowNavigation true, remove content actions
+      if (bSuppressRowNavigation && oContent?.item) {
+        oContent.item.actions = [];
+      }
+      return {
+        ...oNewManifest,
+        "sap.insights": {
+          parentAppId: oInput.id,
+          cardType: "RT",
+          versions: {
+            ui5: `${oVersionInfo.version}-${oVersionInfo.buildTimestamp}`
+          },
+          visible: true
+        }
+      };
+    }
+
+    /**
+     * Get Attribute Value
+     *
+     * @param {object} attributeData - column object
+     * @returns {string} returns attribute value
+     * @private
+     */
+    _getAttributeValue(attributeData) {
+      let attributeValue = !attributeData.value.startsWith("{") ? "{= extension.formatters.stringFormatter(${" + attributeData.path + "}) }" : attributeData.value;
+      if (attributeData.type === "Edm.Date" || attributeData.type === "Edm.DateTime") {
+        const oDateFormatOptions = JSON.stringify({
+          pattern: Formatting.getDatePattern("short")
+        });
+        attributeValue = "{=${" + attributeData.path + "}?format.dateTime(${" + attributeData.path + "}, " + oDateFormatOptions + ") : ''}";
+      }
+      return attributeValue;
+    }
+
+    //creates sap.app object structure for the card manifest of recommended card
+    createManifestSapApp(appManifest) {
+      const manifestAppData = deepExtend({}, appManifest);
+      if (manifestAppData?.dataSources?.mainService) {
+        manifestAppData.dataSources["filterService"] = manifestAppData.dataSources.mainService;
+        if (manifestAppData.dataSources["filterService"]?.settings) {
+          manifestAppData.dataSources["filterService"].settings["odataVersion"] = "2.0";
+        }
+      }
+      return manifestAppData;
+    }
+
+    /**
+     * Creates the manifest's SAP card object, sap.card based on the input card details.
+     *
+     * @param {oIAppManifestbject} manifest - The original manifest object of the application.
+     * @param {IManifestCardData} oInput - The input object containing card details.
+     * @returns {ISapCard} The SAP card configuration object.
+     */
+    createManifestSapCard(manifest, oInput) {
+      const datasource = manifest["sap.app"]?.dataSources;
+      const sServiceUrl = datasource?.mainService?.uri;
+      const entitySetName = oInput.entitySet;
+      const sCountPath = "__count";
+      const sText = {
+        text: "{= ${" + sCountPath + "} === '0' ? '' : ${" + sCountPath + "} }"
+      };
+      let oCardConfig = {
+        type: "List"
+      };
+      oCardConfig["configuration"] = this.createManifestSapCardConfig(sServiceUrl || "", entitySetName);
+      oCardConfig["data"] = this.createManifestSapCardData(sServiceUrl || "", oInput.url);
+      oCardConfig["header"] = {
+        title: oInput.cardTitle,
+        subTitle: "",
+        actions: [],
+        status: sText,
+        data: {
+          path: "/content/d"
+        }
+      };
+      oCardConfig["extension"] = "module:sap/insights/CardExtension";
+      oCardConfig["content"] = {
+        data: {
+          path: "/content/d/results"
+        },
+        maxItems: 5,
+        item: {
+          actions: [],
+          attributesLayoutType: "OneColumn",
+          attributes: []
+        }
+      };
+      this.addCardActions(oCardConfig, oInput.semanticObject, oInput.action);
+      return oCardConfig;
+    }
+
+    /**
+     * Sets the card actions for the given SAP card.
+     *
+     * @param {object} sapCard - The SAP card object to set the actions on.
+     * @param {string} semObj - The semantic object for the navigation target.
+     * @param {string} semanticAction - The semantic action for the navigation target.
+     */
+    addCardActions(sapCard, semObj, semanticAction) {
+      let oHeaderParams = {
+        ibnTarget: {
+          semanticObject: semObj,
+          action: semanticAction
+        },
+        sensitiveProps: [],
+        ibnParams: {}
+      };
+      let oHeaderParameterValue = [{
+        type: "Navigation",
+        parameters: "{= extension.formatters.getNavigationContext(${parameters>/headerState/value})}"
+      }];
+      let oContentParams = JSON.parse(JSON.stringify(oHeaderParams));
+      let oContentParameterValue = [{
+        type: "Navigation",
+        parameters: "{= extension.formatters.getNavigationContext(${parameters>/contentState/value}, ${})}"
+      }];
+      if (sapCard.configuration?.parameters) {
+        sapCard.configuration.parameters.headerState = {
+          value: JSON.stringify(oHeaderParams)
+        };
+        sapCard.configuration.parameters.contentState = {
+          value: JSON.stringify(oContentParams)
+        };
+      }
+      if (sapCard.header) {
+        sapCard.header.actions = oHeaderParameterValue;
+      }
+      if (sapCard?.content?.item) {
+        sapCard.content.item.actions = oContentParameterValue;
+      }
+    }
+
+    /**
+     * Creates the manifest sap card configuration object.
+     *
+     * @param {string} sServiceUrl - The service URL to be used in the request.
+     * @param {string} entitySetName - The name of the entity set.
+     * @returns {object} The SAP card configuration object.
+     */
+    createManifestSapCardConfig(sServiceUrl, entitySetName) {
+      const oCardConfiguration = {
+        parameters: {
+          _relevantODataFilters: {
+            value: []
+          },
+          _relevantODataParameters: {
+            value: []
+          },
+          _entitySet: {
+            value: entitySetName
+          },
+          _urlSuffix: {
+            value: "/Results"
+          }
+        },
+        destinations: {
+          service: {
+            name: "(default)",
+            defaultUrl: "/"
+          }
+        },
+        csrfTokens: {
+          token1: {
+            data: {
+              request: {
+                url: "{{destinations.service}}" + sServiceUrl,
+                method: "HEAD",
+                headers: {
+                  "X-CSRF-Token": "Fetch"
+                }
+              }
+            }
+          }
+        }
+      };
+      return oCardConfiguration;
+    }
+
+    //create sap.ui5 object for the card manifest
+    createSapui5() {
+      return {
+        _version: "1.1.0",
+        contentDensities: {
+          compact: true,
+          cozy: true
+        },
+        dependencies: {
+          libs: {
+            "sap.insights": {
+              lazy: false
+            }
+          }
+        }
+      };
+    }
+
+    /**
+     * Creates the manifest data for an SAP card.
+     *
+     * @param {string} sServiceUrl - The service URL to be used in the request.
+     * @param {string} urlExpand - The URL to expand in the batch request.
+     * @returns {IRequestData} The SAP card data object containing the request configuration.
+     */
+    createManifestSapCardData(sServiceUrl, urlExpand) {
+      const oBatch = {
+        content: {
+          method: "GET",
+          url: urlExpand,
+          headers: {
+            Accept: "application/json"
+          }
+        }
+      };
+      const oSapCardData = {
+        request: {
+          url: "{{destinations.service}}" + sServiceUrl + "/$batch",
+          method: "POST",
+          headers: {
+            "X-CSRF-Token": "{{csrfTokens.token1}}"
+          },
+          batch: oBatch
+        }
+      };
+      return oSapCardData;
+    }
+
+    /**
+     * This function returns card details required for the recommended card manifest
+     * based on app manifest and annotations
+     * @param {object} manifest - The original app manifest
+     * @param {object} oInfo - The object containing details of lineitem, entityset, settings etc
+     * @param {object} oParentApp - The parent app object
+     * @param {object} oMetaModel - The OData metamodel
+     * @returns {object} The card data object with title, subtitle, url, semanticObject, action, id and column details
+     * @private
+     */
+    _getManifestCardData(manifest, oInfo, oParentApp, oMetaModel) {
+      const manifestApp = manifest["sap.app"];
+      const dataSources = manifestApp?.dataSources;
+      const mainServiceUri = dataSources?.mainService?.uri || "";
+      const lineItem = oInfo.lineItem;
+      const entitySet = oInfo.entitySet;
+      const oEntitySet = oMetaModel.getODataEntitySet(entitySet);
+      const oEntityType = oMetaModel.getODataEntityType(oEntitySet?.entityType);
+      const serviceUrl = `${mainServiceUri.replace(/\/$/, "")}/${entitySet}`; // make '{mainServiceUri}/{entitySet}' format
+
+      //get the column details for each of the lineitem columns
+      const aColumns = lineItem?.map(oColumn => this._getColumnDetail(entitySet, oMetaModel, oColumn)).filter(oItem => oItem !== undefined);
+      const oSelectExpand = this._getRelevantColumnPaths(aColumns);
+      //get the complete select and expand parameters for url
+      const mParameters = this.getParameters(oInfo, oMetaModel, entitySet, oSelectExpand);
+      const urlSelectExpand = this.createCustomParams(mParameters);
+      const finalUrl = urlSelectExpand ? `${serviceUrl}?$top=5&skip=0&${urlSelectExpand}&$inlinecount=allpages` : `${serviceUrl}?$top=5&skip=0`;
+      //sort  the column based on their importance and then slice the first 4 columns
+      const aColumnSorted = sortCollectionByImportance(aColumns).map(column => {
+        return {
+          path: column?.path,
+          type: column?.type,
+          value: column?.value,
+          identifier: column?.identifier,
+          state: column?.state,
+          showStateIcon: column?.showStateIcon
+        };
+      }).slice(0, 4);
+      return {
+        cardTitle: manifest?.["sap.app"]?.title,
+        subTitle: oEntityType[UIAnnotations.CommonLabel] ? `Top 5 ${oEntityType[UIAnnotations.CommonLabel].String}` : "",
+        url: finalUrl,
+        semanticObject: oParentApp?.semanticObject || "",
+        action: oParentApp?.action || "",
+        id: manifest?.["sap.app"]?.id,
+        columns: aColumnSorted,
+        entitySet: entitySet
+      };
+    }
+
+    /**
+     * This function returns the column detail object for the given column's context
+     * @param {string} entitySet - - The entity set name
+     * @param {object} oMetaModel -  OData metamodel
+     * @param {object} lineItemContext - The line item column context object
+     * @returns {object} The column detail containing value, path, importance and type
+     * @private
+     */
+    _getColumnDetail(entitySet, oMetaModel, lineItemContext) {
+      let oProperty;
+      let oEntitySet = oMetaModel.getODataEntitySet(entitySet);
+      let oEntityType = oMetaModel.getODataEntityType(oEntitySet.entityType);
+      if (lineItemContext.Value?.Path) {
+        oProperty = oMetaModel.getODataProperty(oEntityType, lineItemContext.Value.Path);
+        let oPropertyHidden = oProperty[UIAnnotations.UIHidden];
+
+        // if oProperty not hidden and oLineitemContext not hidden then only consider the column else return undefined
+        if (oPropertyHidden?.Bool === "true" || oPropertyHidden?.Bool === true) {
+          return undefined;
+        }
+        //check if lineItemContext is hidden or no oProperty is found
+        if (this.isPropertyHidden(lineItemContext) || !oProperty || Object.keys(oProperty).length === 0) {
+          return undefined;
+        }
+      }
+      let oP13NDetails = this.createP13N(oEntitySet, oProperty, lineItemContext, oMetaModel);
+      oP13NDetails = oP13NDetails.replace(/\\/g, ""); // Remove the double backslashes
+      let columnDataObject = oP13NDetails ? JSON.parse(oP13NDetails) : {};
+      if (!this.isSupportedColumn(columnDataObject, lineItemContext, oMetaModel, oEntitySet)) {
+        return undefined;
+      }
+      if (oProperty) {
+        columnDataObject = this.getColumnObjectDetails(columnDataObject, oProperty, oEntityType, lineItemContext);
+        if (lineItemContext?.[FieldAnnotationsType.Importance] !== undefined) {
+          const importance = lineItemContext[FieldAnnotationsType.Importance];
+          columnDataObject.importance = importance;
+        }
+      }
+      return columnDataObject;
+    }
+
+    /**
+     * Retrieves the column object details based on the provided property and entity type.
+     *
+     * @param {object} columnDataObject - The column information object to be populated.
+     * @param {object} propertyDetails - The property object containing metadata about the column.
+     * @param {object} entityType - The entity type object containing metadata about the entity.
+     * @param {object} dataField - The data field object containing the lineitem column context object
+     * @returns {object} The populated column information object.
+     * @private
+     */
+    getColumnObjectDetails(columnDataObject, propertyDetails, entityType, dataField) {
+      let sColumnKeyDescription = propertyDetails[UIAnnotations.CommonText]?.Path || "";
+      sColumnKeyDescription = "{" + sColumnKeyDescription + "}";
+      let sColumnValue = propertyDetails.name ? "{" + propertyDetails.name + "}" : "";
+      let sNavigation = "";
+      const aSemKeyAnnotation = entityType[UIAnnotations.CommonSemanticKey];
+      const bIsPropertySemanticKey = !!aSemKeyAnnotation && aSemKeyAnnotation.some(function (oAnnotation) {
+        return oAnnotation.PropertyPath === propertyDetails.name;
+      });
+      let bIsCriticality = false;
+      let criticalityAnnotation = undefined;
+      if ((dataField?.Criticality && dataField?.Value?.Path) === propertyDetails.name) {
+        criticalityAnnotation = dataField;
+        bIsCriticality = true;
+      }
+      if (propertyDetails[UIAnnotations.MeasuresISOCurrency]?.Path) {
+        sColumnValue = sColumnValue.concat(" " + "{" + sNavigation + propertyDetails[UIAnnotations.MeasuresISOCurrency]?.Path + "}");
+      }
+      if (propertyDetails[UIAnnotations.MeasuresUnit]?.Path) {
+        sColumnValue = sColumnValue.concat(" " + "{" + sNavigation + propertyDetails[UIAnnotations.MeasuresUnit]?.Path + "}");
+      }
+      if (propertyDetails[UIAnnotations.CommonText]?.Path) {
+        let sTextArragement = propertyDetails[UIAnnotations.CommonText]?.[UIAnnotations.UITextArrangement];
+        if (!sTextArragement) {
+          sTextArragement = entityType[UIAnnotations.UITextArrangement];
+        }
+        this._setColumnTextValue(sTextArragement, columnDataObject, sColumnKeyDescription, sColumnValue);
+      } else {
+        columnDataObject["value"] = sColumnValue;
+        if (bIsPropertySemanticKey) {
+          columnDataObject["identifier"] = bIsPropertySemanticKey;
+        }
+      }
+      if (bIsCriticality) {
+        columnDataObject["state"] = this.buildExpressionForCriticalityColor(criticalityAnnotation);
+        columnDataObject["showStateIcon"] = criticalityAnnotation?.CriticalityRepresentation?.EnumMember !== FieldAnnotationsType.CriticalityRepresentationTypeWithoutIcon || true;
+      }
+      columnDataObject["path"] = propertyDetails[UIAnnotations.CommonText]?.Path || propertyDetails.name;
+      columnDataObject["type"] = propertyDetails.type;
+      return columnDataObject;
+    }
+
+    /**
+     * Build expression for the criticality annotation, kept same as the one used in LROP
+     * @param {object} criticalityAnnotation - The criticality annotation object
+     * @returns {string} The expression for the criticality color
+     * @private
+     */
+    buildExpressionForCriticalityColor(criticalityAnnotation) {
+      let sFormatCriticalityExpression = ValueState.None;
+      let sExpressionTemplate;
+      let oCriticalityProperty = criticalityAnnotation?.Criticality;
+      let CriticalityType = /*#__PURE__*/function (CriticalityType) {
+        CriticalityType["Negative"] = "com.sap.vocabularies.UI.v1.CriticalityType/Negative";
+        CriticalityType["Critical"] = "com.sap.vocabularies.UI.v1.CriticalityType/Critical";
+        CriticalityType["Positive"] = "com.sap.vocabularies.UI.v1.CriticalityType/Positive";
+        return CriticalityType;
+      }({});
+      if (oCriticalityProperty) {
+        sExpressionTemplate = "'{'= ({0} === ''" + CriticalityType.Negative + "'') || ({0} === ''1'') || ({0} === 1) ? ''" + ValueState.Error + "'' : " + "({0} === ''" + CriticalityType.Critical + "'') || ({0} === ''2'') || ({0} === 2) ? ''" + ValueState.Warning + "'' : " + "({0} === ''" + CriticalityType.Positive + "'') || ({0} === ''3'') || ({0} === 3) ? ''" + ValueState.Success + "'' : " + "''" + ValueState.None + "'' '}'";
+        if (oCriticalityProperty?.Path) {
+          const sCriticalitySimplePath = "${" + oCriticalityProperty.Path + "}";
+          sFormatCriticalityExpression = formatMessage(sExpressionTemplate, [sCriticalitySimplePath]);
+        } else if (oCriticalityProperty?.EnumMember) {
+          const sCriticality = "'" + oCriticalityProperty.EnumMember + "'";
+          sFormatCriticalityExpression = formatMessage(sExpressionTemplate, [sCriticality]);
+        } else {
+          Log.warning("Case not supported, returning the default sap.ui.core.ValueState.None");
+        }
+      } else {
+        // Any other cases are not valid, the default value of 'None' will be returned
+        Log.warning("Case not supported, returning the default sap.ui.core.ValueState.None");
+      }
+      return sFormatCriticalityExpression;
+    }
+
+    /**
+     * Sets display text format of column
+     *
+     * @private
+     * @param {{EnumMember: string} | undefined} sTextArragement - sTextArragement object
+     * @param { ColumnObjectData} columnDataObject - Object containing column details
+     * @param {string} sColumnKeyDescription - Description field to include in text value
+     * @param {string} sColumnValue - The value to include in Text value
+     */
+    _setColumnTextValue(sTextArragement, columnDataObject, sColumnKeyDescription, sColumnValue) {
+      let TextArrangementType = /*#__PURE__*/function (TextArrangementType) {
+        TextArrangementType["TextOnly"] = "TextOnly";
+        TextArrangementType["TextLast"] = "TextLast";
+        TextArrangementType["TextSeparate"] = "TextSeparate";
+        return TextArrangementType;
+      }({});
+      const sTextArrangementType = sTextArragement?.EnumMember?.split("/")[1];
+      let valueExpr;
+      switch (sTextArrangementType) {
+        case TextArrangementType.TextOnly:
+          valueExpr = `{= $${sColumnKeyDescription} === '' ? '' : $${sColumnKeyDescription} }`;
+          break;
+        case TextArrangementType.TextLast:
+          valueExpr = `{= $${sColumnValue} === '' ? '' : $${sColumnValue} }` + `{= $${sColumnKeyDescription} === '' ? '' : ' (' + ($${sColumnKeyDescription}) + ')' }`;
+          break;
+        case TextArrangementType.TextSeparate:
+          valueExpr = `{= $${sColumnValue} === '' ? '' : $${sColumnValue} }`;
+          break;
+        default:
+          valueExpr = `{= $${sColumnKeyDescription} === '' ? '' : $${sColumnKeyDescription} }` + `{= $${sColumnValue} === '' ? '' : ' (' + ($${sColumnValue}) + ')' }`;
+          break;
+      }
+      columnDataObject["value"] = valueExpr;
+    }
+
+    // get requestAtlLeastFields from PresentationVariant
+    _getRequestAtLeastFields(presentationVariant) {
+      return presentationVariant && Array.isArray(presentationVariant.requestAtLeastFields) ? presentationVariant.requestAtLeastFields : [];
+    }
+
+    /**
+     * Creates a query string with custom parameters for OData requests.
+     *
+     * This method generates a query string containing `$expand` and `$select` parameters
+     * based on the provided input object. The values are URL-encoded to ensure proper formatting.
+     *
+     * @param {object} mParameters - An object containing the parameters for the query string.
+     * @param {string | undefined} mParameters.expand - The value for the `$expand` parameter, if any.
+     * @param {string | undefined} mParameters.select - The value for the `$select` parameter, if any.
+     * @returns {string} A query string containing the `$expand` and `$select` parameters, joined by `&`.
+     * @private
+     */
+    createCustomParams(mParameters) {
+      const aCustomParams = [];
+      if (mParameters?.expand) {
+        aCustomParams.push("$expand=" + encodeURL(mParameters["expand"]));
+      }
+      if (mParameters?.select) {
+        aCustomParams.push("$select=" + encodeURL(mParameters["select"]));
+      }
+      return aCustomParams.join("&");
+    }
+
+    /**
+     * Retrieves an object from the OData meta model based on the given entity type and path.
+     *
+     * This method resolves the provided path to an absolute path if it is relative, using the entity type as the base.
+     * It then retrieves the corresponding object from the meta model. Any "@" characters in the path are removed
+     * to match the meta model's structure.
+     *
+     * @param {ODataMetaModel} metaModel - The OData meta model containing metadata about entities and annotations.
+     * @param {string} entityTypeName - The entity type used as the base for resolving relative paths.
+     * @param {string} path - The path to the object in the meta model. Can be relative or absolute.
+     * @returns {IPresentationVariant | ILineItem[]} The object retrieved from the meta model, which can be a presentation variant or an array of nested objects.
+     * @private
+     */
+    getObject(metaModel, entityTypeName, path) {
+      if (path[0] !== "/") {
+        // relative path - add path of annotation target, i.e. EntityType
+        path = metaModel.getODataEntityType(entityTypeName, true) + "/" + path; //*****check this */
+      }
+      // assumption: absolute paths in annotations are equal to corresponding paths in metaModel
+      // any "@" are removed in the metaModel
+      return metaModel.getObject(path.replace(/@/g, ""));
+    }
+
+    /**
+     * Check If Page is List Report
+     *
+     * @param {object} page - page object
+     * @returns {boolean} returns boolean
+     * @private
+     */
+    _isListReport(page) {
+      return page?.component?.name === "sap.suite.ui.generic.template.ListReport";
+    }
+
+    /**
+     * @param {IPageType[] | PageRecord} pages - pages object from manifest
+     * @returns {ILrSettings} - returns the settings object for the ListReport
+     */
+    getSettingsForPage(pages) {
+      if (!pages) {
+        return {};
+      }
+      let lrSettings = {};
+
+      // Handling array and object structure in LR V2 manifest
+      if (Array.isArray(pages) && this._isListReport(pages[0])) {
+        const listPage = pages[0];
+        if (listPage?.component) {
+          const component = listPage.component;
+          lrSettings = component?.settings || {};
+          lrSettings.bSupressCardRowNavigation = this.shouldSuppressCardRowNavigation(listPage);
+        }
+      } else if (Object.keys(pages).length) {
+        const sListKey = Object.keys(pages).find(key => this._isListReport(pages[key]));
+        if (sListKey) {
+          const listPage = pages[sListKey];
+          if (listPage?.component) {
+            const component = listPage.component;
+            lrSettings = component?.settings ?? {};
+            lrSettings.bSupressCardRowNavigation = this.shouldSuppressCardRowNavigation(listPage);
+          }
+        }
+      }
+      return lrSettings;
+    }
+
+    /**
+     * Determines whether card row navigation should be suppressed for the card
+     *
+     * @param {IPageType} page - The ListReport page object from the manifest.
+     * @returns {boolean} True if card row navigation should be suppressed
+     */
+    shouldSuppressCardRowNavigation(listPage) {
+      // LR only app or if external navigation from OP
+      if (listPage.pages) {
+        // If pages is an array, handle based on its length and navigation property
+        if (Array.isArray(listPage.pages)) {
+          if (listPage.pages.length === 0 || listPage.pages[0]?.navigation) {
+            return true;
+          }
+        } else {
+          // If pages is an object, check if the object keys have navigation
+          const keys = Object.keys(listPage.pages);
+          if (keys.length === 0 || keys.length && listPage.pages[keys[0]]?.navigation) {
+            return true;
+          }
+        }
+      } else {
+        //if no list pages return true
+        return true;
+      }
+
+      // Check for Quick variant selection X in settings
+      if (listPage?.component?.settings?.quickVariantSelectionX) {
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * @param {object} metaModel - metamodel object
+     * @param {ILrSettings} ILrSettings - settings object from the manifest
+     * @param {string} entitySetName - entity set of the application
+     * @returns {object} - returns the normalized table settings
+     * @private
+     */
+    getNormalizedTableSettings(metaModel, lRVariantSettings, entitySetName) {
+      const settings = deepExtend({}, lRVariantSettings);
+
+      // 1. map boolean settings gridTable and treeTable to tableType
+      if (settings && !settings.tableType) {
+        if (settings.gridTable) {
+          settings.tableType = TABLE_TYPES.GRID;
+        } else if (settings.treeTable) {
+          settings.tableType = TABLE_TYPES.TREE;
+        }
+      }
+
+      // 2. map flat settings to structured ones
+      settings.tableSettings = settings.tableSettings || {};
+      settings.tableSettings.type = settings.tableSettings.type || settings.tableType;
+      const entitySet = metaModel.getODataEntitySet(entitySetName);
+      const entityTypeData = metaModel.getODataEntityType(entitySet.entityType);
+
+      // 3. determine type
+      if (settings.tableSettings.type !== TABLE_TYPES.STANDARD_LIST && settings.tableSettings.type !== TABLE_TYPES.OBJECT_LIST && entitySetName) {
+        settings.tableSettings.type = settings.tableSettings.type || (entityTypeData[UIAnnotations.SapSemantics] === "aggregate" ? TABLE_TYPES.ANALYTICAL : TABLE_TYPES.RESPONSIVE);
+        if (settings.tableSettings.type === TABLE_TYPES.ANALYTICAL && !(entityTypeData[UIAnnotations.SapSemantics] === "aggregate")) {
+          settings.tableSettings.type = TABLE_TYPES.GRID;
+        }
+      }
+      if (entityTypeData[UIAnnotations.UIHeaderInfo]) {
+        settings.tableSettings.headerInfo = entityTypeData[UIAnnotations.UIHeaderInfo];
+      }
+
+      // 4. remove deprecated settings (to avoid new code to rely on them)
+      delete settings.gridTable;
+      delete settings.treeTable;
+      delete settings.tableType;
+      return settings.tableSettings;
+    }
+
+    /**
+     * @param {object} metaModel - metamodel object
+     * @param {string} entitySetName - entity set of the application
+     * @param {object} tabItem - details of the variant tab
+     * @returns {boolean} - returns true if the variant is a smart chart
+     */
+    checkIfSmartChart(metaModel, entitySetName, tabItem) {
+      let entitySetData = metaModel.getODataEntitySet(entitySetName);
+      let entityTypeData = metaModel.getODataEntityType(entitySetData.entityType);
+      let annotationName, annotationPath, variantData;
+      annotationPath = tabItem.annotationPath;
+      //variantData = !!annotationPath && (entityTypeData[annotationPath] as VariantInfo);
+      variantData = annotationPath ? entityTypeData[annotationPath] : undefined;
+      if (variantData?.PresentationVariant) {
+        // oVariant is SelectionPresentationVariant
+        if (variantData.PresentationVariant.Visualizations) {
+          annotationName = variantData.PresentationVariant.Visualizations[0].AnnotationPath;
+        } else if (variantData.PresentationVariant.Path) {
+          let sPresentationVariantPath = variantData.PresentationVariant.Path.split("@")[1];
+          let oPresentationVariantAnnotation = sPresentationVariantPath && entityTypeData[sPresentationVariantPath];
+          annotationName = oPresentationVariantAnnotation ? oPresentationVariantAnnotation?.Visualizations?.[0].AnnotationPath : "";
+        }
+      } else if (variantData?.Visualizations) {
+        // oVariant is PresentationVariant
+        annotationName = variantData.Visualizations[0].AnnotationPath;
+      }
+      return !!((annotationName ?? "").indexOf(UIAnnotations.UIChart) > -1);
+    }
+
+    /**
+     * function returns true if the passed entityset / properties have mandatory properties
+     *
+     * @param {EntitySet} entitySetData - Entity set
+     * @param {Array} propertiesSet - Additional Properties
+     * @returns {boolean} returns boolean
+     * @private
+     */
+    hasMandatoryProperties(entitySetData, propertiesSet) {
+      // if entityset has required properties in filter restrictions return true
+      if (entitySetData?.["Org.OData.Capabilities.V1.FilterRestrictions"]?.["RequiredProperties"]?.length) {
+        return true;
+      } else if (propertiesSet?.length) {
+        // iterate through all properties and return true if any property is mandatory or sap:rquired-in-filter is true
+        return propertiesSet.some(propertyDetail => {
+          return Object.keys(propertyDetail).length && (propertyDetail["sap:parameter"] === "mandatory" || propertyDetail["sap:required-in-filter"] === "true");
+        });
+      }
+      return false;
+    }
+
+    /**
+     * Check if sEntitySet has association with parameterised entityset and if it has give parametersised entityset parameters
+     * @param {object} metaModel OData MetaModel
+     * @param {string} entitySetName of the EntitySet which has Parameter Entityset in association.
+     * @param {boolean} infoParamsRequired If the full info of parameters is needed or only the name of params is needed.
+     * @return {ParameterisedEntity} Contains name of Parameter EntitySet, keys of Parameter EntitySet and Name of Navigation property.
+     * @private
+     */
+    _getParametersisedEntitySetParams(metaModel, entitySetName, infoParamsRequired) {
+      if (!metaModel) {
+        throw new Error("OData Model needs to be passed as an argument");
+      }
+      const oResult = {
+        entitySetName: null,
+        parameters: [],
+        navPropertyName: null
+      };
+      const entitySetData = metaModel.getODataEntitySet(entitySetName);
+      const entityTypeData = metaModel.getODataEntityType(entitySetData.entityType);
+      const aNavigationProperties = entityTypeData.navigationProperty;
+      if (!aNavigationProperties) {
+        return oResult;
+      }
+
+      // filter the parameter entityset for extracting it's key and it's entityset name
+      aNavigationProperties.forEach(function (oNavProperty) {
+        const oNavigationEntitySet = metaModel.getODataAssociationEnd(entityTypeData, oNavProperty.name);
+        const oNavigationEntityType = oNavigationEntitySet && metaModel.getODataEntityType(oNavigationEntitySet.type);
+        if (oNavigationEntityType?.[UIAnnotations.SapSemantics] !== "parameters" || !oNavigationEntityType.key) {
+          return false;
+        }
+        oResult.entitySetName = metaModel.getODataAssociationSetEnd(entityTypeData, oNavProperty.name)?.entitySet;
+        for (let value of oNavigationEntityType.key.propertyRef) {
+          if (infoParamsRequired) {
+            const navProp = oNavigationEntityType.property;
+            for (let navProperty of navProp) {
+              if (navProperty.name === value.name) {
+                oResult.parameters.push(navProperty);
+              }
+            }
+          } else {
+            oResult.parameters.push(value.name);
+          }
+        }
+        const aSubNavigationProperties = oNavigationEntityType.navigationProperty;
+        // Parameter entityset must have association back to main entityset.
+        const bBackAssociationPresent = aSubNavigationProperties?.some(function (oSubNavigationProperty) {
+          const sSubNavigationEntityType = metaModel.getODataAssociationEnd(oNavigationEntityType, oSubNavigationProperty?.name)?.type;
+          //if entityset.entitytype is same as subnavigation entitytype then it's a back association
+          oResult.navPropertyName = sSubNavigationEntityType === entitySetData.entityType ? oSubNavigationProperty?.name : null;
+          return oResult.navPropertyName;
+        });
+        return bBackAssociationPresent && oResult.navPropertyName && oResult.entitySetName;
+      });
+      return oResult;
+    }
+
+    /**
+     * This function check if a lineitem annotation column is visible or not
+     * @param {object} lineItemAnnotations - The column details object
+     * @returns {Boolean} The column visibility status {true/false}
+     * @private
+     */
+    isPropertyHidden(lineItemAnnotations) {
+      let oFieldControl = lineItemAnnotations[UIAnnotations.CommonFieldControl];
+      let uiHidden = lineItemAnnotations[UIAnnotations.UIHidden];
+
+      // Check for FieldControl Hidden
+      if (oFieldControl?.EnumMember === FieldAnnotationsType.FieldControlHiddenType) {
+        return true;
+      }
+
+      // Check for UI Hidden
+      if (uiHidden) {
+        if (Object.prototype.hasOwnProperty.call(uiHidden, "Bool")) {
+          return uiHidden?.Bool === "true";
+        } else if (Object.prototype.hasOwnProperty.call(uiHidden, "Path")) {
+          return false;
+        } else {
+          return true; // <Annotation Term="UI.Hidden"/>
+        }
+      }
+      return false;
+    }
+
+    /**
+     * Creates a P13N  string for a given entity set, property, and line item column.
+     *
+     * @param {Object} contextSet - The entity set object.
+     * @param {Object} contextProp - The property details from metadata.
+     * @param {Object} columnDataField - The line item column data field.
+     * @param {Object} metaModel - The metadata model object.
+     * @returns {string} The P13N string for the specified entity set and property.
+     * @private
+     */
+    createP13N(contextSet, contextProp, columnDataField, metaModel) {
+      let p13nDetails = "";
+      let additionalProperties = [];
+      let navigationPath = "";
+      let recordType = columnDataField?.RecordType;
+      let dataFieldValue = columnDataField?.Value;
+      let valuePath = dataFieldValue?.Path || "";
+      if (recordType === FieldAnnotationsType.DataField || recordType === FieldAnnotationsType.DataFieldForAnnotation || recordType === FieldAnnotationsType.DataFieldWithUrl) {
+        if (valuePath) {
+          let columnKey = this.createP13NColumnKey(columnDataField);
+          p13nDetails = '\\{"columnKey":"' + columnKey + '", "leadingProperty":"' + valuePath;
+          navigationPath = this.getNavigationPrefixPath(metaModel, contextSet, valuePath);
+        } else if (dataFieldValue?.Apply?.Name === "odata.concat") {
+          dataFieldValue?.Apply?.Parameters.forEach(function (parameterDetails) {
+            if (parameterDetails.Type === "Path") {
+              if (!p13nDetails) {
+                p13nDetails = '\\{"columnKey":"' + parameterDetails?.Value + '", "leadingProperty":"' + parameterDetails?.Value;
+              } else {
+                additionalProperties.push(parameterDetails.Value);
+              }
+            }
+          });
+        }
+        // Append type information and additional properties
+        p13nDetails += this.processAdditionalProperties(contextProp, columnDataField, navigationPath, additionalProperties);
+        if (recordType === FieldAnnotationsType.DataFieldWithUrl && columnDataField?.Url) {
+          this.processDataFieldWithUrl(columnDataField, additionalProperties);
+        }
+        if (p13nDetails && additionalProperties.length) {
+          p13nDetails += '", "additionalProperty":"' + additionalProperties.join();
+        }
+        if (p13nDetails) {
+          p13nDetails += '"\\}';
+        }
+      }
+      return p13nDetails;
+    }
+
+    //process DataFieldUrl properties and add them to additionalProperties
+    processDataFieldWithUrl(columnDataField, additionalProperties) {
+      const oDataFieldUrl = columnDataField.Url;
+      if (oDataFieldUrl?.Apply?.Parameters) {
+        oDataFieldUrl.Apply.Parameters.forEach(oParameter => {
+          if (oParameter.Type === "LabeledElement" && oParameter.Value?.Path) {
+            additionalProperties.push(oParameter.Value.Path);
+          }
+        });
+      }
+      if (oDataFieldUrl?.Path) {
+        additionalProperties.push(oDataFieldUrl.Path);
+      }
+    }
+
+    /**
+     * Creates a personalized column key based on the provided data field.
+     * @param {Object} oDataField - The data field object containing metadata for generating the column key.
+     * @returns {string} The generated column key based on the data field.
+     */
+    createP13NColumnKey(dataFieldColumn) {
+      let columnKeyName = "",
+        fioriTemplatePrefix = "template",
+        seperatorNotation = "::";
+      let recordType = dataFieldColumn.RecordType;
+      let dataFieldValue = dataFieldColumn?.Value;
+      let dataFieldSemanticObject = dataFieldColumn.SemanticObject?.String || "";
+      let dataFieldActionString = dataFieldColumn.Action?.String || "";
+      let dataFieldPath = dataFieldValue?.Path || "";
+      let annotationPath = "",
+        isRelevantAnnotation = null;
+      let buildKey = function (parts) {
+        return fioriTemplatePrefix + seperatorNotation + parts.join(seperatorNotation);
+      };
+      switch (recordType) {
+        case FieldAnnotationsType.DataField:
+          columnKeyName = dataFieldPath;
+          break;
+        case FieldAnnotationsType.DataFieldWithIntentBasedNavigation:
+          columnKeyName = buildKey([FieldTypes.DataFieldWithIntentBasedNavigation, dataFieldSemanticObject, dataFieldActionString, dataFieldPath]);
+          break;
+        case FieldAnnotationsType.DataFieldWithNavigationPath:
+          columnKeyName = buildKey([FieldTypes.DataFieldWithNavigationPath, dataFieldPath]);
+          break;
+        case FieldAnnotationsType.DataFieldForIntentBasedNavigation:
+          columnKeyName = buildKey([FieldTypes.DataFieldForIntentBasedNavigation, dataFieldSemanticObject, dataFieldActionString]);
+          break;
+        case FieldAnnotationsType.DataFieldForAction:
+          columnKeyName = buildKey([FieldTypes.DataFieldForAction, dataFieldActionString]);
+          break;
+        case FieldAnnotationsType.DataFieldForAnnotation:
+          annotationPath = dataFieldColumn.Target?.AnnotationPath;
+          isRelevantAnnotation = annotationPath && (annotationPath.indexOf(FieldAnnotationsType.Contact) >= 0 || annotationPath.indexOf(FieldAnnotationsType.DataPoint) >= 0 || annotationPath.indexOf(FieldAnnotationsType.FieldGroup) >= 0 || annotationPath.indexOf(FieldAnnotationsType.Chart) >= 0);
+          if (isRelevantAnnotation) {
+            columnKeyName = buildKey([FieldTypes.DataFieldForAnnotation, annotationPath]);
+            //since DataFieldForAnnotation can contain an @ and this is not working with SmartTable.prototype._addTablePersonalisationToToolbar, it is removed
+            columnKeyName = columnKeyName.replace("@", "");
+          }
+          break;
+        default:
+          // Handle cases where the RecordType does not match any of the known types
+          columnKeyName = "";
+          break;
+      }
+      return columnKeyName;
+    }
+
+    /**
+     * Retrieves the navigation prefix path for a given entity type and value path.
+     *
+     * @param {object} oMetaModel - The meta model object.
+     * @param {object} oContextSet - The context set object containing the entity type.
+     * @param {string} sPath - The value path for which the navigation prefix is needed.
+     * @returns {string} The navigation prefix path.
+     */
+    getNavigationPrefixPath(oMetaModel, oContextSet, sPath) {
+      let sNavigation = "";
+      if (oMetaModel) {
+        let oEntityType = oMetaModel.getODataEntityType(oContextSet.entityType);
+        if (oEntityType) {
+          sNavigation = this._getNavigationPrefix(oMetaModel, oEntityType, sPath);
+          if (sNavigation) {
+            sNavigation += "/";
+          }
+        }
+      }
+      return sNavigation;
+    }
+
+    /**
+     * Retrieves the navigation prefix for a given property within an entity type.
+     * @param {Object} metaModel - The metadata model object.
+     * @param {Object} entityTypeData - The entity type object.
+     * @param {string} propertyName - The property path for which the navigation prefix is to be determined.
+     * @returns {string} The navigation prefix for the specified property.
+     */
+    _getNavigationPrefix(metaModel, entityTypeData, propertyName) {
+      let expandName = "";
+      let propertyParts = propertyName.split("/");
+      if (propertyParts.length > 1) {
+        for (let i = 0; i < propertyParts.length - 1; i++) {
+          let associationEndData = metaModel.getODataAssociationEnd(entityTypeData, propertyParts[i]);
+          if (!associationEndData) {
+            return expandName;
+          }
+          if (associationEndData) {
+            entityTypeData = metaModel.getODataEntityType(associationEndData.type);
+            expandName += (expandName ? "/" : "") + propertyParts[i];
+          }
+        }
+      }
+      return expandName;
+    }
+
+    /**
+     * Processes additional properties for a given context property and data field.
+     *
+     * This method analyzes the provided context property and data field to extract additional properties
+     * such as criticality, text annotations, unit annotations, and field control paths. It also determines
+     * the type of the property (e.g., date, string) and appends this information to the P13N string.
+     *
+     * @param {UIAnnotationValue} oContextProp - The context property object containing metadata about the property.
+     * @param {ILineItemContext} oDataField - The data field object containing line item metadata.
+     * @param {string} sNavigationPath - The navigation path to be prefixed to certain properties.
+     * @param {string[]} aAdditionalProperties - An array to which additional property paths will be added.
+     * @returns {string} A P13N string containing additional property details such as type and unit.
+     * @private
+     */
+    processAdditionalProperties(oContextProp, oDataField, sNavigationPath, aAdditionalProperties) {
+      let additionalP13N = "";
+
+      // Check for DateTime type with specific display format
+      if (oContextProp?.type === "Edm.DateTime" && oContextProp?.["sap:display-format"] === "Date") {
+        additionalP13N += '", "type":"date';
+      } else if (oContextProp?.type === "Edm.String") {
+        additionalP13N += '", "type":"string';
+      }
+
+      // Add Criticality property if available
+      if (oDataField?.Criticality?.Path) {
+        aAdditionalProperties.push(oDataField?.Criticality.Path);
+      }
+      let oContextCommonText = oContextProp?.[UIAnnotations.CommonText];
+
+      // Add Text annotation property if available
+      if (oContextCommonText?.Path) {
+        aAdditionalProperties.push(sNavigationPath + oContextCommonText?.Path);
+      }
+
+      // Add Unit annotation property if available
+      const oUnitAnnotation = oContextProp ? oContextProp[UIAnnotations.MeasuresISOCurrency] || oContextProp[UIAnnotations.MeasuresUnit] : null;
+      if (oUnitAnnotation?.Path) {
+        aAdditionalProperties.push(oUnitAnnotation.Path);
+        additionalP13N += '", "unit":"' + oUnitAnnotation.Path;
+      }
+      // Add FieldControl property if available
+      if (oContextProp?.[UIAnnotations.CommonFieldControl]?.Path) {
+        aAdditionalProperties.push(sNavigationPath + oContextProp[UIAnnotations.CommonFieldControl].Path);
+      }
+      return additionalP13N;
+    }
+
+    /**
+     * Determines whether a column is supported for card creation.
+     *
+     * This method checks conditions to determine if a column is eligible for inclusion in a card,
+     * conditions are kept similar to RT cards restrictions in V2 LR.
+     *
+     * @param {Record<string, string>} columnDataObject - The column data object containing metadata about the column.
+     * @param {ILineItemContext} dataFieldDetails - The data field object containing line item metadata.
+     * @param {ODataMetaModel} metaModel - The OData meta model containing metadata about entities and properties.
+     * @param {IEntitySet} entitySetData - The entity set to which the column belongs.
+     * @returns {boolean} `true` if the column is supported for card creation, otherwise `false`.
+     * @private
+     */
+    isSupportedColumn(columnDataObject, dataFieldDetails, metaModel, entitySetData) {
+      let sRecordType = dataFieldDetails.RecordType;
+      if (sRecordType === FieldAnnotationsType.DataFieldForAnnotation || sRecordType === FieldAnnotationsType.DataFieldForAction || sRecordType === FieldAnnotationsType.DataFieldForIntentBasedNavigation || !columnDataObject) {
+        return false;
+      }
+      let entityType = metaModel.getODataEntityType(entitySetData.entityType);
+      let propertyDetails = metaModel.getODataProperty(entityType, columnDataObject.leadingProperty);
+      let columnKeyName = columnDataObject.columnKey;
+      if (this.checkMultiplicityForDataFieldAssociation(metaModel, entitySetData, dataFieldDetails) || columnKeyName && (columnKeyName.indexOf(FieldTypes.DataFieldForAnnotation) > -1 || columnKeyName.indexOf(FieldTypes.DataFieldForAction) > -1 || columnKeyName.indexOf(FieldTypes.DataFieldForIntentBasedNavigation) > -1 || propertyDetails?.[UIAnnotations.UIIsImageURL]?.Bool === "true")) {
+        return false;
+      }
+      return true;
+    }
+
+    /**
+     * Checks the multiplicity of a data field's association in the OData model.
+     *
+     * This method verifies whether the association for a given data field has a multiplicity of `*` (many).
+     * It traverses the navigation path of the data field to determine the multiplicity of the associated entity.
+     *
+     * @param {ODataMetaModel} metaModel - The OData meta model containing entity and association metadata.
+     * @param {IEntitySet} entitySetData - The entity set to which the data field belongs.
+     * @param {ILineItemContext} dataFieldValue - The data field whose association multiplicity is to be checked.
+     * @returns {boolean} `true` if the association has a multiplicity of `*`, otherwise `false`.
+     * @private
+     */
+    checkMultiplicityForDataFieldAssociation(metaModel, entitySetData, dataFieldValue) {
+      if (dataFieldValue?.Value?.Path) {
+        let dataFieldValuePath = dataFieldValue.Value.Path;
+        let entityTypeData = metaModel && metaModel.getODataEntityType(entitySetData.entityType);
+        let associationData;
+        if (!(dataFieldValuePath.indexOf("/") > -1) || !entityTypeData) {
+          return false;
+        }
+        while (dataFieldValuePath.indexOf("/") > -1) {
+          //if complex path exists then check for multiplicity
+          let navigationPropertyPath = dataFieldValuePath.split("/")[0];
+          dataFieldValuePath = dataFieldValuePath.split("/").slice(1).join("/");
+          entityTypeData = metaModel.getODataEntityType(associationData?.type) || entityTypeData;
+          associationData = metaModel.getODataAssociationEnd(entityTypeData, navigationPropertyPath);
+        }
+        if (associationData && associationData.multiplicity === "*") {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+  RecommendedCardUtil.FieldTypes = FieldTypes;
+  return RecommendedCardUtil;
+});
+//# sourceMappingURL=RecommendedCardUtil-dbg.js.map