npm - @salesforce/lds-adapters-cdp-semantic-authoring - Versions diffs - 1.309.0-dev8 → 1.309.0-dev9 - Mend

@salesforce/lds-adapters-cdp-semantic-authoring 1.309.0-dev8 → 1.309.0-dev9

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 (7) hide show

package/dist/es/es2018/cdp-semantic-authoring.js +366 -150
package/dist/es/es2018/types/src/generated/adapters/patchSemanticModel.d.ts +42 -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 +2 -1
package/package.json +3 -3
package/sfdc/index.js +557 -338
package/src/raml/luvio.raml +3 -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$b, typeCheckConfig as typeCheckConfig$b, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$8 } from 'force/luvioEngine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$c, typeCheckConfig as typeCheckConfig$c, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$8 } 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$D = function SemanticBaseModelOutputRepresentationSelect() {
+const select$E = 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$C = function SemanticFilterOutputRepresentationSelect() {
+const select$D = function SemanticFilterOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$s,
@@ -1933,8 +1933,8 @@ function keyBuilderFromType$b(luvio, object) {
 function normalize$g(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$B = function SemanticCalculatedDimensionOutputRepresentationSelect() {
-    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$C();
+const select$C = function SemanticCalculatedDimensionOutputRepresentationSelect() {
+    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$D();
     return {
         kind: 'Fragment',
         version: VERSION$r,
@@ -2473,8 +2473,8 @@ function keyBuilderFromType$a(luvio, object) {
 function normalize$f(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$A = function SemanticCalculatedMeasurementOutputRepresentationSelect() {
-    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$C();
+const select$B = function SemanticCalculatedMeasurementOutputRepresentationSelect() {
+    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$D();
     return {
         kind: 'Fragment',
         version: VERSION$q,
@@ -3342,7 +3342,7 @@ function keyBuilderFromType$9(luvio, object) {
 function normalize$e(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$z = function SemanticDataObjectOutputRepresentationSelect() {
+const select$A = 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$y = function BinDimensionConfigurationOutputRepresentationSelect() {
+const select$z = 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$x = function GroupDimensionGroupOutputRepresentationSelect() {
+const select$y = 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$w = function GroupDimensionConfigurationOutputRepresentationSelect() {
-    const { selections: GroupDimensionGroupOutputRepresentation__selections, opaque: GroupDimensionGroupOutputRepresentation__opaque, } = select$x();
+const select$x = function GroupDimensionConfigurationOutputRepresentationSelect() {
+    const { selections: GroupDimensionGroupOutputRepresentation__selections, opaque: GroupDimensionGroupOutputRepresentation__opaque, } = select$y();
     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$v = function SemanticGroupingConfigurationOutputRepresentationSelect() {
-    const { selections: BinDimensionConfigurationOutputRepresentation__selections, opaque: BinDimensionConfigurationOutputRepresentation__opaque, } = select$y();
-    const { selections: GroupDimensionConfigurationOutputRepresentation__selections, opaque: GroupDimensionConfigurationOutputRepresentation__opaque, } = select$w();
+const select$w = function SemanticGroupingConfigurationOutputRepresentationSelect() {
+    const { selections: BinDimensionConfigurationOutputRepresentation__selections, opaque: BinDimensionConfigurationOutputRepresentation__opaque, } = select$z();
+    const { selections: GroupDimensionConfigurationOutputRepresentation__selections, opaque: GroupDimensionConfigurationOutputRepresentation__opaque, } = select$x();
     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$u = function SemanticTableFieldReferenceOutputRepresentationSelect() {
+const select$v = 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$t = function SemanticFieldReferenceOutputRepresentationSelect() {
-    const { selections: SemanticTableFieldReferenceOutputRepresentation__selections, opaque: SemanticTableFieldReferenceOutputRepresentation__opaque, } = select$u();
+const select$u = function SemanticFieldReferenceOutputRepresentationSelect() {
+    const { selections: SemanticTableFieldReferenceOutputRepresentation__selections, opaque: SemanticTableFieldReferenceOutputRepresentation__opaque, } = select$v();
     return {
         kind: 'Fragment',
         version: VERSION$j,
@@ -3903,9 +3903,9 @@ function keyBuilderFromType$8(luvio, object) {
 function normalize$d(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$s = function SemanticGroupingOutputRepresentationSelect() {
-    const { selections: SemanticGroupingConfigurationOutputRepresentation__selections, opaque: SemanticGroupingConfigurationOutputRepresentation__opaque, } = select$v();
-    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$t();
+const select$t = function SemanticGroupingOutputRepresentationSelect() {
+    const { selections: SemanticGroupingConfigurationOutputRepresentation__selections, opaque: SemanticGroupingConfigurationOutputRepresentation__opaque, } = select$w();
+    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$u();
     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$r = function SemanticRelationshipCriteriaOutputRepresentationSelect() {
+const select$s = function SemanticRelationshipCriteriaOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$h,
@@ -4377,8 +4377,8 @@ function keyBuilderFromType$7(luvio, object) {
 function normalize$c(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$q = function SemanticRelationshipOutputRepresentationSelect() {
-    const { selections: SemanticRelationshipCriteriaOutputRepresentation__selections, opaque: SemanticRelationshipCriteriaOutputRepresentation__opaque, } = select$r();
+const select$r = function SemanticRelationshipOutputRepresentationSelect() {
+    const { selections: SemanticRelationshipCriteriaOutputRepresentation__selections, opaque: SemanticRelationshipCriteriaOutputRepresentation__opaque, } = select$s();
     return {
         kind: 'Fragment',
         version: VERSION$g,
@@ -4792,7 +4792,7 @@ function keyBuilderFromType$6(luvio, object) {
 function normalize$b(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$p = function SemanticMappedFieldOutputRepresentationSelect() {
+const select$q = function SemanticMappedFieldOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$f,
@@ -4997,7 +4997,7 @@ function normalize$a(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$o = function SemanticUnionOutputRepresentationSelect() {
+const select$p = function SemanticUnionOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$e,
@@ -5054,14 +5054,14 @@ const select$o = function SemanticUnionOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$z()
+                fragment: select$A()
             },
             {
                 name: 'semanticMappedFields',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$p()
+                fragment: select$q()
             }
         ]
     };
@@ -5434,8 +5434,8 @@ function normalize$9(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$n = function SemanticLogicalViewOutputRepresentationSelect() {
-    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$C();
+const select$o = function SemanticLogicalViewOutputRepresentationSelect() {
+    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$D();
     return {
         kind: 'Fragment',
         version: VERSION$d,
@@ -5499,21 +5499,21 @@ const select$n = function SemanticLogicalViewOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$z()
+                fragment: select$A()
             },
             {
                 name: 'semanticRelationships',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$q()
+                fragment: select$r()
             },
             {
                 name: 'semanticUnions',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$o()
+                fragment: select$p()
             }
         ]
     };
@@ -5760,8 +5760,8 @@ function validate$e(obj, path = 'SemanticIdentifyingDimensionOutputRepresentatio
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$m = function SemanticIdentifyingDimensionOutputRepresentationSelect() {
-    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$t();
+const select$n = function SemanticIdentifyingDimensionOutputRepresentationSelect() {
+    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$u();
     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$l = function SemanticInsightTypeOutputRepresentationSelect() {
+const select$m = 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$k = function SemanticInsightsSettingsOutputRepresentationSelect() {
-    const { selections: SemanticIdentifyingDimensionOutputRepresentation__selections, opaque: SemanticIdentifyingDimensionOutputRepresentation__opaque, } = select$m();
-    const { selections: SemanticInsightTypeOutputRepresentation__selections, opaque: SemanticInsightTypeOutputRepresentation__opaque, } = select$l();
-    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$t();
+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();
     return {
         kind: 'Fragment',
         version: VERSION$a,
@@ -6273,10 +6273,10 @@ function keyBuilderFromType$3(luvio, object) {
 function normalize$8(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$j = function SemanticMetricOutputRepresentationSelect() {
-    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$t();
-    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$C();
-    const { selections: SemanticInsightsSettingsOutputRepresentation__selections, opaque: SemanticInsightsSettingsOutputRepresentation__opaque, } = select$k();
+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();
     return {
         kind: 'Fragment',
         version: VERSION$9,
@@ -6754,7 +6754,7 @@ function keyBuilderFromType$2(luvio, object) {
 function normalize$7(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$i = function SemanticParameterOutputRepresentationSelect() {
+const select$j = function SemanticParameterOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$8,
@@ -7506,8 +7506,8 @@ function normalize$6(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$h = function SemanticModelOutputRepresentationSelect() {
-    const { selections: SemanticBaseModelOutputRepresentation__selections, opaque: SemanticBaseModelOutputRepresentation__opaque, } = select$D();
+const select$i = function SemanticModelOutputRepresentationSelect() {
+    const { selections: SemanticBaseModelOutputRepresentation__selections, opaque: SemanticBaseModelOutputRepresentation__opaque, } = select$E();
     return {
         kind: 'Fragment',
         version: VERSION$7,
@@ -7586,7 +7586,7 @@ const select$h = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$B()
+                fragment: select$C()
             },
             {
                 name: 'semanticCalculatedDimensionsUrl',
@@ -7598,7 +7598,7 @@ const select$h = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$A()
+                fragment: select$B()
             },
             {
                 name: 'semanticCalculatedMeasurementsUrl',
@@ -7610,7 +7610,7 @@ const select$h = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$z()
+                fragment: select$A()
             },
             {
                 name: 'semanticDataObjectsUrl',
@@ -7622,7 +7622,7 @@ const select$h = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$s()
+                fragment: select$t()
             },
             {
                 name: 'semanticGroupingsUrl',
@@ -7634,21 +7634,21 @@ const select$h = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$n()
+                fragment: select$o()
             },
             {
                 name: 'semanticMetrics',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$j()
+                fragment: select$k()
             },
             {
                 name: 'semanticParameters',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$i()
+                fragment: select$j()
             },
             {
                 name: 'semanticParametersUrl',
@@ -7660,7 +7660,7 @@ const select$h = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$q()
+                fragment: select$r()
             },
             {
                 name: 'semanticRelationshipsUrl',
@@ -8153,19 +8153,19 @@ function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$g(luvio, params) {
-    return select$h();
+function select$h(luvio, params) {
+    return select$i();
 }
-function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$6(storeKeyMap, luvio, response);
 }
-function ingestSuccess$9(luvio, resourceParams, response) {
+function ingestSuccess$a(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$g(),
+        node: select$h(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -8176,7 +8176,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/v62.0',
@@ -8190,7 +8190,7 @@ function createResourceRequest$a(config) {
     };
 }
-const adapterName$a = 'createSemanticModel';
+const adapterName$b = '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$a, createSemanticModel_ConfigPropertyMetadata);
-const createResourceParams$a = /*#__PURE__*/ createResourceParams$b(createSemanticModel_ConfigPropertyMetadata);
-function typeCheckConfig$a(untrustedConfig) {
+const createSemanticModel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, createSemanticModel_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$c(createSemanticModel_ConfigPropertyMetadata);
+function typeCheckConfig$b(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, createSemanticModel_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, createSemanticModel_ConfigPropertyMetadata);
     const untrustedConfig_baseModels = untrustedConfig.baseModels;
     if (ArrayIsArray$1(untrustedConfig_baseModels)) {
         const untrustedConfig_baseModels_array = [];
@@ -8326,30 +8326,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) => {
@@ -8359,12 +8359,12 @@ function buildNetworkSnapshot$a(luvio, config, options) {
 }
 const createSemanticModelAdapterFactory = (luvio) => {
     return function createSemanticModel(untrustedConfig) {
-        const config = validateAdapterConfig$a(untrustedConfig, createSemanticModel_ConfigPropertyNames);
+        const config = validateAdapterConfig$b(untrustedConfig, createSemanticModel_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createSemanticModel"');
         }
-        return buildNetworkSnapshot$a(luvio, config);
+        return buildNetworkSnapshot$b(luvio, config);
     };
 };
@@ -8556,7 +8556,7 @@ function keyBuilderFromType(luvio, object) {
 function normalize$5(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$f = function SemanticSubMetricOutputRepresentationSelect() {
+const select$g = function SemanticSubMetricOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$6,
@@ -8592,19 +8592,19 @@ function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
-function select$e(luvio, params) {
-    return select$f();
+function select$f(luvio, params) {
+    return select$g();
 }
-function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$5(storeKeyMap, luvio, response);
 }
-function ingestSuccess$8(luvio, resourceParams, response) {
+function ingestSuccess$9(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$e(),
+        node: select$f(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -8615,7 +8615,7 @@ function ingestSuccess$8(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$9(config) {
+function createResourceRequest$a(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -8629,7 +8629,7 @@ function createResourceRequest$9(config) {
     };
 }
-const adapterName$9 = 'createSemanticSubMetric';
+const adapterName$a = 'createSemanticSubMetric';
 const createSemanticSubMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('apiName', false, 2 /* Body */, 0 /* String */),
@@ -8640,11 +8640,11 @@ const createSemanticSubMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('semanticMetricDefinitionApiName', false, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('timeRange', false, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, createSemanticSubMetric_ConfigPropertyMetadata);
-const createResourceParams$9 = /*#__PURE__*/ createResourceParams$b(createSemanticSubMetric_ConfigPropertyMetadata);
-function typeCheckConfig$9(untrustedConfig) {
+const createSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, createSemanticSubMetric_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$c(createSemanticSubMetric_ConfigPropertyMetadata);
+function typeCheckConfig$a(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, createSemanticSubMetric_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, createSemanticSubMetric_ConfigPropertyMetadata);
     const untrustedConfig_filters = untrustedConfig.filters;
     if (ArrayIsArray$1(untrustedConfig_filters)) {
         const untrustedConfig_filters_array = [];
@@ -8664,30 +8664,30 @@ function typeCheckConfig$9(untrustedConfig) {
     }
     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((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$8(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$9(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -8697,12 +8697,12 @@ function buildNetworkSnapshot$9(luvio, config, options) {
 }
 const createSemanticSubMetricAdapterFactory = (luvio) => {
     return function createSemanticSubMetric(untrustedConfig) {
-        const config = validateAdapterConfig$9(untrustedConfig, createSemanticSubMetric_ConfigPropertyNames);
+        const config = validateAdapterConfig$a(untrustedConfig, createSemanticSubMetric_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createSemanticSubMetric"');
         }
-        return buildNetworkSnapshot$9(luvio, config);
+        return buildNetworkSnapshot$a(luvio, config);
     };
 };
@@ -8711,7 +8711,7 @@ function keyBuilder$g(luvio, params) {
         name: params.urlParams.subMetricNameOrId
     });
 }
-function getResponseCacheKeys$8(cacheKeyMap, luvio, resourceParams) {
+function getResponseCacheKeys$9(cacheKeyMap, luvio, resourceParams) {
     const key = keyBuilder$g(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
@@ -8723,7 +8723,7 @@ function evictSuccess(luvio, resourceParams) {
     const key = keyBuilder$g(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$8(config) {
+function createResourceRequest$9(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -8737,34 +8737,34 @@ function createResourceRequest$8(config) {
     };
 }
-const adapterName$8 = 'deleteSemanticSubMetric';
+const adapterName$9 = 'deleteSemanticSubMetric';
 const deleteSemanticSubMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('subMetricNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, deleteSemanticSubMetric_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$b(deleteSemanticSubMetric_ConfigPropertyMetadata);
-function typeCheckConfig$8(untrustedConfig) {
+const deleteSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, deleteSemanticSubMetric_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$c(deleteSemanticSubMetric_ConfigPropertyMetadata);
+function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, deleteSemanticSubMetric_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, deleteSemanticSubMetric_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 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(() => {
         return luvio.handleSuccessResponse(() => {
@@ -8772,7 +8772,7 @@ function buildNetworkSnapshot$8(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$8(cache, luvio, resourceParams);
+            getResponseCacheKeys$9(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -8782,33 +8782,33 @@ function buildNetworkSnapshot$8(luvio, config, options) {
 }
 const deleteSemanticSubMetricAdapterFactory = (luvio) => {
     return function SemanticAuthoringdeleteSemanticSubMetric(untrustedConfig) {
-        const config = validateAdapterConfig$8(untrustedConfig, deleteSemanticSubMetric_ConfigPropertyNames);
+        const config = validateAdapterConfig$9(untrustedConfig, deleteSemanticSubMetric_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$8}"`);
+            throw new Error(`Invalid config for "${adapterName$9}"`);
         }
-        return buildNetworkSnapshot$8(luvio, config);
+        return buildNetworkSnapshot$9(luvio, config);
     };
 };
-function select$d(luvio, params) {
-    return select$j();
+function select$e(luvio, params) {
+    return select$k();
 }
 function keyBuilder$f(luvio, params) {
     return keyBuilder$k(luvio, {
         name: params.urlParams.metricNameOrId
     });
 }
-function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$8(storeKeyMap, luvio, response);
 }
-function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$f(luvio, resourceParams);
     luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$d(),
+        node: select$e(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -8825,7 +8825,7 @@ function ingestError$7(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$7(config) {
+function createResourceRequest$8(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -8843,64 +8843,64 @@ function createResourceRequestFromRepresentation$2(representation) {
         urlParams: {},
     };
     config.urlParams.metricNameOrId = representation.id;
-    return createResourceRequest$7(config);
+    return createResourceRequest$8(config);
 }
-const adapterName$7 = 'getSemanticMetric';
+const adapterName$8 = 'getSemanticMetric';
 const getSemanticMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('metricNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getSemanticMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getSemanticMetric_ConfigPropertyMetadata);
-const createResourceParams$7 = /*#__PURE__*/ createResourceParams$b(getSemanticMetric_ConfigPropertyMetadata);
+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$7(config);
+    const resourceParams = createResourceParams$8(config);
     return keyBuilder$f(luvio, resourceParams);
 }
-function typeCheckConfig$7(untrustedConfig) {
+function typeCheckConfig$8(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticMetric_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticMetric_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$7(untrustedConfig);
+    const config = typeCheckConfig$8(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$7(luvio, config) {
-    createResourceParams$7(config);
-    return select$d();
+    createResourceParams$8(config);
+    return select$e();
 }
 function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+        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$7(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$7(luvio, config, options) {
-    const resourceParams = createResourceParams$7(config);
-    const request = createResourceRequest$7(resourceParams);
+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$7(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -8908,7 +8908,7 @@ function buildNetworkSnapshot$7(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
+    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
@@ -8919,12 +8919,12 @@ function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSemanticMetricAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticMetric(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$7(untrustedConfig, getSemanticMetric_ConfigPropertyNames);
+    const config = validateAdapterConfig$8(untrustedConfig, getSemanticMetric_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -9007,7 +9007,7 @@ function normalize$4(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$c = function SemanticMetricCollectionOutputRepresentationSelect() {
+const select$d = function SemanticMetricCollectionOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$5,
@@ -9018,7 +9018,7 @@ const select$c = function SemanticMetricCollectionOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$j()
+                fragment: select$k()
             }
         ]
     };
@@ -9072,22 +9072,22 @@ function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$b(luvio, params) {
-    return select$c();
+function select$c(luvio, params) {
+    return select$d();
 }
 function keyBuilder$d(luvio, params) {
     return keyPrefix + '::SemanticMetricCollectionOutputRepresentation:(' + 'modelApiNameOrId:' + params.urlParams.modelApiNameOrId + ')';
 }
-function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$4(storeKeyMap, luvio, response, () => keyBuilder$d(luvio, resourceParams));
 }
-function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$d(luvio, resourceParams);
     luvio.storeIngest(key, ingest$4, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$b(),
+        node: select$c(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -9104,7 +9104,7 @@ function ingestError$6(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$6(config) {
+function createResourceRequest$7(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -9118,60 +9118,60 @@ function createResourceRequest$6(config) {
     };
 }
-const adapterName$6 = 'getSemanticMetrics';
+const adapterName$7 = 'getSemanticMetrics';
 const getSemanticMetrics_ConfigPropertyMetadata = [
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getSemanticMetrics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getSemanticMetrics_ConfigPropertyMetadata);
-const createResourceParams$6 = /*#__PURE__*/ createResourceParams$b(getSemanticMetrics_ConfigPropertyMetadata);
+const getSemanticMetrics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getSemanticMetrics_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$c(getSemanticMetrics_ConfigPropertyMetadata);
 function keyBuilder$c(luvio, config) {
-    const resourceParams = createResourceParams$6(config);
+    const resourceParams = createResourceParams$7(config);
     return keyBuilder$d(luvio, resourceParams);
 }
-function typeCheckConfig$6(untrustedConfig) {
+function typeCheckConfig$7(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticMetrics_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticMetrics_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$6(untrustedConfig);
+    const config = typeCheckConfig$7(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$6(luvio, config) {
-    createResourceParams$6(config);
-    return select$b();
+    createResourceParams$7(config);
+    return select$c();
 }
 function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$6(luvio, config, resourceParams, response) {
     const snapshot = ingestError$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$6(luvio, config, options) {
-    const resourceParams = createResourceParams$6(config);
-    const request = createResourceRequest$6(resourceParams);
+function buildNetworkSnapshot$7(luvio, config, options) {
+    const resourceParams = createResourceParams$7(config);
+    const request = createResourceRequest$7(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$7(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -9179,7 +9179,7 @@ function buildNetworkSnapshot$6(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
+    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
@@ -9190,12 +9190,12 @@ function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSemanticMetricsAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticMetrics(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$6(untrustedConfig, getSemanticMetrics_ConfigPropertyNames);
+    const config = validateAdapterConfig$7(untrustedConfig, getSemanticMetrics_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -9256,7 +9256,7 @@ function normalize$3(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$a = function SemanticSubMetricsByMetricOutputRepresentationSelect() {
+const select$b = function SemanticSubMetricsByMetricOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$4,
@@ -9272,7 +9272,7 @@ const select$a = function SemanticSubMetricsByMetricOutputRepresentationSelect()
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$f()
+                fragment: select$g()
             }
         ]
     };
@@ -9384,7 +9384,7 @@ function normalize$2(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$9 = function SemanticSubMetricsByMetricCollectionOutputRepresentationSelect() {
+const select$a = function SemanticSubMetricsByMetricCollectionOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$3,
@@ -9395,7 +9395,7 @@ const select$9 = function SemanticSubMetricsByMetricCollectionOutputRepresentati
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$a()
+                fragment: select$b()
             }
         ]
     };
@@ -9449,22 +9449,22 @@ function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$8(luvio, params) {
-    return select$9();
+function select$9(luvio, params) {
+    return select$a();
 }
 function keyBuilder$b(luvio, params) {
     return keyPrefix + '::SemanticSubMetricsByMetricCollectionOutputRepresentation:(' + 'metricApiNames:' + params.urlParams.metricApiNames + ',' + 'modelApiNameOrId:' + params.urlParams.modelApiNameOrId + ')';
 }
-function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$2(storeKeyMap, luvio, response, () => keyBuilder$b(luvio, resourceParams));
 }
-function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$b(luvio, resourceParams);
     luvio.storeIngest(key, ingest$2, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$8(),
+        node: select$9(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -9481,7 +9481,7 @@ function ingestError$5(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$5(config) {
+function createResourceRequest$6(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -9495,61 +9495,61 @@ function createResourceRequest$5(config) {
     };
 }
-const adapterName$5 = 'getSemanticMetricsToSubMetrics';
+const adapterName$6 = 'getSemanticMetricsToSubMetrics';
 const getSemanticMetricsToSubMetrics_ConfigPropertyMetadata = [
     generateParamConfigMetadata('metricApiNames', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getSemanticMetricsToSubMetrics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$b(getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
+const getSemanticMetricsToSubMetrics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$c(getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
 function keyBuilder$a(luvio, config) {
-    const resourceParams = createResourceParams$5(config);
+    const resourceParams = createResourceParams$6(config);
     return keyBuilder$b(luvio, resourceParams);
 }
-function typeCheckConfig$5(untrustedConfig) {
+function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$5(untrustedConfig);
+    const config = typeCheckConfig$6(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$5(luvio, config) {
-    createResourceParams$5(config);
-    return select$8();
+    createResourceParams$6(config);
+    return select$9();
 }
 function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$5(luvio, config, resourceParams, response) {
     const snapshot = ingestError$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$5(luvio, config, options) {
-    const resourceParams = createResourceParams$5(config);
-    const request = createResourceRequest$5(resourceParams);
+function buildNetworkSnapshot$6(luvio, config, options) {
+    const resourceParams = createResourceParams$6(config);
+    const request = createResourceRequest$6(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -9557,7 +9557,7 @@ function buildNetworkSnapshot$5(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
+    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
@@ -9568,12 +9568,12 @@ function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSemanticMetricsToSubMetricsAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticMetricsToSubMetrics(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$5(untrustedConfig, getSemanticMetricsToSubMetrics_ConfigPropertyNames);
+    const config = validateAdapterConfig$6(untrustedConfig, getSemanticMetricsToSubMetrics_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -9582,24 +9582,24 @@ const getSemanticMetricsToSubMetricsAdapterFactory = (luvio) => function Semanti
     buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
 };
-function select$7(luvio, params) {
-    return select$h();
+function select$8(luvio, params) {
+    return select$i();
 }
 function keyBuilder$9(luvio, params) {
     return keyBuilder$i(luvio, {
         name: params.urlParams.modelApiNameOrId
     });
 }
-function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$6(storeKeyMap, luvio, response);
 }
-function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$9(luvio, resourceParams);
     luvio.storeIngest(key, ingest$6, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$7(),
+        node: select$8(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -9616,7 +9616,7 @@ function ingestError$4(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$4(config) {
+function createResourceRequest$5(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -9635,65 +9635,65 @@ function createResourceRequestFromRepresentation$1(representation) {
         queryParams: {},
     };
     config.urlParams.modelApiNameOrId = representation.id;
-    return createResourceRequest$4(config);
+    return createResourceRequest$5(config);
 }
-const adapterName$4 = 'getSemanticModel';
+const adapterName$5 = 'getSemanticModel';
 const getSemanticModel_ConfigPropertyMetadata = [
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('fieldName', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('includeModelContent', false, 1 /* QueryParameter */, 1 /* Boolean */),
 ];
-const getSemanticModel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getSemanticModel_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$b(getSemanticModel_ConfigPropertyMetadata);
+const getSemanticModel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getSemanticModel_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$c(getSemanticModel_ConfigPropertyMetadata);
 function keyBuilder$8(luvio, config) {
-    const resourceParams = createResourceParams$4(config);
+    const resourceParams = createResourceParams$5(config);
     return keyBuilder$9(luvio, resourceParams);
 }
-function typeCheckConfig$4(untrustedConfig) {
+function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticModel_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticModel_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$4(untrustedConfig);
+    const config = typeCheckConfig$5(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$4(luvio, config) {
-    createResourceParams$4(config);
-    return select$7();
+    createResourceParams$5(config);
+    return select$8();
 }
 function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$4(luvio, config, resourceParams, response) {
     const snapshot = ingestError$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$4(luvio, config, options) {
-    const resourceParams = createResourceParams$4(config);
-    const request = createResourceRequest$4(resourceParams);
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -9701,7 +9701,7 @@ function buildNetworkSnapshot$4(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
+    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
@@ -9712,12 +9712,12 @@ function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSemanticModelAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticModel(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$4(untrustedConfig, getSemanticModel_ConfigPropertyNames);
+    const config = validateAdapterConfig$5(untrustedConfig, getSemanticModel_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -9946,8 +9946,8 @@ function validate$2(obj, path = 'SemanticModelPartialOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$6 = function SemanticModelPartialOutputRepresentationSelect() {
-    const { selections: SemanticBaseModelOutputRepresentation__selections, opaque: SemanticBaseModelOutputRepresentation__opaque, } = select$D();
+const select$7 = function SemanticModelPartialOutputRepresentationSelect() {
+    const { selections: SemanticBaseModelOutputRepresentation__selections, opaque: SemanticBaseModelOutputRepresentation__opaque, } = select$E();
     return {
         kind: 'Fragment',
         version: VERSION$2,
@@ -10448,8 +10448,8 @@ const RepresentationType$1 = 'SemanticModelCollectionOutputRepresentation';
 function normalize$1(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$5 = function SemanticModelCollectionOutputRepresentationSelect() {
-    const { selections: SemanticModelPartialOutputRepresentation__selections, opaque: SemanticModelPartialOutputRepresentation__opaque, } = select$6();
+const select$6 = function SemanticModelCollectionOutputRepresentationSelect() {
+    const { selections: SemanticModelPartialOutputRepresentation__selections, opaque: SemanticModelPartialOutputRepresentation__opaque, } = select$7();
     return {
         kind: 'Fragment',
         version: VERSION$1,
@@ -10580,22 +10580,22 @@ function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
-function select$4(luvio, params) {
-    return select$5();
+function select$5(luvio, params) {
+    return select$6();
 }
 function keyBuilder$7(luvio, params) {
     return keyPrefix + '::SemanticModelCollectionOutputRepresentation:(' + 'app:' + params.queryParams.app + ',' + 'category:' + params.queryParams.category + ',' + 'dataspace:' + params.queryParams.dataspace + ',' + 'label:' + params.queryParams.label + ',' + 'limit:' + params.queryParams.limit + ',' + 'offset:' + params.queryParams.offset + ',' + 'orderBy:' + params.queryParams.orderBy + ',' + 'sourceCreation:' + params.queryParams.sourceCreation + ',' + 'sourceCreationName:' + params.queryParams.sourceCreationName + ')';
 }
-function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$1(storeKeyMap, luvio, response, () => keyBuilder$7(luvio, resourceParams));
 }
-function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$7(luvio, resourceParams);
     luvio.storeIngest(key, ingest$1, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$4(),
+        node: select$5(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -10612,7 +10612,7 @@ function ingestError$3(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$3(config) {
+function createResourceRequest$4(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -10626,7 +10626,7 @@ function createResourceRequest$3(config) {
     };
 }
-const adapterName$3 = 'getSemanticModels';
+const adapterName$4 = 'getSemanticModels';
 const getSemanticModels_ConfigPropertyMetadata = [
     generateParamConfigMetadata('app', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('category', false, 1 /* QueryParameter */, 0 /* String */),
@@ -10638,56 +10638,56 @@ const getSemanticModels_ConfigPropertyMetadata = [
     generateParamConfigMetadata('sourceCreation', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('sourceCreationName', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getSemanticModels_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getSemanticModels_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$b(getSemanticModels_ConfigPropertyMetadata);
+const getSemanticModels_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getSemanticModels_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$c(getSemanticModels_ConfigPropertyMetadata);
 function keyBuilder$6(luvio, config) {
-    const resourceParams = createResourceParams$3(config);
+    const resourceParams = createResourceParams$4(config);
     return keyBuilder$7(luvio, resourceParams);
 }
-function typeCheckConfig$3(untrustedConfig) {
+function typeCheckConfig$4(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticModels_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticModels_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$3(untrustedConfig);
+    const config = typeCheckConfig$4(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$3(luvio, config) {
-    createResourceParams$3(config);
-    return select$4();
+    createResourceParams$4(config);
+    return select$5();
 }
 function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$3(luvio, config, resourceParams, response) {
     const snapshot = ingestError$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$3(luvio, config, options) {
-    const resourceParams = createResourceParams$3(config);
-    const request = createResourceRequest$3(resourceParams);
+function buildNetworkSnapshot$4(luvio, config, options) {
+    const resourceParams = createResourceParams$4(config);
+    const request = createResourceRequest$4(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -10695,7 +10695,7 @@ function buildNetworkSnapshot$3(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
+    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
@@ -10706,12 +10706,12 @@ function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSemanticModelsAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticModels(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$3(untrustedConfig, getSemanticModels_ConfigPropertyNames);
+    const config = validateAdapterConfig$4(untrustedConfig, getSemanticModels_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -10720,24 +10720,24 @@ const getSemanticModelsAdapterFactory = (luvio) => function SemanticAuthoring__g
     buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
 };
-function select$3(luvio, params) {
-    return select$f();
+function select$4(luvio, params) {
+    return select$g();
 }
 function keyBuilder$5(luvio, params) {
     return keyBuilder$h(luvio, {
         name: params.urlParams.subMetricNameOrId
     });
 }
-function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$5(storeKeyMap, luvio, response);
 }
-function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$5(luvio, resourceParams);
     luvio.storeIngest(key, ingest$5, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$3(),
+        node: select$4(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -10754,7 +10754,7 @@ function ingestError$2(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$2(config) {
+function createResourceRequest$3(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -10772,64 +10772,64 @@ function createResourceRequestFromRepresentation(representation) {
         urlParams: {},
     };
     config.urlParams.subMetricNameOrId = representation.id;
-    return createResourceRequest$2(config);
+    return createResourceRequest$3(config);
 }
-const adapterName$2 = 'getSemanticSubMetric';
+const adapterName$3 = 'getSemanticSubMetric';
 const getSemanticSubMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('subMetricNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getSemanticSubMetric_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$b(getSemanticSubMetric_ConfigPropertyMetadata);
+const getSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getSemanticSubMetric_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$c(getSemanticSubMetric_ConfigPropertyMetadata);
 function keyBuilder$4(luvio, config) {
-    const resourceParams = createResourceParams$2(config);
+    const resourceParams = createResourceParams$3(config);
     return keyBuilder$5(luvio, resourceParams);
 }
-function typeCheckConfig$2(untrustedConfig) {
+function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticSubMetric_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticSubMetric_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$2(untrustedConfig);
+    const config = typeCheckConfig$3(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$2(luvio, config) {
-    createResourceParams$2(config);
-    return select$3();
+    createResourceParams$3(config);
+    return select$4();
 }
 function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$2(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$2(luvio, config, resourceParams, response) {
     const snapshot = ingestError$2(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$2(luvio, config, options) {
-    const resourceParams = createResourceParams$2(config);
-    const request = createResourceRequest$2(resourceParams);
+function buildNetworkSnapshot$3(luvio, config, options) {
+    const resourceParams = createResourceParams$3(config);
+    const request = createResourceRequest$3(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -10837,7 +10837,7 @@ function buildNetworkSnapshot$2(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
+    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
@@ -10848,12 +10848,12 @@ function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSemanticSubMetricAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticSubMetric(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$2(untrustedConfig, getSemanticSubMetric_ConfigPropertyNames);
+    const config = validateAdapterConfig$3(untrustedConfig, getSemanticSubMetric_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -10936,7 +10936,7 @@ function normalize(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$2 = function SemanticSubMetricCollectionOutputRepresentationSelect() {
+const select$3 = function SemanticSubMetricCollectionOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION,
@@ -10947,7 +10947,7 @@ const select$2 = function SemanticSubMetricCollectionOutputRepresentationSelect(
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$f()
+                fragment: select$g()
             }
         ]
     };
@@ -11001,22 +11001,22 @@ function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$1(luvio, params) {
-    return select$2();
+function select$2(luvio, params) {
+    return select$3();
 }
 function keyBuilder$3(luvio, params) {
     return keyPrefix + '::SemanticSubMetricCollectionOutputRepresentation:(' + 'modelApiNameOrId:' + params.urlParams.modelApiNameOrId + ')';
 }
-function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys(storeKeyMap, luvio, response, () => keyBuilder$3(luvio, resourceParams));
 }
-function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$3(luvio, resourceParams);
     luvio.storeIngest(key, ingest, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$1(),
+        node: select$2(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -11033,7 +11033,7 @@ function ingestError$1(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$1(config) {
+function createResourceRequest$2(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -11047,60 +11047,60 @@ function createResourceRequest$1(config) {
     };
 }
-const adapterName$1 = 'getSemanticSubMetrics';
+const adapterName$2 = 'getSemanticSubMetrics';
 const getSemanticSubMetrics_ConfigPropertyMetadata = [
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getSemanticSubMetrics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getSemanticSubMetrics_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$b(getSemanticSubMetrics_ConfigPropertyMetadata);
+const getSemanticSubMetrics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getSemanticSubMetrics_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$c(getSemanticSubMetrics_ConfigPropertyMetadata);
 function keyBuilder$2(luvio, config) {
-    const resourceParams = createResourceParams$1(config);
+    const resourceParams = createResourceParams$2(config);
     return keyBuilder$3(luvio, resourceParams);
 }
-function typeCheckConfig$1(untrustedConfig) {
+function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticSubMetrics_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticSubMetrics_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$1(untrustedConfig);
+    const config = typeCheckConfig$2(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$1(luvio, config) {
-    createResourceParams$1(config);
-    return select$1();
+    createResourceParams$2(config);
+    return select$2();
 }
 function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$2(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$1(luvio, config, resourceParams, response) {
     const snapshot = ingestError$1(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$1(luvio, config, options) {
-    const resourceParams = createResourceParams$1(config);
-    const request = createResourceRequest$1(resourceParams);
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -11108,7 +11108,7 @@ function buildNetworkSnapshot$1(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$1, undefined, false);
+    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { luvio, config } = context;
@@ -11119,12 +11119,12 @@ function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSemanticSubMetricsAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticSubMetrics(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$1(untrustedConfig, getSemanticSubMetrics_ConfigPropertyNames);
+    const config = validateAdapterConfig$2(untrustedConfig, getSemanticSubMetrics_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -11133,22 +11133,22 @@ const getSemanticSubMetricsAdapterFactory = (luvio) => function SemanticAuthorin
     buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
 };
-function select(luvio, params) {
-    return select$2();
+function select$1(luvio, params) {
+    return select$3();
 }
 function keyBuilder$1(luvio, params) {
     return keyPrefix + '::SemanticSubMetricCollectionOutputRepresentation:(' + 'subMetricIds:' + params.urlParams.subMetricIds + ')';
 }
-function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys(storeKeyMap, luvio, response, () => keyBuilder$1(luvio, resourceParams));
 }
-function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$1(luvio, resourceParams);
     luvio.storeIngest(key, ingest, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select(),
+        node: select$1(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -11165,7 +11165,7 @@ function ingestError(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest(config) {
+function createResourceRequest$1(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -11179,60 +11179,60 @@ function createResourceRequest(config) {
     };
 }
-const adapterName = 'getSemanticSubMetricsById';
+const adapterName$1 = 'getSemanticSubMetricsById';
 const getSemanticSubMetricsById_ConfigPropertyMetadata = [
     generateParamConfigMetadata('subMetricIds', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getSemanticSubMetricsById_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getSemanticSubMetricsById_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$b(getSemanticSubMetricsById_ConfigPropertyMetadata);
+const getSemanticSubMetricsById_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getSemanticSubMetricsById_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$c(getSemanticSubMetricsById_ConfigPropertyMetadata);
 function keyBuilder(luvio, config) {
-    const resourceParams = createResourceParams(config);
+    const resourceParams = createResourceParams$1(config);
     return keyBuilder$1(luvio, resourceParams);
 }
-function typeCheckConfig(untrustedConfig) {
+function typeCheckConfig$1(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticSubMetricsById_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticSubMetricsById_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig(untrustedConfig);
+    const config = typeCheckConfig$1(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment(luvio, config) {
-    createResourceParams(config);
-    return select();
+    createResourceParams$1(config);
+    return select$1();
 }
 function onFetchResponseSuccess(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError(luvio, config, resourceParams, response) {
     const snapshot = ingestError(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot(luvio, config, options) {
-    const resourceParams = createResourceParams(config);
-    const request = createResourceRequest(resourceParams);
+function buildNetworkSnapshot$1(luvio, config, options) {
+    const resourceParams = createResourceParams$1(config);
+    const request = createResourceRequest$1(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -11240,7 +11240,7 @@ function buildNetworkSnapshot(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
+    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$1, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
@@ -11251,12 +11251,12 @@ function buildCachedSnapshotCachePolicy(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSemanticSubMetricsByIdAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticSubMetricsById(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig(untrustedConfig, getSemanticSubMetricsById_ConfigPropertyNames);
+    const config = validateAdapterConfig$1(untrustedConfig, getSemanticSubMetricsById_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -11265,6 +11265,222 @@ const getSemanticSubMetricsByIdAdapterFactory = (luvio) => function SemanticAuth
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
+function select(luvio, params) {
+    return select$i();
+}
+function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$6(storeKeyMap, luvio, response);
+}
+function ingestSuccess(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(),
+        variables: {},
+    });
+    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 createResourceRequest(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v62.0',
+        basePath: '/ssot/semantic/models/' + config.urlParams.modelApiNameOrId + '',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+const adapterName = 'patchSemanticModel';
+const patchSemanticModel_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('apiName', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('label', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('app', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('categories', false, 2 /* Body */, 0 /* String */, true),
+    generateParamConfigMetadata('dataspace', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('queryUnrelatedDataObjects', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('sourceCreation', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('sourceCreationName', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('baseModels', false, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('semanticCalculatedDimensions', false, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('semanticCalculatedMeasurements', false, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('semanticDataObjects', false, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('semanticGroupings', false, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('semanticLogicalViews', false, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('semanticMetrics', false, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('semanticParameters', false, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('semanticRelationships', false, 2 /* Body */, 4 /* Unsupported */, true),
+];
+const patchSemanticModel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, patchSemanticModel_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$c(patchSemanticModel_ConfigPropertyMetadata);
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$c(untrustedConfig, config, patchSemanticModel_ConfigPropertyMetadata);
+    const untrustedConfig_baseModels = untrustedConfig.baseModels;
+    if (ArrayIsArray$1(untrustedConfig_baseModels)) {
+        const untrustedConfig_baseModels_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_baseModels.length; i < arrayLength; i++) {
+            const untrustedConfig_baseModels_item = untrustedConfig_baseModels[i];
+            const referenceSemanticBaseModelInputRepresentationValidationError = validate$V(untrustedConfig_baseModels_item);
+            if (referenceSemanticBaseModelInputRepresentationValidationError === null) {
+                untrustedConfig_baseModels_array.push(untrustedConfig_baseModels_item);
+            }
+        }
+        config.baseModels = untrustedConfig_baseModels_array;
+    }
+    const untrustedConfig_semanticCalculatedDimensions = untrustedConfig.semanticCalculatedDimensions;
+    if (ArrayIsArray$1(untrustedConfig_semanticCalculatedDimensions)) {
+        const untrustedConfig_semanticCalculatedDimensions_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_semanticCalculatedDimensions.length; i < arrayLength; i++) {
+            const untrustedConfig_semanticCalculatedDimensions_item = untrustedConfig_semanticCalculatedDimensions[i];
+            const referenceSemanticCalculatedDimensionInputRepresentationValidationError = validate$T(untrustedConfig_semanticCalculatedDimensions_item);
+            if (referenceSemanticCalculatedDimensionInputRepresentationValidationError === null) {
+                untrustedConfig_semanticCalculatedDimensions_array.push(untrustedConfig_semanticCalculatedDimensions_item);
+            }
+        }
+        config.semanticCalculatedDimensions = untrustedConfig_semanticCalculatedDimensions_array;
+    }
+    const untrustedConfig_semanticCalculatedMeasurements = untrustedConfig.semanticCalculatedMeasurements;
+    if (ArrayIsArray$1(untrustedConfig_semanticCalculatedMeasurements)) {
+        const untrustedConfig_semanticCalculatedMeasurements_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_semanticCalculatedMeasurements.length; i < arrayLength; i++) {
+            const untrustedConfig_semanticCalculatedMeasurements_item = untrustedConfig_semanticCalculatedMeasurements[i];
+            const referenceSemanticCalculatedMeasurementInputRepresentationValidationError = validate$S(untrustedConfig_semanticCalculatedMeasurements_item);
+            if (referenceSemanticCalculatedMeasurementInputRepresentationValidationError === null) {
+                untrustedConfig_semanticCalculatedMeasurements_array.push(untrustedConfig_semanticCalculatedMeasurements_item);
+            }
+        }
+        config.semanticCalculatedMeasurements = untrustedConfig_semanticCalculatedMeasurements_array;
+    }
+    const untrustedConfig_semanticDataObjects = untrustedConfig.semanticDataObjects;
+    if (ArrayIsArray$1(untrustedConfig_semanticDataObjects)) {
+        const untrustedConfig_semanticDataObjects_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_semanticDataObjects.length; i < arrayLength; i++) {
+            const untrustedConfig_semanticDataObjects_item = untrustedConfig_semanticDataObjects[i];
+            const referenceSemanticDataObjectInputRepresentationValidationError = validate$P(untrustedConfig_semanticDataObjects_item);
+            if (referenceSemanticDataObjectInputRepresentationValidationError === null) {
+                untrustedConfig_semanticDataObjects_array.push(untrustedConfig_semanticDataObjects_item);
+            }
+        }
+        config.semanticDataObjects = untrustedConfig_semanticDataObjects_array;
+    }
+    const untrustedConfig_semanticGroupings = untrustedConfig.semanticGroupings;
+    if (ArrayIsArray$1(untrustedConfig_semanticGroupings)) {
+        const untrustedConfig_semanticGroupings_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_semanticGroupings.length; i < arrayLength; i++) {
+            const untrustedConfig_semanticGroupings_item = untrustedConfig_semanticGroupings[i];
+            const referenceSemanticGroupingInputRepresentationValidationError = validate$I(untrustedConfig_semanticGroupings_item);
+            if (referenceSemanticGroupingInputRepresentationValidationError === null) {
+                untrustedConfig_semanticGroupings_array.push(untrustedConfig_semanticGroupings_item);
+            }
+        }
+        config.semanticGroupings = untrustedConfig_semanticGroupings_array;
+    }
+    const untrustedConfig_semanticLogicalViews = untrustedConfig.semanticLogicalViews;
+    if (ArrayIsArray$1(untrustedConfig_semanticLogicalViews)) {
+        const untrustedConfig_semanticLogicalViews_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_semanticLogicalViews.length; i < arrayLength; i++) {
+            const untrustedConfig_semanticLogicalViews_item = untrustedConfig_semanticLogicalViews[i];
+            const referenceSemanticLogicalViewInputRepresentationValidationError = validate$D(untrustedConfig_semanticLogicalViews_item);
+            if (referenceSemanticLogicalViewInputRepresentationValidationError === null) {
+                untrustedConfig_semanticLogicalViews_array.push(untrustedConfig_semanticLogicalViews_item);
+            }
+        }
+        config.semanticLogicalViews = untrustedConfig_semanticLogicalViews_array;
+    }
+    const untrustedConfig_semanticMetrics = untrustedConfig.semanticMetrics;
+    if (ArrayIsArray$1(untrustedConfig_semanticMetrics)) {
+        const untrustedConfig_semanticMetrics_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_semanticMetrics.length; i < arrayLength; i++) {
+            const untrustedConfig_semanticMetrics_item = untrustedConfig_semanticMetrics[i];
+            const referenceSemanticMetricInputRepresentationValidationError = validate$z(untrustedConfig_semanticMetrics_item);
+            if (referenceSemanticMetricInputRepresentationValidationError === null) {
+                untrustedConfig_semanticMetrics_array.push(untrustedConfig_semanticMetrics_item);
+            }
+        }
+        config.semanticMetrics = untrustedConfig_semanticMetrics_array;
+    }
+    const untrustedConfig_semanticParameters = untrustedConfig.semanticParameters;
+    if (ArrayIsArray$1(untrustedConfig_semanticParameters)) {
+        const untrustedConfig_semanticParameters_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_semanticParameters.length; i < arrayLength; i++) {
+            const untrustedConfig_semanticParameters_item = untrustedConfig_semanticParameters[i];
+            const referenceSemanticParameterInputRepresentationValidationError = validate$y(untrustedConfig_semanticParameters_item);
+            if (referenceSemanticParameterInputRepresentationValidationError === null) {
+                untrustedConfig_semanticParameters_array.push(untrustedConfig_semanticParameters_item);
+            }
+        }
+        config.semanticParameters = untrustedConfig_semanticParameters_array;
+    }
+    const untrustedConfig_semanticRelationships = untrustedConfig.semanticRelationships;
+    if (ArrayIsArray$1(untrustedConfig_semanticRelationships)) {
+        const untrustedConfig_semanticRelationships_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_semanticRelationships.length; i < arrayLength; i++) {
+            const untrustedConfig_semanticRelationships_item = untrustedConfig_semanticRelationships[i];
+            const referenceSemanticRelationshipInputRepresentationValidationError = validate$G(untrustedConfig_semanticRelationships_item);
+            if (referenceSemanticRelationshipInputRepresentationValidationError === null) {
+                untrustedConfig_semanticRelationships_array.push(untrustedConfig_semanticRelationships_item);
+            }
+        }
+        config.semanticRelationships = untrustedConfig_semanticRelationships_array;
+    }
+    return config;
+}
+function validateAdapterConfig(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot(luvio, config, options) {
+    const resourceParams = createResourceParams(config);
+    const request = createResourceRequest(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const patchSemanticModelAdapterFactory = (luvio) => {
+    return function patchSemanticModel(untrustedConfig) {
+        const config = validateAdapterConfig(untrustedConfig, patchSemanticModel_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "patchSemanticModel"');
+        }
+        return buildNetworkSnapshot(luvio, config);
+    };
+};
 let createSemanticModel;
 let createSemanticSubMetric;
 let deleteSemanticSubMetric;
@@ -11279,6 +11495,7 @@ let getSemanticSubMetric;
 let getSemanticSubMetricNotifyChange;
 let getSemanticSubMetrics;
 let getSemanticSubMetricsById;
+let patchSemanticModel;
 // Imperative GET Adapters
 let getSemanticMetric_imperative;
 let getSemanticMetrics_imperative;
@@ -11326,7 +11543,7 @@ function bindExportsTo(luvio) {
     return {
         createSemanticModel: unwrapSnapshotData(createSemanticModelAdapterFactory),
         createSemanticSubMetric: unwrapSnapshotData(createSemanticSubMetricAdapterFactory),
-        deleteSemanticSubMetric: createLDSAdapter(luvio, adapterName$8, deleteSemanticSubMetricAdapterFactory),
+        deleteSemanticSubMetric: createLDSAdapter(luvio, adapterName$9, deleteSemanticSubMetricAdapterFactory),
         getSemanticMetric: createWireAdapterConstructor(luvio, getSemanticMetric_ldsAdapter, getSemanticMetricMetadata),
         getSemanticMetricNotifyChange: createLDSAdapter(luvio, 'getSemanticMetricNotifyChange', notifyChangeFactory$2),
         getSemanticMetrics: createWireAdapterConstructor(luvio, getSemanticMetrics_ldsAdapter, getSemanticMetricsMetadata),
@@ -11338,6 +11555,7 @@ function bindExportsTo(luvio) {
         getSemanticSubMetricNotifyChange: createLDSAdapter(luvio, 'getSemanticSubMetricNotifyChange', notifyChangeFactory),
         getSemanticSubMetrics: createWireAdapterConstructor(luvio, getSemanticSubMetrics_ldsAdapter, getSemanticSubMetricsMetadata),
         getSemanticSubMetricsById: createWireAdapterConstructor(luvio, getSemanticSubMetricsById_ldsAdapter, getSemanticSubMetricsByIdMetadata),
+        patchSemanticModel: unwrapSnapshotData(patchSemanticModelAdapterFactory),
         // Imperative GET Adapters
         getSemanticMetric_imperative: createImperativeAdapter(luvio, getSemanticMetric_ldsAdapter, getSemanticMetricMetadata),
         getSemanticMetrics_imperative: createImperativeAdapter(luvio, getSemanticMetrics_ldsAdapter, getSemanticMetricsMetadata),
@@ -11366,6 +11584,7 @@ withDefaultLuvio((luvio) => {
         getSemanticSubMetricNotifyChange,
         getSemanticSubMetrics,
         getSemanticSubMetricsById,
+        patchSemanticModel,
         getSemanticMetric_imperative,
         getSemanticMetrics_imperative,
         getSemanticMetricsToSubMetrics_imperative,
@@ -11377,5 +11596,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 };
-// version: 1.309.0-dev8-411e383cef
+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.309.0-dev9-7ca613f4d0