@salesforce/lds-adapters-cdp-semantic-authoring 1.312.0 → 1.313.0

package/dist/es/es2018/cdp-semantic-authoring.js

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$8, typeCheckConfig as typeCheckConfig$b, StoreKeyMap, createResourceParams as createResourceParams$b } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$8, typeCheckConfig as typeCheckConfig$c, StoreKeyMap, createResourceParams as createResourceParams$c } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys, create: ObjectCreate } = Object;
@@ -113,7 +113,7 @@ function validate$V(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,
@@ -344,8 +344,8 @@ function validate$U(obj, path = 'SemanticModelPartialOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$C = function SemanticModelPartialOutputRepresentationSelect() {
-    const { selections: SemanticBaseModelOutputRepresentation__selections, opaque: SemanticBaseModelOutputRepresentation__opaque, } = select$D();
+const select$D = function SemanticModelPartialOutputRepresentationSelect() {
+    const { selections: SemanticBaseModelOutputRepresentation__selections, opaque: SemanticBaseModelOutputRepresentation__opaque, } = select$E();
     return {
         kind: 'Fragment',
         version: VERSION$s,
@@ -846,8 +846,8 @@ const RepresentationType$g = 'SemanticModelCollectionOutputRepresentation';
 function normalize$g(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$B = function SemanticModelCollectionOutputRepresentationSelect() {
-    const { selections: SemanticModelPartialOutputRepresentation__selections, opaque: SemanticModelPartialOutputRepresentation__opaque, } = select$C();
+const select$C = function SemanticModelCollectionOutputRepresentationSelect() {
+    const { selections: SemanticModelPartialOutputRepresentation__selections, opaque: SemanticModelPartialOutputRepresentation__opaque, } = select$D();
     return {
         kind: 'Fragment',
         version: VERSION$r,
@@ -978,22 +978,22 @@ function getTypeCacheKeys$g(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-function select$A(luvio, params) {
-    return select$B();
+function select$B(luvio, params) {
+    return select$C();
 }
 function keyBuilder$s(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$a(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$g(storeKeyMap, luvio, response, () => keyBuilder$s(luvio, resourceParams));
 }
-function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$s(luvio, resourceParams);
     luvio.storeIngest(key, ingest$g, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$A(),
+        node: select$B(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1010,7 +1010,7 @@ function ingestError$7(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$a(config) {
+function createResourceRequest$b(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -1024,7 +1024,7 @@ function createResourceRequest$a(config) {
     };
 }
 
-const adapterName$a = 'getSemanticModels';
+const adapterName$b = 'getSemanticModels';
 const getSemanticModels_ConfigPropertyMetadata = [
     generateParamConfigMetadata('app', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('category', false, 1 /* QueryParameter */, 0 /* String */),
@@ -1036,56 +1036,56 @@ const getSemanticModels_ConfigPropertyMetadata = [
     generateParamConfigMetadata('sourceCreation', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('sourceCreationName', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getSemanticModels_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, getSemanticModels_ConfigPropertyMetadata);
-const createResourceParams$a = /*#__PURE__*/ createResourceParams$b(getSemanticModels_ConfigPropertyMetadata);
+const getSemanticModels_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, getSemanticModels_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$c(getSemanticModels_ConfigPropertyMetadata);
 function keyBuilder$r(luvio, config) {
-    const resourceParams = createResourceParams$a(config);
+    const resourceParams = createResourceParams$b(config);
     return keyBuilder$s(luvio, resourceParams);
 }
-function typeCheckConfig$a(untrustedConfig) {
+function typeCheckConfig$b(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticModels_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticModels_ConfigPropertyMetadata);
     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 adapterFragment$7(luvio, config) {
-    createResourceParams$a(config);
-    return select$A();
+    createResourceParams$b(config);
+    return select$B();
 }
 function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$b(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$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-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(() => onFetchResponseSuccess$7(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$b(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1093,7 +1093,7 @@ function buildNetworkSnapshot$a(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$a, undefined, false);
+    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$b, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
@@ -1104,12 +1104,12 @@ function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSemanticModelsAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticModels(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$a(untrustedConfig, getSemanticModels_ConfigPropertyNames);
+    const config = validateAdapterConfig$b(untrustedConfig, getSemanticModels_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -2664,7 +2664,7 @@ function validate$u(obj, path = 'SemanticFilterOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$z = function SemanticFilterOutputRepresentationSelect() {
+const select$A = function SemanticFilterOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$q,
@@ -2888,8 +2888,8 @@ function keyBuilderFromType$b(luvio, object) {
 function normalize$f(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$y = function SemanticCalculatedDimensionOutputRepresentationSelect() {
-    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$z();
+const select$z = function SemanticCalculatedDimensionOutputRepresentationSelect() {
+    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$A();
     return {
         kind: 'Fragment',
         version: VERSION$p,
@@ -3428,8 +3428,8 @@ function keyBuilderFromType$a(luvio, object) {
 function normalize$e(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$x = function SemanticCalculatedMeasurementOutputRepresentationSelect() {
-    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$z();
+const select$y = function SemanticCalculatedMeasurementOutputRepresentationSelect() {
+    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$A();
     return {
         kind: 'Fragment',
         version: VERSION$o,
@@ -4297,7 +4297,7 @@ function keyBuilderFromType$9(luvio, object) {
 function normalize$d(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$w = function SemanticDataObjectOutputRepresentationSelect() {
+const select$x = function SemanticDataObjectOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$n,
@@ -4343,7 +4343,7 @@ function validate$o(obj, path = 'BinDimensionConfigurationOutputRepresentation')
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$v = function BinDimensionConfigurationOutputRepresentationSelect() {
+const select$w = function BinDimensionConfigurationOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$m,
@@ -4393,7 +4393,7 @@ function validate$n(obj, path = 'GroupDimensionGroupOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$u = function GroupDimensionGroupOutputRepresentationSelect() {
+const select$v = function GroupDimensionGroupOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$l,
@@ -4472,8 +4472,8 @@ function validate$m(obj, path = 'GroupDimensionConfigurationOutputRepresentation
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$t = function GroupDimensionConfigurationOutputRepresentationSelect() {
-    const { selections: GroupDimensionGroupOutputRepresentation__selections, opaque: GroupDimensionGroupOutputRepresentation__opaque, } = select$u();
+const select$u = function GroupDimensionConfigurationOutputRepresentationSelect() {
+    const { selections: GroupDimensionGroupOutputRepresentation__selections, opaque: GroupDimensionGroupOutputRepresentation__opaque, } = select$v();
     return {
         kind: 'Fragment',
         version: VERSION$k,
@@ -4558,9 +4558,9 @@ function validate$l(obj, path = 'SemanticGroupingConfigurationOutputRepresentati
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$s = function SemanticGroupingConfigurationOutputRepresentationSelect() {
-    const { selections: BinDimensionConfigurationOutputRepresentation__selections, opaque: BinDimensionConfigurationOutputRepresentation__opaque, } = select$v();
-    const { selections: GroupDimensionConfigurationOutputRepresentation__selections, opaque: GroupDimensionConfigurationOutputRepresentation__opaque, } = select$t();
+const select$t = function SemanticGroupingConfigurationOutputRepresentationSelect() {
+    const { selections: BinDimensionConfigurationOutputRepresentation__selections, opaque: BinDimensionConfigurationOutputRepresentation__opaque, } = select$w();
+    const { selections: GroupDimensionConfigurationOutputRepresentation__selections, opaque: GroupDimensionConfigurationOutputRepresentation__opaque, } = select$u();
     return {
         kind: 'Fragment',
         version: VERSION$j,
@@ -4634,7 +4634,7 @@ function validate$k(obj, path = 'SemanticTableFieldReferenceOutputRepresentation
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$r = function SemanticTableFieldReferenceOutputRepresentationSelect() {
+const select$s = function SemanticTableFieldReferenceOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$i,
@@ -4709,8 +4709,8 @@ function validate$j(obj, path = 'SemanticFieldReferenceOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$q = function SemanticFieldReferenceOutputRepresentationSelect() {
-    const { selections: SemanticTableFieldReferenceOutputRepresentation__selections, opaque: SemanticTableFieldReferenceOutputRepresentation__opaque, } = select$r();
+const select$r = function SemanticFieldReferenceOutputRepresentationSelect() {
+    const { selections: SemanticTableFieldReferenceOutputRepresentation__selections, opaque: SemanticTableFieldReferenceOutputRepresentation__opaque, } = select$s();
     return {
         kind: 'Fragment',
         version: VERSION$h,
@@ -4858,9 +4858,9 @@ function keyBuilderFromType$8(luvio, object) {
 function normalize$c(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$p = function SemanticGroupingOutputRepresentationSelect() {
-    const { selections: SemanticGroupingConfigurationOutputRepresentation__selections, opaque: SemanticGroupingConfigurationOutputRepresentation__opaque, } = select$s();
-    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$q();
+const select$q = function SemanticGroupingOutputRepresentationSelect() {
+    const { selections: SemanticGroupingConfigurationOutputRepresentation__selections, opaque: SemanticGroupingConfigurationOutputRepresentation__opaque, } = select$t();
+    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$r();
     return {
         kind: 'Fragment',
         version: VERSION$g,
@@ -5093,7 +5093,7 @@ function validate$h(obj, path = 'SemanticRelationshipCriteriaOutputRepresentatio
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$o = function SemanticRelationshipCriteriaOutputRepresentationSelect() {
+const select$p = function SemanticRelationshipCriteriaOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$f,
@@ -5332,8 +5332,8 @@ function keyBuilderFromType$7(luvio, object) {
 function normalize$b(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$n = function SemanticRelationshipOutputRepresentationSelect() {
-    const { selections: SemanticRelationshipCriteriaOutputRepresentation__selections, opaque: SemanticRelationshipCriteriaOutputRepresentation__opaque, } = select$o();
+const select$o = function SemanticRelationshipOutputRepresentationSelect() {
+    const { selections: SemanticRelationshipCriteriaOutputRepresentation__selections, opaque: SemanticRelationshipCriteriaOutputRepresentation__opaque, } = select$p();
     return {
         kind: 'Fragment',
         version: VERSION$e,
@@ -5747,7 +5747,7 @@ function keyBuilderFromType$6(luvio, object) {
 function normalize$a(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$m = function SemanticMappedFieldOutputRepresentationSelect() {
+const select$n = function SemanticMappedFieldOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$d,
@@ -5952,7 +5952,7 @@ function normalize$9(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$l = function SemanticUnionOutputRepresentationSelect() {
+const select$m = function SemanticUnionOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$c,
@@ -6009,14 +6009,14 @@ const select$l = function SemanticUnionOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$w()
+                fragment: select$x()
             },
             {
                 name: 'semanticMappedFields',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$m()
+                fragment: select$n()
             }
         ]
     };
@@ -6389,8 +6389,8 @@ function normalize$8(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$k = function SemanticLogicalViewOutputRepresentationSelect() {
-    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$z();
+const select$l = function SemanticLogicalViewOutputRepresentationSelect() {
+    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$A();
     return {
         kind: 'Fragment',
         version: VERSION$b,
@@ -6454,21 +6454,21 @@ const select$k = function SemanticLogicalViewOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$w()
+                fragment: select$x()
             },
             {
                 name: 'semanticRelationships',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$n()
+                fragment: select$o()
             },
             {
                 name: 'semanticUnions',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$l()
+                fragment: select$m()
             }
         ]
     };
@@ -6715,8 +6715,8 @@ function validate$c(obj, path = 'SemanticIdentifyingDimensionOutputRepresentatio
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$j = function SemanticIdentifyingDimensionOutputRepresentationSelect() {
-    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$q();
+const select$k = function SemanticIdentifyingDimensionOutputRepresentationSelect() {
+    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$r();
     return {
         kind: 'Fragment',
         version: VERSION$a,
@@ -6790,7 +6790,7 @@ function validate$b(obj, path = 'SemanticInsightTypeOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$i = function SemanticInsightTypeOutputRepresentationSelect() {
+const select$j = function SemanticInsightTypeOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$9,
@@ -6913,10 +6913,10 @@ function validate$a(obj, path = 'SemanticInsightsSettingsOutputRepresentation')
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$h = function SemanticInsightsSettingsOutputRepresentationSelect() {
-    const { selections: SemanticIdentifyingDimensionOutputRepresentation__selections, opaque: SemanticIdentifyingDimensionOutputRepresentation__opaque, } = select$j();
-    const { selections: SemanticInsightTypeOutputRepresentation__selections, opaque: SemanticInsightTypeOutputRepresentation__opaque, } = select$i();
-    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$q();
+const select$i = function SemanticInsightsSettingsOutputRepresentationSelect() {
+    const { selections: SemanticIdentifyingDimensionOutputRepresentation__selections, opaque: SemanticIdentifyingDimensionOutputRepresentation__opaque, } = select$k();
+    const { selections: SemanticInsightTypeOutputRepresentation__selections, opaque: SemanticInsightTypeOutputRepresentation__opaque, } = select$j();
+    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$r();
     return {
         kind: 'Fragment',
         version: VERSION$8,
@@ -7228,10 +7228,10 @@ function keyBuilderFromType$3(luvio, object) {
 function normalize$7(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$g = function SemanticMetricOutputRepresentationSelect() {
-    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$q();
-    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$z();
-    const { selections: SemanticInsightsSettingsOutputRepresentation__selections, opaque: SemanticInsightsSettingsOutputRepresentation__opaque, } = select$h();
+const select$h = function SemanticMetricOutputRepresentationSelect() {
+    const { selections: SemanticFieldReferenceOutputRepresentation__selections, opaque: SemanticFieldReferenceOutputRepresentation__opaque, } = select$r();
+    const { selections: SemanticFilterOutputRepresentation__selections, opaque: SemanticFilterOutputRepresentation__opaque, } = select$A();
+    const { selections: SemanticInsightsSettingsOutputRepresentation__selections, opaque: SemanticInsightsSettingsOutputRepresentation__opaque, } = select$i();
     return {
         kind: 'Fragment',
         version: VERSION$7,
@@ -7709,7 +7709,7 @@ function keyBuilderFromType$2(luvio, object) {
 function normalize$6(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$f = function SemanticParameterOutputRepresentationSelect() {
+const select$g = function SemanticParameterOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$6,
@@ -8461,8 +8461,8 @@ function normalize$5(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$e = function SemanticModelOutputRepresentationSelect() {
-    const { selections: SemanticBaseModelOutputRepresentation__selections, opaque: SemanticBaseModelOutputRepresentation__opaque, } = select$D();
+const select$f = function SemanticModelOutputRepresentationSelect() {
+    const { selections: SemanticBaseModelOutputRepresentation__selections, opaque: SemanticBaseModelOutputRepresentation__opaque, } = select$E();
     return {
         kind: 'Fragment',
         version: VERSION$5,
@@ -8541,7 +8541,7 @@ const select$e = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$y()
+                fragment: select$z()
             },
             {
                 name: 'semanticCalculatedDimensionsUrl',
@@ -8553,7 +8553,7 @@ const select$e = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$x()
+                fragment: select$y()
             },
             {
                 name: 'semanticCalculatedMeasurementsUrl',
@@ -8565,7 +8565,7 @@ const select$e = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$w()
+                fragment: select$x()
             },
             {
                 name: 'semanticDataObjectsUrl',
@@ -8577,7 +8577,7 @@ const select$e = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$p()
+                fragment: select$q()
             },
             {
                 name: 'semanticGroupingsUrl',
@@ -8589,21 +8589,21 @@ const select$e = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$k()
+                fragment: select$l()
             },
             {
                 name: 'semanticMetrics',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$g()
+                fragment: select$h()
             },
             {
                 name: 'semanticParameters',
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$f()
+                fragment: select$g()
             },
             {
                 name: 'semanticParametersUrl',
@@ -8615,7 +8615,7 @@ const select$e = function SemanticModelOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$n()
+                fragment: select$o()
             },
             {
                 name: 'semanticRelationshipsUrl',
@@ -9108,19 +9108,19 @@ function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
 
-function select$d(luvio, params) {
-    return select$e();
+function select$e(luvio, params) {
+    return select$f();
 }
-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$1(luvio, body);
     luvio.storeIngest(key, ingest$5, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$d(),
+        node: select$e(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -9131,7 +9131,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/v63.0',
@@ -9145,7 +9145,7 @@ function createResourceRequest$9(config) {
     };
 }
 
-const adapterName$9 = 'createSemanticModel';
+const adapterName$a = 'createSemanticModel';
 const createSemanticModel_ConfigPropertyMetadata = [
     generateParamConfigMetadata('apiName', false, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
@@ -9166,11 +9166,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$9, createSemanticModel_ConfigPropertyMetadata);
-const createResourceParams$9 = /*#__PURE__*/ createResourceParams$b(createSemanticModel_ConfigPropertyMetadata);
-function typeCheckConfig$9(untrustedConfig) {
+const createSemanticModel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, createSemanticModel_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$c(createSemanticModel_ConfigPropertyMetadata);
+function typeCheckConfig$a(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 = [];
@@ -9281,30 +9281,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) => {
@@ -9314,33 +9314,33 @@ function buildNetworkSnapshot$9(luvio, config, options) {
 }
 const createSemanticModelAdapterFactory = (luvio) => {
     return function createSemanticModel(untrustedConfig) {
-        const config = validateAdapterConfig$9(untrustedConfig, createSemanticModel_ConfigPropertyNames);
+        const config = validateAdapterConfig$a(untrustedConfig, createSemanticModel_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createSemanticModel"');
         }
-        return buildNetworkSnapshot$9(luvio, config);
+        return buildNetworkSnapshot$a(luvio, config);
     };
 };
 
-function select$c(luvio, params) {
-    return select$e();
+function select$d(luvio, params) {
+    return select$f();
 }
 function keyBuilder$f(luvio, params) {
     return keyBuilder$g(luvio, {
         name: params.urlParams.modelApiNameOrId
     });
 }
-function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$5(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$5, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$c(),
+        node: select$d(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -9357,7 +9357,7 @@ function ingestError$6(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$8(config) {
+function createResourceRequest$9(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -9371,62 +9371,62 @@ function createResourceRequest$8(config) {
     };
 }
 
-const adapterName$8 = 'getSemanticModel';
+const adapterName$9 = '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$8, getSemanticModel_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$b(getSemanticModel_ConfigPropertyMetadata);
+const getSemanticModel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getSemanticModel_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$c(getSemanticModel_ConfigPropertyMetadata);
 function keyBuilder$e(luvio, config) {
-    const resourceParams = createResourceParams$8(config);
+    const resourceParams = createResourceParams$9(config);
     return keyBuilder$f(luvio, resourceParams);
 }
-function typeCheckConfig$8(untrustedConfig) {
+function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticModel_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticModel_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$8(untrustedConfig);
+    const config = typeCheckConfig$9(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$6(luvio, config) {
-    createResourceParams$8(config);
-    return select$c();
+    createResourceParams$9(config);
+    return select$d();
 }
 function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(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$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$8(luvio, config, options) {
-    const resourceParams = createResourceParams$8(config);
-    const request = createResourceRequest$8(resourceParams);
+function buildNetworkSnapshot$9(luvio, config, options) {
+    const resourceParams = createResourceParams$9(config);
+    const request = createResourceRequest$9(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -9434,7 +9434,7 @@ function buildNetworkSnapshot$8(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
+    return buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
@@ -9445,12 +9445,12 @@ function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSemanticModelAdapterFactory = (luvio) => function SemanticAuthoring__getSemanticModel(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$8(untrustedConfig, getSemanticModel_ConfigPropertyNames);
+    const config = validateAdapterConfig$9(untrustedConfig, getSemanticModel_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -9459,6 +9459,222 @@ const getSemanticModelAdapterFactory = (luvio) => function SemanticAuthoring__ge
     buildCachedSnapshotCachePolicy$6, buildNetworkSnapshotCachePolicy$6);
 };
 
+function select$c(luvio, params) {
+    return select$f();
+}
+function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$5(storeKeyMap, luvio, response);
+}
+function ingestSuccess$7(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$1(luvio, body);
+    luvio.storeIngest(key, ingest$5, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$c(),
+        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$8(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v63.0',
+        basePath: '/ssot/semantic/models/' + config.urlParams.modelApiNameOrId + '',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$8 = '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$8, patchSemanticModel_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$c(patchSemanticModel_ConfigPropertyMetadata);
+function typeCheckConfig$8(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$S(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$Q(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$P(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$M(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$F(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$A(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$w(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$v(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$D(untrustedConfig_semanticRelationships_item);
+            if (referenceSemanticRelationshipInputRepresentationValidationError === null) {
+                untrustedConfig_semanticRelationships_array.push(untrustedConfig_semanticRelationships_item);
+            }
+        }
+        config.semanticRelationships = untrustedConfig_semanticRelationships_array;
+    }
+    return config;
+}
+function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$8(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function 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(() => {
+            const snapshot = ingestSuccess$7(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const patchSemanticModelAdapterFactory = (luvio) => {
+    return function patchSemanticModel(untrustedConfig) {
+        const config = validateAdapterConfig$8(untrustedConfig, patchSemanticModel_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "patchSemanticModel"');
+        }
+        return buildNetworkSnapshot$8(luvio, config);
+    };
+};
+
 function validate$6(obj, path = 'SemanticTimeRangeOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -9936,14 +10152,14 @@ const getSemanticMetricsToSubMetrics_ConfigPropertyMetadata = [
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getSemanticMetricsToSubMetrics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
-const createResourceParams$7 = /*#__PURE__*/ createResourceParams$b(getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$c(getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
 function keyBuilder$b(luvio, config) {
     const resourceParams = createResourceParams$7(config);
     return keyBuilder$c(luvio, resourceParams);
 }
 function typeCheckConfig$7(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticMetricsToSubMetrics_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
@@ -10073,7 +10289,7 @@ const select$7 = function SemanticMetricCollectionOutputRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$g()
+                fragment: select$h()
             }
         ]
     };
@@ -10178,14 +10394,14 @@ 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 createResourceParams$6 = /*#__PURE__*/ createResourceParams$c(getSemanticMetrics_ConfigPropertyMetadata);
 function keyBuilder$9(luvio, config) {
     const resourceParams = createResourceParams$6(config);
     return keyBuilder$a(luvio, resourceParams);
 }
 function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticMetrics_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticMetrics_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
@@ -10260,7 +10476,7 @@ const getSemanticMetricsAdapterFactory = (luvio) => function SemanticAuthoring__
 };
 
 function select$5(luvio, params) {
-    return select$g();
+    return select$h();
 }
 function keyBuilder$8(luvio, params) {
     return keyBuilder$i(luvio, {
@@ -10313,14 +10529,14 @@ const getSemanticMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getSemanticMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getSemanticMetric_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$b(getSemanticMetric_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$c(getSemanticMetric_ConfigPropertyMetadata);
 function keyBuilder$7(luvio, config) {
     const resourceParams = createResourceParams$5(config);
     return keyBuilder$8(luvio, resourceParams);
 }
 function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticMetric_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticMetric_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
@@ -10555,14 +10771,14 @@ const getSemanticSubMetrics_ConfigPropertyMetadata = [
     generateParamConfigMetadata('modelApiNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getSemanticSubMetrics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getSemanticSubMetrics_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$b(getSemanticSubMetrics_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$c(getSemanticSubMetrics_ConfigPropertyMetadata);
 function keyBuilder$5(luvio, config) {
     const resourceParams = createResourceParams$4(config);
     return keyBuilder$6(luvio, resourceParams);
 }
 function typeCheckConfig$4(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticSubMetrics_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticSubMetrics_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
@@ -10701,10 +10917,10 @@ const createSemanticSubMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('timeRange', false, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, createSemanticSubMetric_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$b(createSemanticSubMetric_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$c(createSemanticSubMetric_ConfigPropertyMetadata);
 function typeCheckConfig$3(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 = [];
@@ -10803,10 +11019,10 @@ const deleteSemanticSubMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('subMetricNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, deleteSemanticSubMetric_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$b(deleteSemanticSubMetric_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$c(deleteSemanticSubMetric_ConfigPropertyMetadata);
 function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, deleteSemanticSubMetric_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, deleteSemanticSubMetric_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
@@ -10905,14 +11121,14 @@ const getSemanticSubMetric_ConfigPropertyMetadata = [
     generateParamConfigMetadata('subMetricNameOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getSemanticSubMetric_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getSemanticSubMetric_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$b(getSemanticSubMetric_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$c(getSemanticSubMetric_ConfigPropertyMetadata);
 function keyBuilder$2(luvio, config) {
     const resourceParams = createResourceParams$1(config);
     return keyBuilder$3(luvio, resourceParams);
 }
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticSubMetric_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticSubMetric_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
@@ -11037,14 +11253,14 @@ 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 createResourceParams = /*#__PURE__*/ createResourceParams$c(getSemanticSubMetricsById_ConfigPropertyMetadata);
 function keyBuilder(luvio, config) {
     const resourceParams = createResourceParams(config);
     return keyBuilder$1(luvio, resourceParams);
 }
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getSemanticSubMetricsById_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getSemanticSubMetricsById_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig(untrustedConfig, configPropertyNames) {
@@ -11118,4 +11334,4 @@ const getSemanticSubMetricsByIdAdapterFactory = (luvio) => function SemanticAuth
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
-export { createSemanticModelAdapterFactory, createSemanticSubMetricAdapterFactory, deleteSemanticSubMetricAdapterFactory, getSemanticMetricAdapterFactory, getSemanticMetricsAdapterFactory, getSemanticMetricsToSubMetricsAdapterFactory, getSemanticModelAdapterFactory, getSemanticModelsAdapterFactory, getSemanticSubMetricAdapterFactory, getSemanticSubMetricsAdapterFactory, getSemanticSubMetricsByIdAdapterFactory };
+export { createSemanticModelAdapterFactory, createSemanticSubMetricAdapterFactory, deleteSemanticSubMetricAdapterFactory, getSemanticMetricAdapterFactory, getSemanticMetricsAdapterFactory, getSemanticMetricsToSubMetricsAdapterFactory, getSemanticModelAdapterFactory, getSemanticModelsAdapterFactory, getSemanticSubMetricAdapterFactory, getSemanticSubMetricsAdapterFactory, getSemanticSubMetricsByIdAdapterFactory, patchSemanticModelAdapterFactory };