npm - @salesforce/lds-adapters-cdp-semantic-authoring - Versions diffs - 1.314.0 → 1.316.0 - Mend

@salesforce/lds-adapters-cdp-semantic-authoring 1.314.0 → 1.316.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/es/es2018/cdp-semantic-authoring.js +5556 -5424
package/dist/es/es2018/types/src/generated/adapters/getSemanticMetricsByIds.d.ts +27 -0
package/dist/es/es2018/types/src/generated/artifacts/main.d.ts +1 -0
package/dist/es/es2018/types/src/generated/artifacts/sfdc.d.ts +3 -1
package/dist/es/es2018/types/src/generated/resources/getSsotSemanticMetricsByMetricIds.d.ts +15 -0
package/package.json +3 -3
package/sfdc/index.js +376 -233
package/src/raml/api.raml +14 -0
package/src/raml/luvio.raml +5 -0

package/sfdc/index.js CHANGED Viewed

@@ -14,7 +14,7 @@
 /* proxy-compat-disable */
 import { createInstrumentedAdapter, createLDSAdapter, createWireAdapterConstructor, createImperativeAdapter } from 'force/ldsBindings';
 import { withDefaultLuvio } from 'force/ldsEngine';
-import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$c, typeCheckConfig as typeCheckConfig$c, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$8 } from 'force/luvioEngine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$d, typeCheckConfig as typeCheckConfig$d, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$9 } from 'force/luvioEngine';
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys, create: ObjectCreate } = Object;
@@ -1639,7 +1639,7 @@ function validate$x(obj, path = 'SemanticBaseModelOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$E = function SemanticBaseModelOutputRepresentationSelect() {
+const select$F = function SemanticBaseModelOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$t,
@@ -1709,7 +1709,7 @@ function validate$w(obj, path = 'SemanticFilterOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$D = function SemanticFilterOutputRepresentationSelect() {
+const select$E = function SemanticFilterOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$s,
@@ -1921,20 +1921,20 @@ function validate$v(obj, path = 'SemanticCalculatedDimensionOutputRepresentation
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$g = 'SemanticCalculatedDimensionOutputRepresentation';
-function keyBuilder$s(luvio, config) {
+function keyBuilder$u(luvio, config) {
     return keyPrefix + '::' + RepresentationType$g + ':' + config.name;
 }
 function keyBuilderFromType$b(luvio, object) {
     const keyParams = {
         name: object.id
     };
-    return keyBuilder$s(luvio, keyParams);
+    return keyBuilder$u(luvio, keyParams);
 }
 function normalize$g(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$C = function SemanticCalculatedDimensionOutputRepresentationSelect() {
-    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$D();
+const select$D = function SemanticCalculatedDimensionOutputRepresentationSelect() {
+    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$E();
     return {
         kind: 'Fragment',
         version: VERSION$r,
@@ -2461,20 +2461,20 @@ function validate$u(obj, path = 'SemanticCalculatedMeasurementOutputRepresentati
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$f = 'SemanticCalculatedMeasurementOutputRepresentation';
-function keyBuilder$r(luvio, config) {
+function keyBuilder$t(luvio, config) {
     return keyPrefix + '::' + RepresentationType$f + ':' + config.name;
 }
 function keyBuilderFromType$a(luvio, object) {
     const keyParams = {
         name: object.id
     };
-    return keyBuilder$r(luvio, keyParams);
+    return keyBuilder$t(luvio, keyParams);
 }
 function normalize$f(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$B = function SemanticCalculatedMeasurementOutputRepresentationSelect() {
-    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$D();
+const select$C = function SemanticCalculatedMeasurementOutputRepresentationSelect() {
+    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$E();
     return {
         kind: 'Fragment',
         version: VERSION$q,
@@ -3330,19 +3330,19 @@ function validate$r(obj, path = 'SemanticDataObjectOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$e = 'SemanticDataObjectOutputRepresentation';
-function keyBuilder$q(luvio, config) {
+function keyBuilder$s(luvio, config) {
     return keyPrefix + '::' + RepresentationType$e + ':' + config.name;
 }
 function keyBuilderFromType$9(luvio, object) {
     const keyParams = {
         name: object.id
     };
-    return keyBuilder$q(luvio, keyParams);
+    return keyBuilder$s(luvio, keyParams);
 }
 function normalize$e(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$A = function SemanticDataObjectOutputRepresentationSelect() {
+const select$B = function SemanticDataObjectOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$p,
@@ -3388,7 +3388,7 @@ function validate$q(obj, path = 'BinDimensionConfigurationOutputRepresentation')
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$z = function BinDimensionConfigurationOutputRepresentationSelect() {
+const select$A = function BinDimensionConfigurationOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$o,
@@ -3438,7 +3438,7 @@ function validate$p(obj, path = 'GroupDimensionGroupOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$y = function GroupDimensionGroupOutputRepresentationSelect() {
+const select$z = function GroupDimensionGroupOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$n,
@@ -3517,8 +3517,8 @@ function validate$o(obj, path = 'GroupDimensionConfigurationOutputRepresentation
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$x = function GroupDimensionConfigurationOutputRepresentationSelect() {
-    const { selections: GroupDimensionGroupOutputRepresentation__selections, opaque: GroupDimensionGroupOutputRepresentation__opaque, } = select$y();
+const select$y = function GroupDimensionConfigurationOutputRepresentationSelect() {
+    const { selections: GroupDimensionGroupOutputRepresentation__selections, opaque: GroupDimensionGroupOutputRepresentation__opaque, } = select$z();
     return {
         kind: 'Fragment',
         version: VERSION$m,
@@ -3603,9 +3603,9 @@ function validate$n(obj, path = 'SemanticGroupingConfigurationOutputRepresentati
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$w = function SemanticGroupingConfigurationOutputRepresentationSelect() {
-    const { selections: BinDimensionConfigurationOutputRepresentation__selections, opaque: BinDimensionConfigurationOutputRepresentation__opaque, } = select$z();
-    const { selections: GroupDimensionConfigurationOutputRepresentation__selections, opaque: GroupDimensionConfigurationOutputRepresentation__opaque, } = select$x();
+const select$x = function SemanticGroupingConfigurationOutputRepresentationSelect() {
+    const { selections: BinDimensionConfigurationOutputRepresentation__selections, opaque: BinDimensionConfigurationOutputRepresentation__opaque, } = select$A();
+    const { selections: GroupDimensionConfigurationOutputRepresentation__selections, opaque: GroupDimensionConfigurationOutputRepresentation__opaque, } = select$y();
     return {
         kind: 'Fragment',
         version: VERSION$l,
@@ -3679,7 +3679,7 @@ function validate$m(obj, path = 'SemanticTableFieldReferenceOutputRepresentation
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$v = function SemanticTableFieldReferenceOutputRepresentationSelect() {
+const select$w = function SemanticTableFieldReferenceOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$k,
@@ -3754,8 +3754,8 @@ function validate$l(obj, path = 'SemanticFieldReferenceOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$u = function SemanticFieldReferenceOutputRepresentationSelect() {
-    const { selections: SemanticTableFieldReferenceOutputRepresentation__selections, opaque: SemanticTableFieldReferenceOutputRepresentation__opaque, } = select$v();
+const select$v = function SemanticFieldReferenceOutputRepresentationSelect() {
+    const { selections: SemanticTableFieldReferenceOutputRepresentation__selections, opaque: SemanticTableFieldReferenceOutputRepresentation__opaque, } = select$w();
     return {
         kind: 'Fragment',
         version: VERSION$j,
@@ -3891,21 +3891,21 @@ function validate$k(obj, path = 'SemanticGroupingOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$d = 'SemanticGroupingOutputRepresentation';
-function keyBuilder$p(luvio, config) {
+function keyBuilder$r(luvio, config) {
     return keyPrefix + '::' + RepresentationType$d + ':' + config.name;
 }
 function keyBuilderFromType$8(luvio, object) {
     const keyParams = {
         name: object.id
     };
-    return keyBuilder$p(luvio, keyParams);
+    return keyBuilder$r(luvio, keyParams);
 }
 function normalize$d(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$t = function SemanticGroupingOutputRepresentationSelect() {
-    const { selections: SemanticGroupingConfigurationOutputRepresentation__selections, opaque: SemanticGroupingConfigurationOutputRepresentation__opaque, } = select$w();
-    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$u();
+const select$u = function SemanticGroupingOutputRepresentationSelect() {
+    const { selections: SemanticGroupingConfigurationOutputRepresentation__selections, opaque: SemanticGroupingConfigurationOutputRepresentation__opaque, } = select$x();
+    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$v();
     return {
         kind: 'Fragment',
         version: VERSION$i,
@@ -4138,7 +4138,7 @@ function validate$j(obj, path = 'SemanticRelationshipCriteriaOutputRepresentatio
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$s = function SemanticRelationshipCriteriaOutputRepresentationSelect() {
+const select$t = function SemanticRelationshipCriteriaOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$h,
@@ -4365,20 +4365,20 @@ function validate$i(obj, path = 'SemanticRelationshipOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$c = 'SemanticRelationshipOutputRepresentation';
-function keyBuilder$o(luvio, config) {
+function keyBuilder$q(luvio, config) {
     return keyPrefix + '::' + RepresentationType$c + ':' + config.name;
 }
 function keyBuilderFromType$7(luvio, object) {
     const keyParams = {
         name: object.id
     };
-    return keyBuilder$o(luvio, keyParams);
+    return keyBuilder$q(luvio, keyParams);
 }
 function normalize$c(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$r = function SemanticRelationshipOutputRepresentationSelect() {
-    const { selections: SemanticRelationshipCriteriaOutputRepresentation__selections, opaque: SemanticRelationshipCriteriaOutputRepresentation__opaque, } = select$s();
+const select$s = function SemanticRelationshipOutputRepresentationSelect() {
+    const { selections: SemanticRelationshipCriteriaOutputRepresentation__selections, opaque: SemanticRelationshipCriteriaOutputRepresentation__opaque, } = select$t();
     return {
         kind: 'Fragment',
         version: VERSION$g,
@@ -4780,19 +4780,19 @@ function validate$h(obj, path = 'SemanticMappedFieldOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$b = 'SemanticMappedFieldOutputRepresentation';
-function keyBuilder$n(luvio, config) {
+function keyBuilder$p(luvio, config) {
     return keyPrefix + '::' + RepresentationType$b + ':' + config.name;
 }
 function keyBuilderFromType$6(luvio, object) {
     const keyParams = {
         name: object.id
     };
-    return keyBuilder$n(luvio, keyParams);
+    return keyBuilder$p(luvio, keyParams);
 }
 function normalize$b(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$q = function SemanticMappedFieldOutputRepresentationSelect() {
+const select$r = function SemanticMappedFieldOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$f,
@@ -4949,14 +4949,14 @@ function validate$g(obj, path = 'SemanticUnionOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$a = 'SemanticUnionOutputRepresentation';
-function keyBuilder$m(luvio, config) {
+function keyBuilder$o(luvio, config) {
     return keyPrefix + '::' + RepresentationType$a + ':' + config.name;
 }
 function keyBuilderFromType$5(luvio, object) {
     const keyParams = {
         name: object.id
     };
-    return keyBuilder$m(luvio, keyParams);
+    return keyBuilder$o(luvio, keyParams);
 }
 function normalize$a(input, existing, path, luvio, store, timestamp) {
     const input_semanticDataObjects = input.semanticDataObjects;
@@ -4997,7 +4997,7 @@ function normalize$a(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$p = function SemanticUnionOutputRepresentationSelect() {
+const select$q = function SemanticUnionOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$e,
@@ -5054,14 +5054,14 @@ const select$p = function SemanticUnionOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$A()
+                fragment: select$B()
             },
             {
                 name: 'semanticMappedFields',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$q()
+                fragment: select$r()
             }
         ]
     };
@@ -5368,14 +5368,14 @@ function validate$f(obj, path = 'SemanticLogicalViewOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$9 = 'SemanticLogicalViewOutputRepresentation';
-function keyBuilder$l(luvio, config) {
+function keyBuilder$n(luvio, config) {
     return keyPrefix + '::' + RepresentationType$9 + ':' + config.name;
 }
 function keyBuilderFromType$4(luvio, object) {
     const keyParams = {
         name: object.id
     };
-    return keyBuilder$l(luvio, keyParams);
+    return keyBuilder$n(luvio, keyParams);
 }
 function normalize$9(input, existing, path, luvio, store, timestamp) {
     const input_semanticDataObjects = input.semanticDataObjects;
@@ -5434,8 +5434,8 @@ function normalize$9(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$o = function SemanticLogicalViewOutputRepresentationSelect() {
-    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$D();
+const select$p = function SemanticLogicalViewOutputRepresentationSelect() {
+    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$E();
     return {
         kind: 'Fragment',
         version: VERSION$d,
@@ -5499,21 +5499,21 @@ const select$o = function SemanticLogicalViewOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$A()
+                fragment: select$B()
             },
             {
                 name: 'semanticRelationships',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$r()
+                fragment: select$s()
             },
             {
                 name: 'semanticUnions',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$p()
+                fragment: select$q()
             }
         ]
     };
@@ -5760,8 +5760,8 @@ function validate$e(obj, path = 'SemanticIdentifyingDimensionOutputRepresentatio
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$n = function SemanticIdentifyingDimensionOutputRepresentationSelect() {
-    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$u();
+const select$o = function SemanticIdentifyingDimensionOutputRepresentationSelect() {
+    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$v();
     return {
         kind: 'Fragment',
         version: VERSION$c,
@@ -5835,7 +5835,7 @@ function validate$d(obj, path = 'SemanticInsightTypeOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$m = function SemanticInsightTypeOutputRepresentationSelect() {
+const select$n = function SemanticInsightTypeOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$b,
@@ -5958,10 +5958,10 @@ function validate$c(obj, path = 'SemanticInsightsSettingsOutputRepresentation')
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$l = function SemanticInsightsSettingsOutputRepresentationSelect() {
-    const { selections: SemanticIdentifyingDimensionOutputRepresentation__selections, opaque: SemanticIdentifyingDimensionOutputRepresentation__opaque, } = select$n();
-    const { selections: SemanticInsightTypeOutputRepresentation__selections, opaque: SemanticInsightTypeOutputRepresentation__opaque, } = select$m();
-    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$u();
+const select$m = function SemanticInsightsSettingsOutputRepresentationSelect() {
+    const { selections: SemanticIdentifyingDimensionOutputRepresentation__selections, opaque: SemanticIdentifyingDimensionOutputRepresentation__opaque, } = select$o();
+    const { selections: SemanticInsightTypeOutputRepresentation__selections, opaque: SemanticInsightTypeOutputRepresentation__opaque, } = select$n();
+    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$v();
     return {
         kind: 'Fragment',
         version: VERSION$a,
@@ -6261,22 +6261,22 @@ function validate$b(obj, path = 'SemanticMetricOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$8 = 'SemanticMetricOutputRepresentation';
-function keyBuilder$k(luvio, config) {
+function keyBuilder$m(luvio, config) {
     return keyPrefix + '::' + RepresentationType$8 + ':' + config.name;
 }
 function keyBuilderFromType$3(luvio, object) {
     const keyParams = {
         name: object.id
     };
-    return keyBuilder$k(luvio, keyParams);
+    return keyBuilder$m(luvio, keyParams);
 }
 function normalize$8(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$k = function SemanticMetricOutputRepresentationSelect() {
-    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$u();
-    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$D();
-    const { selections: SemanticInsightsSettingsOutputRepresentation__selections, opaque: SemanticInsightsSettingsOutputRepresentation__opaque, } = select$l();
+const select$l = function SemanticMetricOutputRepresentationSelect() {
+    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$v();
+    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$E();
+    const { selections: SemanticInsightsSettingsOutputRepresentation__selections, opaque: SemanticInsightsSettingsOutputRepresentation__opaque, } = select$m();
     return {
         kind: 'Fragment',
         version: VERSION$9,
@@ -6742,19 +6742,19 @@ function validate$a(obj, path = 'SemanticParameterOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$7 = 'SemanticParameterOutputRepresentation';
-function keyBuilder$j(luvio, config) {
+function keyBuilder$l(luvio, config) {
     return keyPrefix + '::' + RepresentationType$7 + ':' + config.name;
 }
 function keyBuilderFromType$2(luvio, object) {
     const keyParams = {
         name: object.id
     };
-    return keyBuilder$j(luvio, keyParams);
+    return keyBuilder$l(luvio, keyParams);
 }
 function normalize$7(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$j = function SemanticParameterOutputRepresentationSelect() {
+const select$k = function SemanticParameterOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$8,
@@ -7350,14 +7350,14 @@ function validate$9(obj, path = 'SemanticModelOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$6 = 'SemanticModelOutputRepresentation';
-function keyBuilder$i(luvio, config) {
+function keyBuilder$k(luvio, config) {
     return keyPrefix + '::' + RepresentationType$6 + ':' + config.name;
 }
 function keyBuilderFromType$1(luvio, object) {
     const keyParams = {
         name: object.id
     };
-    return keyBuilder$i(luvio, keyParams);
+    return keyBuilder$k(luvio, keyParams);
 }
 function normalize$6(input, existing, path, luvio, store, timestamp) {
     const input_semanticCalculatedDimensions = input.semanticCalculatedDimensions;
@@ -7506,8 +7506,8 @@ function normalize$6(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$i = function SemanticModelOutputRepresentationSelect() {
-    const { selections: SemanticBaseModelOutputRepresentation__selections, opaque: SemanticBaseModelOutputRepresentation__opaque, } = select$E();
+const select$j = function SemanticModelOutputRepresentationSelect() {
+    const { selections: SemanticBaseModelOutputRepresentation__selections, opaque: SemanticBaseModelOutputRepresentation__opaque, } = select$F();
     return {
         kind: 'Fragment',
         version: VERSION$7,
@@ -7586,7 +7586,7 @@ const select$i = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$C()
+                fragment: select$D()
             },
             {
                 name: 'semanticCalculatedDimensionsUrl',
@@ -7598,7 +7598,7 @@ const select$i = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$B()
+                fragment: select$C()
             },
             {
                 name: 'semanticCalculatedMeasurementsUrl',
@@ -7610,7 +7610,7 @@ const select$i = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$A()
+                fragment: select$B()
             },
             {
                 name: 'semanticDataObjectsUrl',
@@ -7622,7 +7622,7 @@ const select$i = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$t()
+                fragment: select$u()
             },
             {
                 name: 'semanticGroupingsUrl',
@@ -7634,21 +7634,21 @@ const select$i = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$o()
+                fragment: select$p()
             },
             {
                 name: 'semanticMetrics',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$k()
+                fragment: select$l()
             },
             {
                 name: 'semanticParameters',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$j()
+                fragment: select$k()
             },
             {
                 name: 'semanticParametersUrl',
@@ -7660,7 +7660,7 @@ const select$i = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$r()
+                fragment: select$s()
             },
             {
                 name: 'semanticRelationshipsUrl',
@@ -8153,19 +8153,19 @@ function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$h(luvio, params) {
-    return select$i();
+function select$i(luvio, params) {
+    return select$j();
 }
-function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$6(storeKeyMap, luvio, response);
 }
-function ingestSuccess$a(luvio, resourceParams, response) {
+function ingestSuccess$b(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$1(luvio, body);
     luvio.storeIngest(key, ingest$6, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$h(),
+        node: select$i(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -8176,7 +8176,7 @@ function ingestSuccess$a(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$b(config) {
+function createResourceRequest$c(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -8190,7 +8190,7 @@ function createResourceRequest$b(config) {
     };
 }
-const adapterName$b = 'createSemanticModel';
+const adapterName$c = 'createSemanticModel';
 const createSemanticModel_ConfigPropertyMetadata = [
     generateParamConfigMetadata('apiName', false, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
@@ -8211,11 +8211,11 @@ const createSemanticModel_ConfigPropertyMetadata = [
     generateParamConfigMetadata('semanticParameters', false, 2 /* Body */, 4 /* Unsupported */, true),
     generateParamConfigMetadata('semanticRelationships', false, 2 /* Body */, 4 /* Unsupported */, true),
 ];
-const createSemanticModel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, createSemanticModel_ConfigPropertyMetadata);
-const createResourceParams$b = /*#__PURE__*/ createResourceParams$c(createSemanticModel_ConfigPropertyMetadata);
-function typeCheckConfig$b(untrustedConfig) {
+const createSemanticModel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, createSemanticModel_ConfigPropertyMetadata);
+const createResourceParams$c = /*#__PURE__*/ createResourceParams$d(createSemanticModel_ConfigPropertyMetadata);
+function typeCheckConfig$c(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, createSemanticModel_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, createSemanticModel_ConfigPropertyMetadata);
     const untrustedConfig_baseModels = untrustedConfig.baseModels;
     if (ArrayIsArray$1(untrustedConfig_baseModels)) {
         const untrustedConfig_baseModels_array = [];
@@ -8326,30 +8326,30 @@ function typeCheckConfig$b(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$b(untrustedConfig);
+    const config = typeCheckConfig$c(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$b(luvio, config, options) {
-    const resourceParams = createResourceParams$b(config);
-    const request = createResourceRequest$b(resourceParams);
+function buildNetworkSnapshot$c(luvio, config, options) {
+    const resourceParams = createResourceParams$c(config);
+    const request = createResourceRequest$c(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$a(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$b(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$b(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -8359,12 +8359,12 @@ function buildNetworkSnapshot$b(luvio, config, options) {
 }
 const createSemanticModelAdapterFactory = (luvio) => {
     return function createSemanticModel(untrustedConfig) {
-        const config = validateAdapterConfig$b(untrustedConfig, createSemanticModel_ConfigPropertyNames);
+        const config = validateAdapterConfig$c(untrustedConfig, createSemanticModel_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createSemanticModel"');
         }
-        return buildNetworkSnapshot$b(luvio, config);
+        return buildNetworkSnapshot$c(luvio, config);
     };
 };
@@ -8516,19 +8516,19 @@ function validate$6(obj, path = 'SemanticSubMetricOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$5 = 'SemanticSubMetricOutputRepresentation';
-function keyBuilder$h(luvio, config) {
+function keyBuilder$j(luvio, config) {
     return keyPrefix + '::' + RepresentationType$5 + ':' + config.name;
 }
 function keyBuilderFromType(luvio, object) {
     const keyParams = {
         name: object.id
     };
-    return keyBuilder$h(luvio, keyParams);
+    return keyBuilder$j(luvio, keyParams);
 }
 function normalize$5(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$g = function SemanticSubMetricOutputRepresentationSelect() {
+const select$h = function SemanticSubMetricOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$6,
@@ -8564,19 +8564,19 @@ function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
-function select$f(luvio, params) {
-    return select$g();
+function select$g(luvio, params) {
+    return select$h();
 }
-function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$5(storeKeyMap, luvio, response);
 }
-function ingestSuccess$9(luvio, resourceParams, response) {
+function ingestSuccess$a(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType(luvio, body);
     luvio.storeIngest(key, ingest$5, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$f(),
+        node: select$g(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -8587,7 +8587,7 @@ function ingestSuccess$9(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$a(config) {
+function createResourceRequest$b(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -8601,7 +8601,7 @@ function createResourceRequest$a(config) {
     };
 }
-const adapterName$a = 'createSemanticSubMetric';
+const adapterName$b = 'createSemanticSubMetric';
 const createSemanticSubMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('apiName', false, 2 /* Body */, 0 /* String */),
@@ -8612,11 +8612,11 @@ const createSemanticSubMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('semanticMetricDefinitionApiName', false, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('timeRange', false, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, createSemanticSubMetric_ConfigPropertyMetadata);
-const createResourceParams$a = /*#__PURE__*/ createResourceParams$c(createSemanticSubMetric_ConfigPropertyMetadata);
-function typeCheckConfig$a(untrustedConfig) {
+const createSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, createSemanticSubMetric_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$d(createSemanticSubMetric_ConfigPropertyMetadata);
+function typeCheckConfig$b(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, createSemanticSubMetric_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, createSemanticSubMetric_ConfigPropertyMetadata);
     const untrustedConfig_filters = untrustedConfig.filters;
     if (ArrayIsArray$1(untrustedConfig_filters)) {
         const untrustedConfig_filters_array = [];
@@ -8636,30 +8636,30 @@ function typeCheckConfig$a(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$a(untrustedConfig);
+    const config = typeCheckConfig$b(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$a(luvio, config, options) {
-    const resourceParams = createResourceParams$a(config);
-    const request = createResourceRequest$a(resourceParams);
+function buildNetworkSnapshot$b(luvio, config, options) {
+    const resourceParams = createResourceParams$b(config);
+    const request = createResourceRequest$b(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$9(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$a(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$b(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -8669,22 +8669,22 @@ function buildNetworkSnapshot$a(luvio, config, options) {
 }
 const createSemanticSubMetricAdapterFactory = (luvio) => {
     return function createSemanticSubMetric(untrustedConfig) {
-        const config = validateAdapterConfig$a(untrustedConfig, createSemanticSubMetric_ConfigPropertyNames);
+        const config = validateAdapterConfig$b(untrustedConfig, createSemanticSubMetric_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createSemanticSubMetric"');
         }
-        return buildNetworkSnapshot$a(luvio, config);
+        return buildNetworkSnapshot$b(luvio, config);
     };
 };
-function keyBuilder$g(luvio, params) {
-    return keyBuilder$h(luvio, {
+function keyBuilder$i(luvio, params) {
+    return keyBuilder$j(luvio, {
         name: params.urlParams.subMetricNameOrId
     });
 }
-function getResponseCacheKeys$9(cacheKeyMap, luvio, resourceParams) {
-    const key = keyBuilder$g(luvio, resourceParams);
+function getResponseCacheKeys$a(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$i(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
         representationName: RepresentationType$5,
@@ -8692,10 +8692,10 @@ function getResponseCacheKeys$9(cacheKeyMap, luvio, resourceParams) {
     });
 }
 function evictSuccess(luvio, resourceParams) {
-    const key = keyBuilder$g(luvio, resourceParams);
+    const key = keyBuilder$i(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$9(config) {
+function createResourceRequest$a(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -8709,34 +8709,34 @@ function createResourceRequest$9(config) {
     };
 }
-const adapterName$9 = 'deleteSemanticSubMetric';
+const adapterName$a = 'deleteSemanticSubMetric';
 const deleteSemanticSubMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('subMetricNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, deleteSemanticSubMetric_ConfigPropertyMetadata);
-const createResourceParams$9 = /*#__PURE__*/ createResourceParams$c(deleteSemanticSubMetric_ConfigPropertyMetadata);
-function typeCheckConfig$9(untrustedConfig) {
+const deleteSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, deleteSemanticSubMetric_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$d(deleteSemanticSubMetric_ConfigPropertyMetadata);
+function typeCheckConfig$a(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, deleteSemanticSubMetric_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, deleteSemanticSubMetric_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$9(untrustedConfig);
+    const config = typeCheckConfig$a(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$9(luvio, config, options) {
-    const resourceParams = createResourceParams$9(config);
-    const request = createResourceRequest$9(resourceParams);
+function buildNetworkSnapshot$a(luvio, config, options) {
+    const resourceParams = createResourceParams$a(config);
+    const request = createResourceRequest$a(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
@@ -8744,7 +8744,7 @@ function buildNetworkSnapshot$9(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$9(cache, luvio, resourceParams);
+            getResponseCacheKeys$a(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -8754,33 +8754,33 @@ function buildNetworkSnapshot$9(luvio, config, options) {
 }
 const deleteSemanticSubMetricAdapterFactory = (luvio) => {
     return function SemanticAuthoringdeleteSemanticSubMetric(untrustedConfig) {
-        const config = validateAdapterConfig$9(untrustedConfig, deleteSemanticSubMetric_ConfigPropertyNames);
+        const config = validateAdapterConfig$a(untrustedConfig, deleteSemanticSubMetric_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$9}"`);
+            throw new Error(`Invalid config for "${adapterName$a}"`);
         }
-        return buildNetworkSnapshot$9(luvio, config);
+        return buildNetworkSnapshot$a(luvio, config);
     };
 };
-function select$e(luvio, params) {
-    return select$k();
+function select$f(luvio, params) {
+    return select$l();
 }
-function keyBuilder$f(luvio, params) {
-    return keyBuilder$k(luvio, {
+function keyBuilder$h(luvio, params) {
+    return keyBuilder$m(luvio, {
         name: params.urlParams.metricNameOrId
     });
 }
-function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$8(storeKeyMap, luvio, response);
 }
-function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$f(luvio, resourceParams);
+    const key = keyBuilder$h(luvio, resourceParams);
     luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$e(),
+        node: select$f(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -8791,13 +8791,13 @@ function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$7(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$f(luvio, params);
+function ingestError$8(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$h(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$8(config) {
+function createResourceRequest$9(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -8815,98 +8815,98 @@ function createResourceRequestFromRepresentation$2(representation) {
         urlParams: {},
     };
     config.urlParams.metricNameOrId = representation.id;
-    return createResourceRequest$8(config);
+    return createResourceRequest$9(config);
 }
-const adapterName$8 = 'getSemanticMetric';
+const adapterName$9 = 'getSemanticMetric';
 const getSemanticMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('metricNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getSemanticMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getSemanticMetric_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$c(getSemanticMetric_ConfigPropertyMetadata);
-function keyBuilder$e(luvio, config) {
-    const resourceParams = createResourceParams$8(config);
-    return keyBuilder$f(luvio, resourceParams);
+const getSemanticMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getSemanticMetric_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$d(getSemanticMetric_ConfigPropertyMetadata);
+function keyBuilder$g(luvio, config) {
+    const resourceParams = createResourceParams$9(config);
+    return keyBuilder$h(luvio, resourceParams);
 }
-function typeCheckConfig$8(untrustedConfig) {
+function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getSemanticMetric_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getSemanticMetric_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$8(untrustedConfig);
+    const config = typeCheckConfig$9(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$7(luvio, config) {
-    createResourceParams$8(config);
-    return select$e();
+function adapterFragment$8(luvio, config) {
+    createResourceParams$9(config);
+    return select$f();
 }
-function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
+function onFetchResponseSuccess$8(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$7(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$7(luvio, resourceParams, response, {
+function onFetchResponseError$8(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$8(luvio, config, options) {
-    const resourceParams = createResourceParams$8(config);
-    const request = createResourceRequest$8(resourceParams);
+function buildNetworkSnapshot$9(luvio, config, options) {
+    const resourceParams = createResourceParams$9(config);
+    const request = createResourceRequest$9(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$7(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$8(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$7(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$8(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
+function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$e(luvio, config),
-        node: adapterFragment$7(luvio, config),
+        recordId: keyBuilder$g(luvio, config),
+        node: adapterFragment$8(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSemanticMetricAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticMetric(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$8(untrustedConfig, getSemanticMetric_ConfigPropertyNames);
+    const config = validateAdapterConfig$9(untrustedConfig, getSemanticMetric_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$7, buildNetworkSnapshotCachePolicy$7);
+    buildCachedSnapshotCachePolicy$8, buildNetworkSnapshotCachePolicy$8);
 };
 const notifyChangeFactory$2 = (luvio, options) => {
     return function getSsotSemanticModelsMetricsByMetricNameOrIdAndModelApiNameOrIdNotifyChange(configs) {
-        const keys = configs.map(c => keyBuilder$k(luvio, c));
+        const keys = configs.map(c => keyBuilder$m(luvio, c));
         luvio.getNotifyChangeStoreEntries(keys).then(entries => {
             for (let i = 0, len = entries.length; i < len; i++) {
                 const { key, record: val } = entries[i];
@@ -8979,7 +8979,7 @@ function normalize$4(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$d = function SemanticMetricCollectionOutputRepresentationSelect() {
+const select$e = function SemanticMetricCollectionOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$5,
@@ -8990,7 +8990,7 @@ const select$d = function SemanticMetricCollectionOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$k()
+                fragment: select$l()
             }
         ]
     };
@@ -9044,11 +9044,143 @@ function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$c(luvio, params) {
+function select$d(luvio, params) {
+    return select$e();
+}
+function keyBuilder$f(luvio, params) {
+    return keyPrefix + '::SemanticMetricCollectionOutputRepresentation:(' + 'modelApiNameOrId:' + params.urlParams.modelApiNameOrId + ')';
+}
+function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$4(storeKeyMap, luvio, response, () => keyBuilder$f(luvio, resourceParams));
+}
+function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$f(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$4, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$d(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError$7(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$f(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$8(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v63.0',
+        basePath: '/ssot/semantic/models/' + config.urlParams.modelApiNameOrId + '/metrics',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+const adapterName$8 = 'getSemanticMetrics';
+const getSemanticMetrics_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
+];
+const getSemanticMetrics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getSemanticMetrics_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$d(getSemanticMetrics_ConfigPropertyMetadata);
+function keyBuilder$e(luvio, config) {
+    const resourceParams = createResourceParams$8(config);
+    return keyBuilder$f(luvio, resourceParams);
+}
+function typeCheckConfig$8(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$d(untrustedConfig, config, getSemanticMetrics_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$8(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$7(luvio, config) {
+    createResourceParams$8(config);
     return select$d();
 }
+function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$7(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$7(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$8(luvio, config, options) {
+    const resourceParams = createResourceParams$8(config);
+    const request = createResourceRequest$8(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$7(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$7(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$e(luvio, config),
+        node: adapterFragment$7(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getSemanticMetricsAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticMetrics(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$8(untrustedConfig, getSemanticMetrics_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$7, buildNetworkSnapshotCachePolicy$7);
+};
+function select$c(luvio, params) {
+    return select$e();
+}
 function keyBuilder$d(luvio, params) {
-    return keyPrefix + '::SemanticMetricCollectionOutputRepresentation:(' + 'modelApiNameOrId:' + params.urlParams.modelApiNameOrId + ')';
+    return keyPrefix + '::SemanticMetricCollectionOutputRepresentation:(' + 'metricIds:' + params.urlParams.metricIds + ')';
 }
 function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$4(storeKeyMap, luvio, response, () => keyBuilder$d(luvio, resourceParams));
@@ -9080,7 +9212,7 @@ function createResourceRequest$7(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
-        basePath: '/ssot/semantic/models/' + config.urlParams.modelApiNameOrId + '/metrics',
+        basePath: '/ssot/semantic/metrics/' + config.urlParams.metricIds + '',
         method: 'get',
         body: null,
         urlParams: config.urlParams,
@@ -9090,19 +9222,19 @@ function createResourceRequest$7(config) {
     };
 }
-const adapterName$7 = 'getSemanticMetrics';
-const getSemanticMetrics_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
+const adapterName$7 = 'getSemanticMetricsByIds';
+const getSemanticMetricsByIds_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('metricIds', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getSemanticMetrics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getSemanticMetrics_ConfigPropertyMetadata);
-const createResourceParams$7 = /*#__PURE__*/ createResourceParams$c(getSemanticMetrics_ConfigPropertyMetadata);
+const getSemanticMetricsByIds_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getSemanticMetricsByIds_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$d(getSemanticMetricsByIds_ConfigPropertyMetadata);
 function keyBuilder$c(luvio, config) {
     const resourceParams = createResourceParams$7(config);
     return keyBuilder$d(luvio, resourceParams);
 }
 function typeCheckConfig$7(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getSemanticMetrics_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getSemanticMetricsByIds_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
@@ -9151,7 +9283,7 @@ function buildNetworkSnapshot$7(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
@@ -9166,8 +9298,8 @@ function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     });
     return cacheSnapshot;
 }
-const getSemanticMetricsAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticMetrics(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$7(untrustedConfig, getSemanticMetrics_ConfigPropertyNames);
+const getSemanticMetricsByIdsAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticMetricsByIds(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$7(untrustedConfig, getSemanticMetricsByIds_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -9244,7 +9376,7 @@ const select$b = function SemanticSubMetricsByMetricOutputRepresentationSelect()
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$g()
+                fragment: select$h()
             }
         ]
     };
@@ -9473,14 +9605,14 @@ const getSemanticMetricsToSubMetrics_ConfigPropertyMetadata = [
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getSemanticMetricsToSubMetrics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
-const createResourceParams$6 = /*#__PURE__*/ createResourceParams$c(getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$d(getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
 function keyBuilder$a(luvio, config) {
     const resourceParams = createResourceParams$6(config);
     return keyBuilder$b(luvio, resourceParams);
 }
 function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
@@ -9529,7 +9661,7 @@ function buildNetworkSnapshot$6(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
@@ -9555,10 +9687,10 @@ const getSemanticMetricsToSubMetricsAdapterFactory = (luvio) => function Semanti
 };
 function select$8(luvio, params) {
-    return select$i();
+    return select$j();
 }
 function keyBuilder$9(luvio, params) {
-    return keyBuilder$i(luvio, {
+    return keyBuilder$k(luvio, {
         name: params.urlParams.modelApiNameOrId
     });
 }
@@ -9617,14 +9749,14 @@ const getSemanticModel_ConfigPropertyMetadata = [
     generateParamConfigMetadata('includeModelContent', false, 1 /* QueryParameter */, 1 /* Boolean */),
 ];
 const getSemanticModel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getSemanticModel_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$c(getSemanticModel_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$d(getSemanticModel_ConfigPropertyMetadata);
 function keyBuilder$8(luvio, config) {
     const resourceParams = createResourceParams$5(config);
     return keyBuilder$9(luvio, resourceParams);
 }
 function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getSemanticModel_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getSemanticModel_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
@@ -9673,7 +9805,7 @@ function buildNetworkSnapshot$5(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
@@ -9699,7 +9831,7 @@ const getSemanticModelAdapterFactory = (luvio) => function SemanticAuthoring__ge
 };
 const notifyChangeFactory$1 = (luvio, options) => {
     return function getSsotSemanticModelsByModelApiNameOrIdNotifyChange(configs) {
-        const keys = configs.map(c => keyBuilder$i(luvio, c));
+        const keys = configs.map(c => keyBuilder$k(luvio, c));
         luvio.getNotifyChangeStoreEntries(keys).then(entries => {
             for (let i = 0, len = entries.length; i < len; i++) {
                 const { key, record: val } = entries[i];
@@ -9919,7 +10051,7 @@ function validate$2(obj, path = 'SemanticModelPartialOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const select$7 = function SemanticModelPartialOutputRepresentationSelect() {
-    const { selections: SemanticBaseModelOutputRepresentation__selections, opaque: SemanticBaseModelOutputRepresentation__opaque, } = select$E();
+    const { selections: SemanticBaseModelOutputRepresentation__selections, opaque: SemanticBaseModelOutputRepresentation__opaque, } = select$F();
     return {
         kind: 'Fragment',
         version: VERSION$2,
@@ -10611,14 +10743,14 @@ const getSemanticModels_ConfigPropertyMetadata = [
     generateParamConfigMetadata('sourceCreationName', false, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getSemanticModels_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getSemanticModels_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$c(getSemanticModels_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$d(getSemanticModels_ConfigPropertyMetadata);
 function keyBuilder$6(luvio, config) {
     const resourceParams = createResourceParams$4(config);
     return keyBuilder$7(luvio, resourceParams);
 }
 function typeCheckConfig$4(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getSemanticModels_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getSemanticModels_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
@@ -10667,7 +10799,7 @@ function buildNetworkSnapshot$4(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
@@ -10693,10 +10825,10 @@ const getSemanticModelsAdapterFactory = (luvio) => function SemanticAuthoring__g
 };
 function select$4(luvio, params) {
-    return select$g();
+    return select$h();
 }
 function keyBuilder$5(luvio, params) {
-    return keyBuilder$h(luvio, {
+    return keyBuilder$j(luvio, {
         name: params.urlParams.subMetricNameOrId
     });
 }
@@ -10753,14 +10885,14 @@ const getSemanticSubMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('subMetricNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getSemanticSubMetric_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$c(getSemanticSubMetric_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$d(getSemanticSubMetric_ConfigPropertyMetadata);
 function keyBuilder$4(luvio, config) {
     const resourceParams = createResourceParams$3(config);
     return keyBuilder$5(luvio, resourceParams);
 }
 function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getSemanticSubMetric_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getSemanticSubMetric_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
@@ -10809,7 +10941,7 @@ function buildNetworkSnapshot$3(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
@@ -10835,7 +10967,7 @@ const getSemanticSubMetricAdapterFactory = (luvio) => function SemanticAuthoring
 };
 const notifyChangeFactory = (luvio, options) => {
     return function getSsotSemanticModelsSubMetricsByModelApiNameOrIdAndSubMetricNameOrIdNotifyChange(configs) {
-        const keys = configs.map(c => keyBuilder$h(luvio, c));
+        const keys = configs.map(c => keyBuilder$j(luvio, c));
         luvio.getNotifyChangeStoreEntries(keys).then(entries => {
             for (let i = 0, len = entries.length; i < len; i++) {
                 const { key, record: val } = entries[i];
@@ -10919,7 +11051,7 @@ const select$3 = function SemanticSubMetricCollectionOutputRepresentationSelect(
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$g()
+                fragment: select$h()
             }
         ]
     };
@@ -11024,14 +11156,14 @@ const getSemanticSubMetrics_ConfigPropertyMetadata = [
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getSemanticSubMetrics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getSemanticSubMetrics_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$c(getSemanticSubMetrics_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$d(getSemanticSubMetrics_ConfigPropertyMetadata);
 function keyBuilder$2(luvio, config) {
     const resourceParams = createResourceParams$2(config);
     return keyBuilder$3(luvio, resourceParams);
 }
 function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getSemanticSubMetrics_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getSemanticSubMetrics_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
@@ -11080,7 +11212,7 @@ function buildNetworkSnapshot$2(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { luvio, config } = context;
@@ -11156,14 +11288,14 @@ const getSemanticSubMetricsById_ConfigPropertyMetadata = [
     generateParamConfigMetadata('subMetricIds', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getSemanticSubMetricsById_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getSemanticSubMetricsById_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$c(getSemanticSubMetricsById_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$d(getSemanticSubMetricsById_ConfigPropertyMetadata);
 function keyBuilder(luvio, config) {
     const resourceParams = createResourceParams$1(config);
     return keyBuilder$1(luvio, resourceParams);
 }
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getSemanticSubMetricsById_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getSemanticSubMetricsById_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
@@ -11212,7 +11344,7 @@ function buildNetworkSnapshot$1(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$1, undefined, false);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$1, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
@@ -11238,7 +11370,7 @@ const getSemanticSubMetricsByIdAdapterFactory = (luvio) => function SemanticAuth
 };
 function select(luvio, params) {
-    return select$i();
+    return select$j();
 }
 function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$6(storeKeyMap, luvio, response);
@@ -11297,10 +11429,10 @@ const patchSemanticModel_ConfigPropertyMetadata = [
     generateParamConfigMetadata('semanticRelationships', false, 2 /* Body */, 4 /* Unsupported */, true),
 ];
 const patchSemanticModel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, patchSemanticModel_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$c(patchSemanticModel_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$d(patchSemanticModel_ConfigPropertyMetadata);
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, patchSemanticModel_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, patchSemanticModel_ConfigPropertyMetadata);
     const untrustedConfig_baseModels = untrustedConfig.baseModels;
     if (ArrayIsArray$1(untrustedConfig_baseModels)) {
         const untrustedConfig_baseModels_array = [];
@@ -11459,6 +11591,7 @@ let deleteSemanticSubMetric;
 let getSemanticMetric;
 let getSemanticMetricNotifyChange;
 let getSemanticMetrics;
+let getSemanticMetricsByIds;
 let getSemanticMetricsToSubMetrics;
 let getSemanticModel;
 let getSemanticModelNotifyChange;
@@ -11471,6 +11604,7 @@ let patchSemanticModel;
 // Imperative GET Adapters
 let getSemanticMetric_imperative;
 let getSemanticMetrics_imperative;
+let getSemanticMetricsByIds_imperative;
 let getSemanticMetricsToSubMetrics_imperative;
 let getSemanticModel_imperative;
 let getSemanticModels_imperative;
@@ -11479,6 +11613,10 @@ let getSemanticSubMetrics_imperative;
 let getSemanticSubMetricsById_imperative;
 const getSemanticMetricMetadata = { apiFamily: 'SemanticAuthoring', name: 'getSemanticMetric' };
 const getSemanticMetricsMetadata = { apiFamily: 'SemanticAuthoring', name: 'getSemanticMetrics' };
+const getSemanticMetricsByIdsMetadata = {
+    apiFamily: 'SemanticAuthoring',
+    name: 'getSemanticMetricsByIds',
+};
 const getSemanticMetricsToSubMetricsMetadata = {
     apiFamily: 'SemanticAuthoring',
     name: 'getSemanticMetricsToSubMetrics',
@@ -11502,6 +11640,7 @@ function bindExportsTo(luvio) {
     // LDS Adapters
     const getSemanticMetric_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getSemanticMetric', getSemanticMetricAdapterFactory), getSemanticMetricMetadata);
     const getSemanticMetrics_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getSemanticMetrics', getSemanticMetricsAdapterFactory), getSemanticMetricsMetadata);
+    const getSemanticMetricsByIds_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getSemanticMetricsByIds', getSemanticMetricsByIdsAdapterFactory), getSemanticMetricsByIdsMetadata);
     const getSemanticMetricsToSubMetrics_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getSemanticMetricsToSubMetrics', getSemanticMetricsToSubMetricsAdapterFactory), getSemanticMetricsToSubMetricsMetadata);
     const getSemanticModel_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getSemanticModel', getSemanticModelAdapterFactory), getSemanticModelMetadata);
     const getSemanticModels_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getSemanticModels', getSemanticModelsAdapterFactory), getSemanticModelsMetadata);
@@ -11515,10 +11654,11 @@ function bindExportsTo(luvio) {
     return {
         createSemanticModel: unwrapSnapshotData(createSemanticModelAdapterFactory),
         createSemanticSubMetric: unwrapSnapshotData(createSemanticSubMetricAdapterFactory),
-        deleteSemanticSubMetric: createLDSAdapter(luvio, adapterName$9, deleteSemanticSubMetricAdapterFactory),
+        deleteSemanticSubMetric: createLDSAdapter(luvio, adapterName$a, deleteSemanticSubMetricAdapterFactory),
         getSemanticMetric: createWireAdapterConstructor(luvio, getSemanticMetric_ldsAdapter, getSemanticMetricMetadata),
         getSemanticMetricNotifyChange: createLDSAdapter(luvio, 'getSemanticMetricNotifyChange', notifyChangeFactory$2),
         getSemanticMetrics: createWireAdapterConstructor(luvio, getSemanticMetrics_ldsAdapter, getSemanticMetricsMetadata),
+        getSemanticMetricsByIds: createWireAdapterConstructor(luvio, getSemanticMetricsByIds_ldsAdapter, getSemanticMetricsByIdsMetadata),
         getSemanticMetricsToSubMetrics: createWireAdapterConstructor(luvio, getSemanticMetricsToSubMetrics_ldsAdapter, getSemanticMetricsToSubMetricsMetadata),
         getSemanticModel: createWireAdapterConstructor(luvio, getSemanticModel_ldsAdapter, getSemanticModelMetadata),
         getSemanticModelNotifyChange: createLDSAdapter(luvio, 'getSemanticModelNotifyChange', notifyChangeFactory$1),
@@ -11531,6 +11671,7 @@ function bindExportsTo(luvio) {
         // Imperative GET Adapters
         getSemanticMetric_imperative: createImperativeAdapter(luvio, getSemanticMetric_ldsAdapter, getSemanticMetricMetadata),
         getSemanticMetrics_imperative: createImperativeAdapter(luvio, getSemanticMetrics_ldsAdapter, getSemanticMetricsMetadata),
+        getSemanticMetricsByIds_imperative: createImperativeAdapter(luvio, getSemanticMetricsByIds_ldsAdapter, getSemanticMetricsByIdsMetadata),
         getSemanticMetricsToSubMetrics_imperative: createImperativeAdapter(luvio, getSemanticMetricsToSubMetrics_ldsAdapter, getSemanticMetricsToSubMetricsMetadata),
         getSemanticModel_imperative: createImperativeAdapter(luvio, getSemanticModel_ldsAdapter, getSemanticModelMetadata),
         getSemanticModels_imperative: createImperativeAdapter(luvio, getSemanticModels_ldsAdapter, getSemanticModelsMetadata),
@@ -11548,6 +11689,7 @@ withDefaultLuvio((luvio) => {
         getSemanticMetric,
         getSemanticMetricNotifyChange,
         getSemanticMetrics,
+        getSemanticMetricsByIds,
         getSemanticMetricsToSubMetrics,
         getSemanticModel,
         getSemanticModelNotifyChange,
@@ -11559,6 +11701,7 @@ withDefaultLuvio((luvio) => {
         patchSemanticModel,
         getSemanticMetric_imperative,
         getSemanticMetrics_imperative,
+        getSemanticMetricsByIds_imperative,
         getSemanticMetricsToSubMetrics_imperative,
         getSemanticModel_imperative,
         getSemanticModels_imperative,
@@ -11568,5 +11711,5 @@ withDefaultLuvio((luvio) => {
     } = bindExportsTo(luvio));
 });
-export { createSemanticModel, createSemanticSubMetric, deleteSemanticSubMetric, getSemanticMetric, getSemanticMetricNotifyChange, getSemanticMetric_imperative, getSemanticMetrics, getSemanticMetricsToSubMetrics, getSemanticMetricsToSubMetrics_imperative, getSemanticMetrics_imperative, getSemanticModel, getSemanticModelNotifyChange, getSemanticModel_imperative, getSemanticModels, getSemanticModels_imperative, getSemanticSubMetric, getSemanticSubMetricNotifyChange, getSemanticSubMetric_imperative, getSemanticSubMetrics, getSemanticSubMetricsById, getSemanticSubMetricsById_imperative, getSemanticSubMetrics_imperative, patchSemanticModel };
-// version: 1.314.0-022b0c843b
+export { createSemanticModel, createSemanticSubMetric, deleteSemanticSubMetric, getSemanticMetric, getSemanticMetricNotifyChange, getSemanticMetric_imperative, getSemanticMetrics, getSemanticMetricsByIds, getSemanticMetricsByIds_imperative, getSemanticMetricsToSubMetrics, getSemanticMetricsToSubMetrics_imperative, getSemanticMetrics_imperative, getSemanticModel, getSemanticModelNotifyChange, getSemanticModel_imperative, getSemanticModels, getSemanticModels_imperative, getSemanticSubMetric, getSemanticSubMetricNotifyChange, getSemanticSubMetric_imperative, getSemanticSubMetrics, getSemanticSubMetricsById, getSemanticSubMetricsById_imperative, getSemanticSubMetrics_imperative, patchSemanticModel };
+// version: 1.316.0-4453f1e2b6