@sap/cds-compiler 4.8.0 → 4.9.0

package/lib/edm/annotations/genericTranslation.js

@@ -102,7 +102,9 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     // qualified with #$parameters or if its applicable to an EntitySet or Singleton
     const scopeCheck = {
       ref: (elemref, prop, xpr, path) => {
-        if (scopeCheck.scope === 'param' && (!elemref.param || (xpr[0].id || xpr[0]) === '$self')) {
+        if (scopeCheck.scope === 'param' &&
+          (!elemref.param ||
+           (xpr[0].id || xpr[0]) === '$self' && !def.elements.$self)) {
           error('odata-anno-xpr-ref', path, { anno: scopeCheck.anno, elemref, '#': 'notaparam' });
           // don't try to resolve those paths later on
           delete elemref[prop];
@@ -111,9 +113,13 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           error('odata-anno-xpr-ref', path, { anno: scopeCheck.anno, elemref, '#': 'notaneelement' });
           delete elemref[prop];
         }
-        if (scopeCheck.scope === 'param' && elemref.param)
+        if (scopeCheck.scope === 'param' && elemref.param) {
           // make sure that path is resolvable as element path later on
           delete elemref.param;
+          const head = xpr[0].id || xpr[0];
+          if (head[0] === '$')
+            xpr.unshift('$self');
+        }
       },
     };
     const checkDict = (dict, scope) => {
@@ -156,7 +162,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
             const steps = prefix.replace(`@${ns}.`, '').split('.');
             const paramAnnoParts = steps[0].split('#$parameters');
             const dictTerm = getDictTerm(`${ns}.${paramAnnoParts[0]}`, options);
-            if (paramAnnoParts.length > 1 || [ 'Singleton', 'EntitySet' ].some(y => dictTerm?.AppliesTo?.includes(y))) {
+            if (paramAnnoParts.length > 1 ||
+                [ 'Singleton', 'EntitySet' ].some(y => dictTerm?.AppliesTo?.includes(y))) {
               steps[0] = `@${ns}.${paramAnnoParts.join('')}`;
               let newAnno = steps.join('.');
               if (innerAnnotation)
@@ -185,12 +192,14 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   There is one exception (Schema), see below
 
   carrier = service
-    the target is the EntityContainer, unless the annotation has an "AppliesTo" where only Schema is given, but not EntityContainer
-    then the <Annotation ...> is directly put into <Schema ...> without an enclosing <Annotations ...>
+    the target is the EntityContainer, unless the annotation has an "AppliesTo"
+    where only Schema is given, but not EntityContainer then the <Annotation ...>
+    is directly put into <Schema ...> without an enclosing <Annotations ...>
 
   carrier = entity (incl. view/projection)
-    the target is the corresponding EntityType, unless the annotation has an "AppliesTo" where only EntitySet is given, but not EntityType
-    then the target is the corresponding EntitySet
+    the target is the corresponding EntityType, unless the annotation has an
+    "AppliesTo" where only EntitySet is given, but not EntityType then the target
+    is the corresponding EntitySet
 
   carrier = structured type
     the target is the corresponding ComplexType
@@ -217,7 +226,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     if (def.$elementsAnnoProxies) {
       Object.entries(def.$elementsAnnoProxies).forEach(([ elemPath, element ]) => {
         const edmTargetName = `${defName}/${elemPath}`;
-        handleAnnotations(edmTargetName, element, element.$path, [ ...location, '$elementsAnnoProxies', elemPath ]);
+        handleAnnotations(edmTargetName, element, element.$path,
+                          [ ...location, '$elementsAnnoProxies', elemPath ]);
       });
     }
     // element bound annotations
@@ -278,24 +288,28 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       if (cAction.$paramsAnnoProxies) {
         Object.entries(cAction.$paramsAnnoProxies).forEach(([ paramPath, param ]) => {
           const edmTargetName = `${actionName}/${paramPath}`;
-          handleAnnotations(edmTargetName, param, param.$path, [ ...location, '$paramsAnnoProxies', paramPath ]);
+          handleAnnotations(edmTargetName, param, param.$path,
+                            [ ...location, '$paramsAnnoProxies', paramPath ]);
         });
       }
       Object.entries(cAction.params).forEach(([ n, p ]) => {
         const edmTargetName = `${actionName}/${n}`;
-        handleAnnotations(edmTargetName, p, [ ...location, 'params', n ]);
+        handleAnnotations(edmTargetName, p,
+                          [ ...location, 'params', n ]);
       });
     }
     if (cAction.returns) {
       if (cAction.$returnsAnnoProxies) {
         Object.entries(cAction.$returnsAnnoProxies).forEach(([ returnsPath, returns ]) => {
           const edmTargetName = `${actionName}/${returnsPath}`;
-          handleAnnotations(edmTargetName, returns, returns.$path, [ ...location, '$returnsAnnoProxies', returnsPath ]);
+          handleAnnotations(edmTargetName, returns, returns.$path,
+                            [ ...location, '$returnsAnnoProxies', returnsPath ]);
         });
       }
       const edmTargetName = `${actionName}/$ReturnType`;
       setProp(cAction.returns, '$appliesToReturnType', true);
-      handleAnnotations(edmTargetName, cAction.returns, [ ...location, 'returns' ]);
+      handleAnnotations(edmTargetName, cAction.returns,
+                        [ ...location, 'returns' ]);
       delete cAction.returns.$appliesToReturnType;
     }
 
@@ -304,12 +318,19 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       const params = [];
       if (entityNameIfBound) {
         // If this is an action and has an explicit binding parameter add it here
-        if (cAction.$bindingParam && cAction.kind === 'action')
-          params.push(cAction.$bindingParam.items ? `Collection(${entityNameIfBound})` : entityNameIfBound);
-
+        if (cAction.$bindingParam && cAction.kind === 'action') {
+          params.push(
+            cAction.$bindingParam.items
+              ? `Collection(${entityNameIfBound})`
+              : entityNameIfBound
+          );
+        }
         // If action/function has no explicit binding parameter add it here
-        else if (!cAction.$bindingParam)
-          params.push(cAction['@cds.odata.bindingparameter.collection'] ? `Collection(${entityNameIfBound})` : entityNameIfBound);
+        else if (!cAction.$bindingParam) {
+          params.push(cAction['@cds.odata.bindingparameter.collection']
+            ? `Collection(${entityNameIfBound})`
+            : entityNameIfBound);
+        }
       }
       // In case this is a function the explicit binding parameter is part of
       // the functions params dictionary. Only for functions all parameters must
@@ -369,50 +390,49 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       if (knownAnnos.length === 0)
         return;
     }
-    if (isBetaEnabled(options, 'odataAnnotationExpressions')) {
-      knownAnnos.forEach((knownAnno) => {
-        if (knownAnno.search(/\.\$edmJson\./g) < 0) {
-          if (isBetaEnabled(options, 'odataPathsInAnnotationExpressions')) {
-            transformExpression(carrier, knownAnno, {
-              ref: (elemref, prop, xpr, csnPath) => {
-                const { links, scope } = reqDefsUtils.inspectRef(csnPath);
-                let i = scope === '$self' ? 1 : 0;
-                const getProp = propName => (links[i].art ? (links[i].art[propName] || reqDefsUtils.effectiveType(links[i].art)[propName]) : undefined);
-                if (scope === '$magic')
-                  return;
-                let stop = false;
-                for (; i < links.length && !stop; i++) {
-                  const cardinality = getProp('cardinality');
-                  if ((cardinality && cardinality.max !== 1) || getProp('items')) {
-                    error('odata-anno-xpr-ref', location, {
-                      count: i + 1, elemref, anno: knownAnno, '#': 'tomany',
-                    });
-                    stop = true;
-                  }
-                  if (!isEdmPropertyRendered(links[i].art, csnPath)) {
-                    error('odata-anno-xpr-ref', location, {
-                      count: i + 1, elemref, anno: knownAnno, '#': 'notrendered',
-                    });
-                    stop = true;
-                  }
-                  if (links[i].art?._target?.$proxy && i < links.length - 1) {
-                    const proxy = links[i].art?._target;
-                    const eltName = links[i + 1].art?.name;
-                    if (!proxy.elements[eltName]) {
-                      error('odata-anno-xpr-ref', location, {
-                        count: i + 2, elemref, anno: knownAnno, '#': 'notrendered',
-                      });
-                      stop = true;
-                    }
-                  }
+
+    knownAnnos.forEach((knownAnno) => {
+      if (knownAnno.search(/\.\$edmJson\./g) < 0) {
+        transformExpression(carrier, knownAnno, {
+          ref: (elemref, prop, xpr, csnPath) => {
+            if (options.isV2() && elemref.$bparam) {
+              error('odata-anno-xpr-ref', location, {
+                elemref, anno: knownAnno, version: '2.0', '#': 'bparam_v2',
+              });
+              return;
+            }
+            const { links, scope } = reqDefsUtils.inspectRef(csnPath);
+            let i = scope === '$self' ? 1 : 0;
+            if (scope === '$magic') {
+              error('odata-anno-xpr-ref', location, {
+                elemref, anno: knownAnno, '#': 'magic',
+              });
+              return;
+            }
+            let stop = false;
+            for (; i < links.length && !stop; i++) {
+              if (!isEdmPropertyRendered(links[i].art, csnPath)) {
+                error('odata-anno-xpr-ref', location, {
+                  count: i + 1, elemref, anno: knownAnno, '#': 'notrendered',
+                });
+                stop = true;
+              }
+              if (links[i].art?._target?.$proxy && i < links.length - 1) {
+                const proxy = links[i].art?._target;
+                const eltName = links[i + 1].art?.name;
+                if (!proxy.elements[eltName]) {
+                  error('odata-anno-xpr-ref', location, {
+                    count: i + 2, elemref, anno: knownAnno, '#': 'notrendered',
+                  });
+                  stop = true;
                 }
-              },
-            }, csnPathResolutionLocation);
-          }
-          xpr2edmJson(carrier, knownAnno, location, options, messageFunctions);
-        }
-      });
-    }
+              }
+            }
+          },
+        }, csnPathResolutionLocation);
+        xpr2edmJson(carrier, knownAnno, location, options, messageFunctions);
+      }
+    });
 
     const prefixTree = createPrefixTree();
 

package/lib/edm/edm.js

@@ -19,11 +19,11 @@ function getEdm( options, messageFunctions ) {
      */
     constructor(version, attributes = Object.create(null), csn = undefined) {
       if (!attributes || typeof attributes !== 'object')
-        error(null, 'Please debug me: attributes must be a dictionary');
+        error(null, 'Debug me: attributes must be a dictionary');
       if (!Array.isArray(version))
-        error(null, `Please debug me: v is either undefined or not an array: ${version}`);
+        error(null, `Debug me: v is either undefined or not an array: ${version}`);
       if (version.filter(v => v).length !== 1)
-        error(null, 'Please debug me: exactly one version must be set');
+        error(null, 'Debug me: exactly one version must be set');
 
       // Common attributes of JSON and XML.
       // Note: Can't assign attributes directly, due to the input object being modified.
@@ -1108,7 +1108,7 @@ function getEdm( options, messageFunctions ) {
             json.$OnDelete = c._edmAttributes.Action;
             break;
           default:
-            error(null, `Please debug me: Unhandled NavProp child: ${c.kind}`);
+            error(null, `Debug me: Unhandled NavProp child: ${c.kind}`);
         }
       });
       // TODO Annotations

package/lib/edm/edmInboundChecks.js

@@ -3,6 +3,7 @@
 const { setProp, isBetaEnabled } = require('../base/model');
 const {
   forEachDefinition, forEachMemberRecursively, getUtils,
+  transformExpression, findAnnotationExpression,
 } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const { assignAnnotation } = require('./edmUtils.js');
@@ -55,8 +56,10 @@ function inboundQualificationChecks( csn, options, messageFunctions,
       Object.entries(def.actions).forEach(([ n, action ]) => {
         const aLoc = location.concat('actions', n);
         checkIfItemsOfItems(action, undefined, undefined, aLoc);
+        markBindingParamPaths(action, aLoc);
         forEachMemberRecursively(action, checkIfItemsOfItems, aLoc);
         checkIfItemsOfItems(action.returns, undefined, undefined, aLoc.concat('returns'));
+        markBindingParamPaths(action, aLoc);
       });
     }
 
@@ -124,6 +127,36 @@ function inboundQualificationChecks( csn, options, messageFunctions,
           message('chained-array-of', path);
       }
     }
+
+    // we need to know if the first path step is the bindind param
+    // for the rejection of V2 paths where the BP is ignored
+    function markBindingParamPaths( action, loc ) {
+      const special$self = !csn?.definitions?.$self && '$self';
+      if (action.params) {
+        const params = Object.entries(action.params);
+        const firstParam = params[0][1];
+        const type = firstParam?.items?.type || firstParam?.type;
+        if (type === special$self) {
+          const bindingParamName = params[0][0];
+          const markBindingParam = {
+            ref: (parent, prop, xpr) => {
+              if ((xpr[0].id || xpr[0]) === bindingParamName)
+                parent.$bparam = true;
+            },
+          };
+          let exprAnnos = Object.keys(action).filter(pn => findAnnotationExpression(action, pn));
+          exprAnnos.forEach((pn) => {
+            transformExpression(action, pn, markBindingParam, loc);
+          });
+          forEachMemberRecursively(action, (member, _memberName, _prop, path, _parent) => {
+            exprAnnos = Object.keys(member).filter(pn => findAnnotationExpression(member, pn));
+            exprAnnos.forEach((pn) => {
+              transformExpression(member, pn, markBindingParam, path);
+            });
+          }, loc);
+        }
+      }
+    }
   }
 
   function checkNestedContextsAndServices() {

package/lib/edm/edmPreprocessor.js

@@ -127,7 +127,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         const mySchemaName = whatsMySchemaName(defName);
         if (mySchemaName)
           setProp(def, '$mySchemaName', mySchemaName);
-        if (isMyServiceRequested(defName) && def.kind !== 'aspect')
+        if (isMyServiceRequested(defName) && def.kind !== 'aspect' && def.kind !== 'event')
           reqDefs.definitions[defName] = def;
       },
       linkAssociationTarget,
@@ -1641,7 +1641,10 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             if (art.type && !isBuiltinType(art.type))
               art = art._type || csnUtils.getCsnDef(art.type);
           }
-          keyPaths.push(...produceKeyRefPaths(art, prefix + options.pathDelimiter + k.ref.join(options.pathDelimiter), path));
+          if (art === eltCsn)
+            error('odata-key-recursive', path, { name: prefix });
+          else
+            keyPaths.push(...produceKeyRefPaths(art, prefix + options.pathDelimiter + k.ref.join(options.pathDelimiter), path));
         });
       }
       else {
@@ -2176,7 +2179,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     let isSubTreeSpan = true;
 
     let rootPrefix = absPath.slice(1, absPath.length - 1);
-    const isExprAnno = (obj, pn) => isBetaEnabled(options, 'odataPathsInAnnotationExpressions') && findAnnotationExpression(obj, pn);
 
     const subTreeSpan = {
       ref: (parent, _prop, xpr) => {
@@ -2228,7 +2230,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     if (absPath.length > 2) {
       const [ xprANames, nxprANames ] = Object.keys(carrier).reduce((acc, pn) => {
         if (pn[0] === '@')
-          acc[isExprAnno(carrier, pn) ? 0 : 1].push(pn);
+          acc[findAnnotationExpression(carrier, pn) ? 0 : 1].push(pn);
         return acc;
       }, [ [], [] ]);
 
@@ -2244,8 +2246,10 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       if (scope === 'actions' && def[scope][carrier.$path[3]]) {
         def = def[scope][carrier.$path[3]];
         scope = carrier.$path[4];
-        if (scope === 'params')
+        if (scope === 'params') {
           rootPrefix = absPath.slice(2, absPath.length - 1);
+          eltPath = absPath.slice(2).join('/');
+        }
         if (scope === 'returns') {
           absPath[2] = '$ReturnType';
           rootPrefix = absPath.slice(3, absPath.length - 1);
@@ -2263,7 +2267,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         else {
           absolutize.scope = scope;
           transformExpression(carrier, xprAName, absolutize);
-
           if (!def[proxyDict])
             setProp(def, proxyDict, Object.create(null));
           let proxyCarrier = def[proxyDict][eltPath];

package/lib/gen/Dictionary.json

@@ -213,7 +213,6 @@
       "Type": "Capabilities.CountRestrictionsType",
       "AppliesTo": [
         "EntitySet",
-        "Singleton",
         "Collection"
       ]
     },
@@ -417,6 +416,12 @@
         "Property"
       ]
     },
+    "Capabilities.DefaultCapabilities": {
+      "Type": "Capabilities.DefaultCapabilitiesType",
+      "AppliesTo": [
+        "EntityContainer"
+      ]
+    },
     "CodeList.CurrencyCodes": {
       "Type": "CodeList.CodeListSource",
       "AppliesTo": [
@@ -2553,20 +2558,34 @@
         "DocumentationUrl": "Edm.String"
       }
     },
+    "Capabilities.ChangeTrackingBase": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "Supported": "Edm.Boolean"
+      }
+    },
     "Capabilities.ChangeTrackingType": {
       "$kind": "ComplexType",
+      "BaseType": "Capabilities.ChangeTrackingBase",
       "Properties": {
-        "Supported": "Edm.Boolean",
         "FilterableProperties": "Collection(Edm.PropertyPath)",
-        "ExpandableProperties": "Collection(Edm.NavigationPropertyPath)"
+        "ExpandableProperties": "Collection(Edm.NavigationPropertyPath)",
+        "Supported": "Edm.Boolean"
+      }
+    },
+    "Capabilities.CountRestrictionsBase": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "Countable": "Edm.Boolean"
       }
     },
     "Capabilities.CountRestrictionsType": {
       "$kind": "ComplexType",
+      "BaseType": "Capabilities.CountRestrictionsBase",
       "Properties": {
-        "Countable": "Edm.Boolean",
         "NonCountableProperties": "Collection(Edm.PropertyPath)",
-        "NonCountableNavigationProperties": "Collection(Edm.NavigationPropertyPath)"
+        "NonCountableNavigationProperties": "Collection(Edm.NavigationPropertyPath)",
+        "Countable": "Edm.Boolean"
       }
     },
     "Capabilities.NavigationRestrictionsType": {
@@ -2625,14 +2644,23 @@
         "SupportedFormats": "Collection(Edm.String)"
       }
     },
-    "Capabilities.FilterRestrictionsType": {
+    "Capabilities.FilterRestrictionsBase": {
       "$kind": "ComplexType",
       "Properties": {
         "Filterable": "Edm.Boolean",
         "RequiresFilter": "Edm.Boolean",
+        "MaxLevels": "Edm.Int32"
+      }
+    },
+    "Capabilities.FilterRestrictionsType": {
+      "$kind": "ComplexType",
+      "BaseType": "Capabilities.FilterRestrictionsBase",
+      "Properties": {
         "RequiredProperties": "Collection(Edm.PropertyPath)",
         "NonFilterableProperties": "Collection(Edm.PropertyPath)",
         "FilterExpressionRestrictions": "Collection(Capabilities.FilterExpressionRestrictionType)",
+        "Filterable": "Edm.Boolean",
+        "RequiresFilter": "Edm.Boolean",
         "MaxLevels": "Edm.Int32"
       }
     },
@@ -2643,22 +2671,38 @@
         "AllowedExpressions": "Capabilities.FilterExpressionType"
       }
     },
+    "Capabilities.SortRestrictionsBase": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "Sortable": "Edm.Boolean"
+      }
+    },
     "Capabilities.SortRestrictionsType": {
       "$kind": "ComplexType",
+      "BaseType": "Capabilities.SortRestrictionsBase",
       "Properties": {
-        "Sortable": "Edm.Boolean",
         "AscendingOnlyProperties": "Collection(Edm.PropertyPath)",
         "DescendingOnlyProperties": "Collection(Edm.PropertyPath)",
-        "NonSortableProperties": "Collection(Edm.PropertyPath)"
+        "NonSortableProperties": "Collection(Edm.PropertyPath)",
+        "Sortable": "Edm.Boolean"
       }
     },
-    "Capabilities.ExpandRestrictionsType": {
+    "Capabilities.ExpandRestrictionsBase": {
       "$kind": "ComplexType",
       "Properties": {
         "Expandable": "Edm.Boolean",
         "StreamsExpandable": "Edm.Boolean",
+        "MaxLevels": "Edm.Int32"
+      }
+    },
+    "Capabilities.ExpandRestrictionsType": {
+      "$kind": "ComplexType",
+      "BaseType": "Capabilities.ExpandRestrictionsBase",
+      "Properties": {
         "NonExpandableProperties": "Collection(Edm.NavigationPropertyPath)",
         "NonExpandableStreamProperties": "Collection(Edm.PropertyPath)",
+        "Expandable": "Edm.Boolean",
+        "StreamsExpandable": "Edm.Boolean",
         "MaxLevels": "Edm.Int32"
       }
     },
@@ -2669,16 +2713,31 @@
         "UnsupportedExpressions": "Capabilities.SearchExpressions"
       }
     },
-    "Capabilities.InsertRestrictionsType": {
+    "Capabilities.InsertRestrictionsBase": {
       "$kind": "ComplexType",
       "Properties": {
         "Insertable": "Edm.Boolean",
+        "MaxLevels": "Edm.Int32",
+        "TypecastSegmentSupported": "Edm.Boolean",
+        "QueryOptions": "Capabilities.ModificationQueryOptionsType",
+        "CustomHeaders": "Collection(Capabilities.CustomParameter)",
+        "CustomQueryOptions": "Collection(Capabilities.CustomParameter)",
+        "Description": "Edm.String",
+        "LongDescription": "Edm.String",
+        "ErrorResponses": "Collection(Capabilities.HttpResponse)"
+      }
+    },
+    "Capabilities.InsertRestrictionsType": {
+      "$kind": "ComplexType",
+      "BaseType": "Capabilities.InsertRestrictionsBase",
+      "Properties": {
         "NonInsertableProperties": "Collection(Edm.PropertyPath)",
         "NonInsertableNavigationProperties": "Collection(Edm.NavigationPropertyPath)",
         "RequiredProperties": "Collection(Edm.PropertyPath)",
+        "Permissions": "Collection(Capabilities.PermissionType)",
+        "Insertable": "Edm.Boolean",
         "MaxLevels": "Edm.Int32",
         "TypecastSegmentSupported": "Edm.Boolean",
-        "Permissions": "Collection(Capabilities.PermissionType)",
         "QueryOptions": "Capabilities.ModificationQueryOptionsType",
         "CustomHeaders": "Collection(Capabilities.CustomParameter)",
         "CustomQueryOptions": "Collection(Capabilities.CustomParameter)",
@@ -2708,7 +2767,7 @@
         "ContentIDSupported": "Edm.Boolean"
       }
     },
-    "Capabilities.UpdateRestrictionsType": {
+    "Capabilities.UpdateRestrictionsBase": {
       "$kind": "ComplexType",
       "Properties": {
         "Updatable": "Edm.Boolean",
@@ -2717,9 +2776,29 @@
         "UpdateMethod": "Capabilities.HttpMethod",
         "FilterSegmentSupported": "Edm.Boolean",
         "TypecastSegmentSupported": "Edm.Boolean",
+        "MaxLevels": "Edm.Int32",
+        "Permissions": "Collection(Capabilities.PermissionType)",
+        "QueryOptions": "Capabilities.ModificationQueryOptionsType",
+        "CustomHeaders": "Collection(Capabilities.CustomParameter)",
+        "CustomQueryOptions": "Collection(Capabilities.CustomParameter)",
+        "Description": "Edm.String",
+        "LongDescription": "Edm.String",
+        "ErrorResponses": "Collection(Capabilities.HttpResponse)"
+      }
+    },
+    "Capabilities.UpdateRestrictionsType": {
+      "$kind": "ComplexType",
+      "BaseType": "Capabilities.UpdateRestrictionsBase",
+      "Properties": {
         "NonUpdatableProperties": "Collection(Edm.PropertyPath)",
         "NonUpdatableNavigationProperties": "Collection(Edm.NavigationPropertyPath)",
         "RequiredProperties": "Collection(Edm.PropertyPath)",
+        "Updatable": "Edm.Boolean",
+        "Upsertable": "Edm.Boolean",
+        "DeltaUpdateSupported": "Edm.Boolean",
+        "UpdateMethod": "Capabilities.HttpMethod",
+        "FilterSegmentSupported": "Edm.Boolean",
+        "TypecastSegmentSupported": "Edm.Boolean",
         "MaxLevels": "Edm.Int32",
         "Permissions": "Collection(Capabilities.PermissionType)",
         "QueryOptions": "Capabilities.ModificationQueryOptionsType",
@@ -2737,11 +2816,27 @@
         "ContentIDSupported": "Edm.Boolean"
       }
     },
-    "Capabilities.DeleteRestrictionsType": {
+    "Capabilities.DeleteRestrictionsBase": {
       "$kind": "ComplexType",
       "Properties": {
         "Deletable": "Edm.Boolean",
+        "MaxLevels": "Edm.Int32",
+        "FilterSegmentSupported": "Edm.Boolean",
+        "TypecastSegmentSupported": "Edm.Boolean",
+        "Permissions": "Collection(Capabilities.PermissionType)",
+        "CustomHeaders": "Collection(Capabilities.CustomParameter)",
+        "CustomQueryOptions": "Collection(Capabilities.CustomParameter)",
+        "Description": "Edm.String",
+        "LongDescription": "Edm.String",
+        "ErrorResponses": "Collection(Capabilities.HttpResponse)"
+      }
+    },
+    "Capabilities.DeleteRestrictionsType": {
+      "$kind": "ComplexType",
+      "BaseType": "Capabilities.DeleteRestrictionsBase",
+      "Properties": {
         "NonDeletableNavigationProperties": "Collection(Edm.NavigationPropertyPath)",
+        "Deletable": "Edm.Boolean",
         "MaxLevels": "Edm.Int32",
         "FilterSegmentSupported": "Edm.Boolean",
         "TypecastSegmentSupported": "Edm.Boolean",
@@ -2841,6 +2936,27 @@
         "ExampleValues": "Collection(Core.PrimitiveExampleValue)"
       }
     },
+    "Capabilities.DefaultCapabilitiesType": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "ChangeTracking": "Capabilities.ChangeTrackingBase",
+        "CountRestrictions": "Capabilities.CountRestrictionsBase",
+        "IndexableByKey": "Core.Tag",
+        "TopSupported": "Core.Tag",
+        "SkipSupported": "Core.Tag",
+        "ComputeSupported": "Core.Tag",
+        "SelectSupport": "Capabilities.SelectSupportType",
+        "FilterRestrictions": "Capabilities.FilterRestrictionsBase",
+        "SortRestrictions": "Capabilities.SortRestrictionsBase",
+        "ExpandRestrictions": "Capabilities.ExpandRestrictionsBase",
+        "SearchRestrictions": "Capabilities.SearchRestrictionsType",
+        "InsertRestrictions": "Capabilities.InsertRestrictionsBase",
+        "UpdateRestrictions": "Capabilities.UpdateRestrictionsBase",
+        "DeleteRestrictions": "Capabilities.DeleteRestrictionsBase",
+        "OperationRestrictions": "Capabilities.OperationRestrictionsType",
+        "ReadRestrictions": "Capabilities.ReadRestrictionsType"
+      }
+    },
     "Capabilities.HttpResponse": {
       "$kind": "ComplexType",
       "Properties": {
@@ -3102,7 +3218,6 @@
         "TargetEntities": "Collection(Edm.NavigationPropertyPath)",
         "EffectTypes": "Common.EffectType",
         "TriggerAction": "Common.QualifiedName",
-        "TriggeredIndicator": "Edm.Boolean",
         "Discretionary": "Edm.Boolean"
       }
     },

package/lib/gen/language.checksum

@@ -1 +1 @@
-94c7898bd2c786378430965b9e240ce0
+0c76b255e5fe55c0f8527a4d9f1b563f