@sap/cds-compiler 4.3.0 → 4.4.0

package/lib/edm/annotations/vocabularyDefinitions.js

@@ -0,0 +1,160 @@
+'use strict';
+
+/*
+   OASIS: https://github.com/oasis-tcs/odata-vocabularies/tree/master/vocabularies
+   Aggregation (published)
+   Authorization (published)
+   Capabilities (published)
+   Core (published)
+   JSON (published)
+   Measures (published)
+   Repeatability (published)
+   Temporal (published)
+   Validation (published)
+
+   SAP: https://github.com/SAP/odata-vocabularies/tree/master/vocabularies
+   Analytics (published)
+   CodeList (published)
+   Common (published)
+   Communication (published)
+   DataIntegration (published)
+   Graph (published, experimental)
+   Hierarchy (published, experimental)
+   HTML5 (published, experimental)
+   ODM (published, experimental)
+   Offline (experimental)
+   PDF (published)
+   PersonalData (published)
+   Session (published)
+   UI (published)
+*/
+
+const vocabularyDefinitions = {
+  Aggregation: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Aggregation.V1.xml' },
+    inc: { Alias: 'Aggregation', Namespace: 'Org.OData.Aggregation.V1' },
+    int: { filename: 'Aggregation.xml' },
+  },
+  Analytics: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Analytics.xml' },
+    inc: { Alias: 'Analytics', Namespace: 'com.sap.vocabularies.Analytics.v1' },
+    int: { filename: 'Analytics.xml' },
+  },
+  Authorization: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Authorization.V1.xml' },
+    inc: { Alias: 'Authorization', Namespace: 'Org.OData.Authorization.V1' },
+    int: { filename: 'Authorization.xml' },
+  },
+  Capabilities: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Capabilities.V1.xml' },
+    inc: { Alias: 'Capabilities', Namespace: 'Org.OData.Capabilities.V1' },
+    int: { filename: 'Capabilities.xml' },
+  },
+  CodeList: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/CodeList.xml' },
+    inc: { Alias: 'CodeList', Namespace: 'com.sap.vocabularies.CodeList.v1' },
+    int: { filename: 'CodeList.xml' },
+  },
+  Common: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Common.xml' },
+    inc: { Alias: 'Common', Namespace: 'com.sap.vocabularies.Common.v1' },
+    int: { filename: 'Common.xml' },
+  },
+  Communication: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Communication.xml' },
+    inc: { Alias: 'Communication', Namespace: 'com.sap.vocabularies.Communication.v1' },
+    int: { filename: 'Communication.xml' },
+  },
+  Core: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Core.V1.xml' },
+    inc: { Alias: 'Core', Namespace: 'Org.OData.Core.V1' },
+    int: { filename: 'Core.xml' },
+  },
+  DataIntegration: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/DataIntegration.xml' },
+    inc: { Alias: 'DataIntegration', Namespace: 'com.sap.vocabularies.DataIntegration.v1' },
+    int: { filename: 'DataIntegration.xml' },
+  },
+  Graph: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Graph.xml' },
+    inc: { Alias: 'Graph', Namespace: 'com.sap.vocabularies.Graph.v1' },
+    int: { filename: 'Graph.xml' },
+  },
+  Hierarchy: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Hierarchy.xml' },
+    inc: { Alias: 'Hierarchy', Namespace: 'com.sap.vocabularies.Hierarchy.v1' },
+    int: { filename: 'Hierarchy.xml' },
+  },
+  HTML5: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/HTML5.xml' },
+    inc: { Alias: 'HTML5', Namespace: 'com.sap.vocabularies.HTML5.v1' },
+    int: { filename: 'HTML5.xml' },
+  },
+  JSON: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.JSON.V1.xml' },
+    inc: { Alias: 'JSON', Namespace: 'Org.OData.JSON.V1' },
+    int: { filename: 'JSON.xml' },
+  },
+  Measures: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Measures.V1.xml' },
+    inc: { Alias: 'Measures', Namespace: 'Org.OData.Measures.V1' },
+    int: { filename: 'Measures.xml' },
+  },
+  ODM: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/ODM.xml' },
+    inc: { Alias: 'ODM', Namespace: 'com.sap.vocabularies.ODM.v1' },
+    int: { filename: 'ODM.xml' },
+  },
+  Offline: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Offline.xml' },
+    inc: { Alias: 'Offline', Namespace: 'com.sap.vocabularies.Offline.v1' },
+    int: { filename: 'Offline.xml' },
+  },
+  PDF: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/PDF.xml' },
+    inc: { Alias: 'PDF', Namespace: 'com.sap.vocabularies.PDF.v1' },
+    int: { filename: 'PDF.xml' },
+  },
+  PersonalData: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/PersonalData.xml' },
+    inc: { Alias: 'PersonalData', Namespace: 'com.sap.vocabularies.PersonalData.v1' },
+    int: { filename: 'PersonalData.xml' },
+  },
+  Repeatability: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Repeatability.V1.xml' },
+    inc: { Alias: 'Repeatability', Namespace: 'Org.OData.Repeatability.V1' },
+    int: { filename: 'Repeatability.xml' },
+  },
+  Session: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Session.xml' },
+    inc: { Alias: 'Session', Namespace: 'com.sap.vocabularies.Session.v1' },
+    int: { filename: 'Session.xml' },
+  },
+  UI: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/UI.xml' },
+    inc: { Alias: 'UI', Namespace: 'com.sap.vocabularies.UI.v1' },
+    int: { filename: 'UI.xml' },
+  },
+  Validation: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Validation.V1.xml' },
+    inc: { Alias: 'Validation', Namespace: 'Org.OData.Validation.V1' },
+    int: { filename: 'Validation.xml' },
+  },
+  /* unvalidated vocabularies below here:
+     A vocabulary is unvalidated if it doesn't have an int.filename property as this indicates that
+     the vocabulary is added to the validation dictionary
+     Example:
+  'Org.Snafu.V1': {
+    'ref': { Uri: 'https://snafu.org/snafu.xml' },
+    'inc': { Alias: 'Snafu', Namespace: 'Org.Snafu.V1' },
+  },
+  */
+};
+
+/* create inverted voc definitions list to allow addressing full qualified vocabularies
+Object.entries(vocabularyDefinitions).forEach(([n, v]) => {
+  if(!vocabularyDefinitions[v.inc.Namespace])
+    vocabularyDefinitions[v.inc.Namespace] = vocabularyDefinitions[n];
+});
+*/
+module.exports = { vocabularyDefinitions };

package/lib/edm/csn2edm.js

@@ -10,12 +10,17 @@ const edmUtils = require('./edmUtils.js');
 const { initializeModel } = require('./edmPreprocessor.js');
 const translate = require('./annotations/genericTranslation.js');
 const { setProp, isBetaEnabled } = require('../base/model');
-const { cloneCsnNonDict, isEdmPropertyRendered, isBuiltinType } = require('../model/csnUtils');
+const {
+  cloneCsnNonDict, isEdmPropertyRendered, isBuiltinType, getUtils,
+} = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { makeMessageFunction } = require('../base/messages');
 const {
-  EdmTypeFacetMap, EdmTypeFacetNames, EdmPrimitiveTypeMap, getEdm,
-} = require('./edm.js');
+  EdmTypeFacetMap,
+  EdmTypeFacetNames,
+  EdmPrimitiveTypeMap,
+} = require('./EdmPrimitiveTypeDefinitions.js');
+const { getEdm } = require('./edm.js');
 
 /*
 OData V2 spec 06/01/2017 PDF version is available from here:
@@ -749,7 +754,7 @@ function csn2edmAll( _csn, _options, serviceNames = undefined ) {
           const rt = actionCsn.returns && ((actionCsn.returns.items && actionCsn.returns.items.type) || actionCsn.returns.type);
           if (rt) { // add EntitySet attribute only if return type is a non abstract entity
             const definition = schemaCsn.definitions[rt];
-            if (definition && definition.kind === 'entity' && !definition.abstract)
+            if (definition && definition.kind === 'entity' && !definition.abstract && !edmUtils.isSingleton(definition))
               actionImport.setEdmAttribute('EntitySet', edmUtils.getBaseName(rt));
           }
           EntityContainer.register(actionImport);
@@ -1046,6 +1051,8 @@ function csn2edmAll( _csn, _options, serviceNames = undefined ) {
 
     // generate the Edm.Annotations tree and append it to the corresponding schema
     function addAnnotations2XServiceRefs( ) {
+      const { getFinalTypeInfo } = getUtils(csn);
+      options.getFinalTypeInfo = getFinalTypeInfo;
       const { annos, usedVocabularies, xrefs } = translate.csn2annotationEdm(reqDefs, csn.vocabularies, serviceCsn.name, Edm, options, messageFunctions, mergedVocabularies);
       // distribute edm:Annotations into the schemas
       // Distribute each anno into Schema
@@ -1114,7 +1121,7 @@ function csn2edmAll( _csn, _options, serviceNames = undefined ) {
             if (!Number.isNaN(precision) && !Number.isNaN(scale) && scale > precision) {
               message('odata-spec-violation-type', pLoc,
                       {
-                        type: edmType, number: scale, rawvalue: precision, ersion: (p.v4 ? '4.0' : '2.0'), '#': 'scale',
+                        type: edmType, number: scale, rawvalue: precision, '#': 'scale',
                       });
             }
           }

package/lib/edm/edm.js

@@ -3,74 +3,11 @@
 const edmUtils = require('./edmUtils.js');
 const { isBuiltinType } = require('../model/csnUtils.js');
 const { forEach } = require('../utils/objectUtils');
-
-// facet definitions, optional could either be true or array of edm types
-// remove indicates wether or not the canonic facet shall be removed when applying @odata.Type
-const EdmTypeFacetMap = {
-  MaxLength: {
-    v2: true, v4: true, remove: true, optional: true,
-  },
-  Precision: {
-    v2: true, v4: true, remove: true, optional: true,
-  },
-  Scale: {
-    v2: true, v4: true, remove: true, optional: true, extra: 'sap:variable-scale',
-  },
-  SRID: { v4: true, remove: true, optional: true },
-  // 'FixedLength': { v2: true },
-  // 'Collation': { v2: true },
-  // 'Unicode': { v2: true, v4: true },
-};
-const EdmTypeFacetNames = Object.keys(EdmTypeFacetMap);
-
-// Merged primitive type map with descriptions taken from V4 spec and filled up with V2 spec
-const EdmPrimitiveTypeMap = {
-  'Edm.Binary': {
-    v2: true, v4: true, MaxLength: true, FixedLength: true, desc: 'Binary data',
-  },
-  'Edm.Boolean': { v2: true, v4: true, desc: 'Binary-valued logic' },
-  'Edm.Byte': { v2: true, v4: true, desc: 'Unsigned 8-bit integer' },
-  'Edm.Date': { v4: true, desc: 'Date without a time-zone offset' },
-  'Edm.DateTime': { v2: true, Precision: true, desc: 'Date and time with values ranging from 12:00:00 midnight, January 1, 1753 A.D. through 11:59:59 P.M, December 31, 9999 A.D.' },
-  'Edm.DateTimeOffset': {
-    v2: true, v4: true, Precision: true, desc: 'Date and time with a time-zone offset, no leap seconds',
-  },
-  'Edm.Decimal': {
-    v2: true, v4: true, Precision: true, Scale: true, desc: 'Numeric values with decimal representation',
-  },
-  'Edm.Double': { v2: true, v4: true, desc: 'IEEE 754 binary64 floating-point number (15-17 decimal digits)' },
-  'Edm.Duration': { v4: true, Precision: true, desc: 'Signed duration in days, hours, minutes, and (sub)seconds' },
-  'Edm.Guid': { v2: true, v4: true, desc: '16-byte (128-bit) unique identifier' },
-  'Edm.Int16': { v2: true, v4: true, desc: 'Signed 16-bit integer' },
-  'Edm.Int32': { v2: true, v4: true, desc: 'Signed 32-bit integer' },
-  'Edm.Int64': { v2: true, v4: true, desc: 'Signed 64-bit integer' },
-  'Edm.SByte': { v2: true, v4: true, desc: 'Signed 8-bit integer' },
-  'Edm.Single': { v2: true, v4: true, desc: 'IEEE 754 binary32 floating-point number (6-9 decimal digits)' },
-  'Edm.Stream': { v4: true, MaxLength: true, desc: 'Binary data stream' },
-  'Edm.String': {
-    v2: true, v4: true, MaxLength: true, FixedLength: true, Collation: true, Unicode: true, desc: 'Sequence of characters',
-  },
-  'Edm.Time': { v2: true, Precision: true, desc: 'time of day with values ranging from 0:00:00.x to 23:59:59.y, where x and y depend upon the precision' },
-  'Edm.TimeOfDay': { v4: true, Precision: true, desc: 'Clock time 00:00-23:59:59.999999999999' },
-  'Edm.Geography': { v4: true, SRID: true, desc: 'Abstract base type for all Geography types' },
-  'Edm.GeographyPoint': { v4: true, SRID: true, desc: 'A point in a round-earth coordinate system' },
-  'Edm.GeographyLineString': { v4: true, SRID: true, desc: 'Line string in a round-earth coordinate system' },
-  'Edm.GeographyPolygon': { v4: true, SRID: true, desc: 'Polygon in a round-earth coordinate system' },
-  'Edm.GeographyMultiPoint': { v4: true, SRID: true, desc: 'Collection of points in a round-earth coordinate system' },
-  'Edm.GeographyMultiLineString': { v4: true, SRID: true, desc: 'Collection of line strings in a round-earth coordinate system' },
-  'Edm.GeographyMultiPolygon': { v4: true, SRID: true, desc: 'Collection of polygons in a round-earth coordinate system' },
-  'Edm.GeographyCollection': { v4: true, SRID: true, desc: 'Collection of arbitrary Geography values' },
-  'Edm.Geometry': { v4: true, SRID: true, desc: 'Abstract base type for all Geometry types' },
-  'Edm.GeometryPoint': { v4: true, SRID: true, desc: 'Point in a flat-earth coordinate system' },
-  'Edm.GeometryLineString': { v4: true, SRID: true, desc: 'Line string in a flat-earth coordinate system' },
-  'Edm.GeometryPolygon': { v4: true, SRID: true, descr: 'Polygon in a flat-earth coordinate system' },
-  'Edm.GeometryMultiPoint': { v4: true, SRID: true, desc: 'Collection of points in a flat-earth coordinate system' },
-  'Edm.GeometryMultiLineString': { v4: true, SRID: true, desc: 'Collection of line strings in a flat-earth coordinate system' },
-  'Edm.GeometryMultiPolygon': { v4: true, SRID: true, desc: 'Collection of polygons in a flat-earth coordinate system' },
-  'Edm.GeometryCollection': { v4: true, SRID: true, desc: 'Collection of arbitrary Geometry values' },
-  'Edm.PrimitiveType': { v4: true, desc: 'Abstract meta type' },
-  // 'Edm.Untyped': { v4: true, desc: 'Abstract void type' },
-};
+const {
+  EdmTypeFacetMap,
+  EdmTypeFacetNames,
+  EdmPrimitiveTypeMap,
+} = require('./EdmPrimitiveTypeDefinitions.js');
 
 function getEdm( options, messageFunctions ) {
   const { error } = messageFunctions || { error: () => true, warning: () => true };
@@ -1444,10 +1381,14 @@ function getEdm( options, messageFunctions ) {
   }
   class Cast extends AnnotationBase {
     toXMLattributes() {
-      // TODO: Why json?
-      if (this._jsonOnlyAttributes.Collection)
-        return ` Type="Collection(${this._edmAttributes.Type})"`;
-      return ` Type="${this._edmAttributes.Type}"`;
+      if (this._jsonOnlyAttributes.Collection) {
+        const ot = this._edmAttributes.Type;
+        this._edmAttributes.Type = `Collection(${ot})`;
+        const str = super.toXMLattributes();
+        this._edmAttributes.Type = ot;
+        return str;
+      }
+      return super.toXMLattributes();
     }
     toJSON() {
       const json = this.mergeJSONAnnotations();
@@ -1627,5 +1568,5 @@ function getEdm( options, messageFunctions ) {
 } // instance function
 
 module.exports = {
-  EdmTypeFacetMap, EdmTypeFacetNames, EdmPrimitiveTypeMap, getEdm,
+  getEdm,
 };

package/lib/edm/edmPreprocessor.js

@@ -168,6 +168,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         initEdmNavPropBindingTargets,
         pullupCapabilitiesAnnotations,
         annotateOptionalActFuncParams,
+        openService,
       ]);
     }
 
@@ -2133,6 +2134,11 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     }
   }
 
+  function openService( def ) {
+    if (options.odataOpenType && !def.$isParamEntity && !def.$proxy)
+      edmUtils.assignAnnotation(def, '@open', true);
+  }
+
   // ////////////////////////////////////////////////////////////////////
   //
   // Helper section starts here

package/lib/gen/Dictionary.json

@@ -58,14 +58,18 @@
     "Aggregation.RecursiveHierarchy": {
       "Type": "Aggregation.RecursiveHierarchyType",
       "AppliesTo": [
-        "EntityType",
-        "ComplexType"
+        "EntityType"
+      ]
+    },
+    "Aggregation.UpPath": {
+      "Type": "Collection(Edm.String)",
+      "AppliesTo": [
+        "EntityType"
       ]
     },
     "Aggregation.AvailableOnAggregates": {
       "Type": "Aggregation.AvailableOnAggregatesType",
       "AppliesTo": [
-        "Action",
         "Function"
       ]
     },
@@ -1399,6 +1403,13 @@
     "Core.GeometryFeature": {
       "Type": "Core.GeometryFeatureType"
     },
+    "Core.AnyStructure": {
+      "Type": "Core.Tag",
+      "AppliesTo": [
+        "EntityType",
+        "ComplexType"
+      ]
+    },
     "DataIntegration.Extractable": {
       "Type": "Edm.Boolean",
       "AppliesTo": [
@@ -1454,6 +1465,27 @@
       ],
       "$experimental": true
     },
+    "Hierarchy.RecursiveHierarchyActions": {
+      "Type": "Hierarchy.RecursiveHierarchyActionsType",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
+    "Hierarchy.MatchCount": {
+      "Type": "Edm.Int64",
+      "AppliesTo": [
+        "Collection"
+      ],
+      "$experimental": true
+    },
+    "Hierarchy.RecursiveHierarchySupported": {
+      "Type": "Core.Tag",
+      "AppliesTo": [
+        "Collection"
+      ],
+      "$experimental": true
+    },
     "HTML5.CssDefaults": {
       "Type": "HTML5.CssDefaultsType",
       "AppliesTo": [
@@ -1537,6 +1569,13 @@
         "EntityType"
       ]
     },
+    "ODM.oidReference": {
+      "Type": "ODM.oidReferenceType",
+      "AppliesTo": [
+        "Property"
+      ],
+      "$experimental": true
+    },
     "Offline.ClientOnly": {
       "Type": "Offline.ClientOnlyType",
       "AppliesTo": [
@@ -2087,9 +2126,10 @@
     "Aggregation.ApplySupportedBase": {
       "$kind": "ComplexType",
       "Properties": {
-        "Transformations": "Collection(Edm.String)",
+        "Transformations": "Collection(Aggregation.Transformation)",
         "CustomAggregationMethods": "Collection(Edm.String)",
-        "Rollup": "Aggregation.RollupType"
+        "Rollup": "Aggregation.RollupType",
+        "From": "Edm.Boolean"
       }
     },
     "Aggregation.ApplySupportedType": {
@@ -2097,11 +2137,12 @@
       "BaseType": "Aggregation.ApplySupportedBase",
       "Properties": {
         "PropertyRestrictions": "Edm.Boolean",
-        "GroupableProperties": "Collection(Edm.PropertyPath)",
+        "GroupableProperties": "Collection(Edm.AnyPropertyPath)",
         "AggregatableProperties": "Collection(Aggregation.AggregatablePropertyType)",
-        "Transformations": "Collection(Edm.String)",
+        "Transformations": "Collection(Aggregation.Transformation)",
         "CustomAggregationMethods": "Collection(Edm.String)",
-        "Rollup": "Aggregation.RollupType"
+        "Rollup": "Aggregation.RollupType",
+        "From": "Edm.Boolean"
       }
     },
     "Aggregation.AggregatablePropertyType": {
@@ -2116,9 +2157,7 @@
       "$kind": "ComplexType",
       "Properties": {
         "NodeProperty": "Edm.PropertyPath",
-        "ParentNavigationProperty": "Edm.NavigationPropertyPath",
-        "DistanceFromRootProperty": "Edm.PropertyPath",
-        "IsLeafProperty": "Edm.PropertyPath"
+        "ParentNavigationProperty": "Edm.NavigationPropertyPath"
       }
     },
     "Aggregation.AvailableOnAggregatesType": {
@@ -2163,6 +2202,107 @@
       "$deprecated": true,
       "$deprecationText": "Deprecated since [`NavigationPropertyAggregationCapabilities`](#NavigationPropertyAggregationCapabilities) is also deprecated"
     },
+    "Aggregation.Transformation": {
+      "$kind": "TypeDefinition",
+      "UnderlyingType": "Edm.String",
+      "$Allowed": {
+        "Values": {
+          "aggregate": {
+            "Value": "aggregate",
+            "Type": "String"
+          },
+          "groupby": {
+            "Value": "groupby",
+            "Type": "String"
+          },
+          "concat": {
+            "Value": "concat",
+            "Type": "String"
+          },
+          "identity": {
+            "Value": "identity",
+            "Type": "String"
+          },
+          "filter": {
+            "Value": "filter",
+            "Type": "String"
+          },
+          "search": {
+            "Value": "search",
+            "Type": "String"
+          },
+          "nest": {
+            "Value": "nest",
+            "Type": "String"
+          },
+          "addnested": {
+            "Value": "addnested",
+            "Type": "String"
+          },
+          "join": {
+            "Value": "join",
+            "Type": "String"
+          },
+          "outerjoin": {
+            "Value": "outerjoin",
+            "Type": "String"
+          },
+          "compute": {
+            "Value": "compute",
+            "Type": "String"
+          },
+          "bottomcount": {
+            "Value": "bottomcount",
+            "Type": "String"
+          },
+          "bottomsum": {
+            "Value": "bottomsum",
+            "Type": "String"
+          },
+          "bottompercent": {
+            "Value": "bottompercent",
+            "Type": "String"
+          },
+          "topcount": {
+            "Value": "topcount",
+            "Type": "String"
+          },
+          "topsum": {
+            "Value": "topsum",
+            "Type": "String"
+          },
+          "toppercent": {
+            "Value": "toppercent",
+            "Type": "String"
+          },
+          "orderby": {
+            "Value": "orderby",
+            "Type": "String"
+          },
+          "top": {
+            "Value": "top",
+            "Type": "String"
+          },
+          "skip": {
+            "Value": "skip",
+            "Type": "String"
+          },
+          "ancestors": {
+            "Value": "ancestors",
+            "Type": "String"
+          },
+          "descendants": {
+            "Value": "descendants",
+            "Type": "String"
+          },
+          "traverse": {
+            "Value": "traverse",
+            "Type": "String"
+          }
+        },
+        "Symbols": {}
+      }
+    },
     "Aggregation.AggregationMethod": {
       "$kind": "TypeDefinition",
       "UnderlyingType": "Edm.String",
@@ -2192,6 +2332,10 @@
         "Symbols": {}
       }
     },
+    "Aggregation.HierarchyQualifier": {
+      "$kind": "TypeDefinition",
+      "UnderlyingType": "Edm.String"
+    },
     "Aggregation.RollupType": {
       "$kind": "EnumType",
       "Members": [
@@ -3422,11 +3566,32 @@
     "Hierarchy.RecursiveHierarchyType": {
       "$kind": "ComplexType",
       "Properties": {
-        "ExternalKeyProperty": "Edm.PropertyPath",
-        "DescendantCountProperty": "Edm.PropertyPath",
-        "DrillStateProperty": "Edm.PropertyPath",
-        "SiblingRankProperty": "Edm.PropertyPath",
-        "PreorderRankProperty": "Edm.PropertyPath"
+        "ExternalKey": "Edm.String",
+        "NodeType": "Edm.String",
+        "ChildCount": "Edm.Int64",
+        "DescendantCount": "Edm.Int64",
+        "LimitedDescendantCount": "Edm.Int64",
+        "DrillState": "Edm.String",
+        "DistanceFromRoot": "Edm.Int64",
+        "LimitedRank": "Edm.Int64",
+        "SiblingRank": "Edm.Int64",
+        "Matched": "Edm.Boolean",
+        "MatchedDescendantCount": "Edm.Int64"
+      },
+      "$experimental": true
+    },
+    "Hierarchy.RecursiveHierarchyActionsType": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "ChangeNextSiblingAction": "Common.QualifiedName",
+        "CopyAction": "Common.QualifiedName"
+      }
+    },
+    "Hierarchy.TopLevelsExpandType": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "NodeID": "Edm.String",
+        "Levels": "Edm.Int64"
       },
       "$experimental": true
     },
@@ -3486,6 +3651,12 @@
         "Symbols": {}
       }
     },
+    "ODM.oidReferenceType": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "entityName": "Edm.String"
+      }
+    },
     "Offline.ClientOnlyType": {
       "$kind": "ComplexType",
       "Properties": {},

package/lib/gen/language.checksum

@@ -1 +1 @@
-462a4274cec75ca772064210a7421aec
+582fa96ad61075beb0b9f9f8c46f11f3