@salesforce/lds-adapters-industries-context 1.444.0 → 1.445.0

package/sfdc/index.js

@@ -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$13, typeCheckConfig as typeCheckConfig$13, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$k } from 'force/luvioEngine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$14, typeCheckConfig as typeCheckConfig$14, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$k } from 'force/luvioEngine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -357,7 +357,7 @@ function keyBuilderFromType$t(luvio, object) {
 function normalize$x(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$1t = function ContextInfoRepresentationSelect() {
+const select$1u = function ContextInfoRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$D,
@@ -423,7 +423,7 @@ function validate$1a(obj, path = 'QueryContextRecordResultDataRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$1s = function QueryContextRecordResultDataRepresentationSelect() {
+const select$1t = function QueryContextRecordResultDataRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$C,
@@ -530,8 +530,8 @@ function keyBuilderFromType$s(luvio, object) {
 function normalize$w(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$1r = function QueryRecordsResultRepresentationSelect() {
-    const { selections: QueryContextRecordResultDataRepresentation__selections, opaque: QueryContextRecordResultDataRepresentation__opaque, } = select$1s();
+const select$1s = function QueryRecordsResultRepresentationSelect() {
+    const { selections: QueryContextRecordResultDataRepresentation__selections, opaque: QueryContextRecordResultDataRepresentation__opaque, } = select$1t();
     return {
         kind: 'Fragment',
         version: VERSION$B,
@@ -679,7 +679,7 @@ function keyBuilderFromType$r(luvio, object) {
 function normalize$v(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$1q = function ContextFilterOutputRepresentationSelect() {
+const select$1r = function ContextFilterOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$A,
@@ -715,19 +715,19 @@ function getTypeCacheKeys$v(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-function select$1p(luvio, params) {
-    return select$1q();
+function select$1q(luvio, params) {
+    return select$1r();
 }
-function getResponseCacheKeys$12(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$13(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$v(storeKeyMap, luvio, response);
 }
-function ingestSuccess$R(luvio, resourceParams, response) {
+function ingestSuccess$S(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$r(luvio, body);
     luvio.storeIngest(key, ingest$v, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$1p(),
+        node: select$1q(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -738,7 +738,7 @@ function ingestSuccess$R(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$12(config) {
+function createResourceRequest$13(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -752,7 +752,7 @@ function createResourceRequest$12(config) {
     };
 }
 
-const adapterName$12 = 'buildAndQueryRecordsFilter';
+const adapterName$13 = 'buildAndQueryRecordsFilter';
 const buildAndQueryRecordsFilter_ConfigPropertyMetadata = [
     generateParamConfigMetadata('build', false, 2 /* Body */, 4 /* Unsupported */),
     generateParamConfigMetadata('filter', false, 2 /* Body */, 0 /* String */),
@@ -760,11 +760,11 @@ const buildAndQueryRecordsFilter_ConfigPropertyMetadata = [
     generateParamConfigMetadata('query', false, 2 /* Body */, 4 /* Unsupported */),
     generateParamConfigMetadata('type', false, 2 /* Body */, 0 /* String */),
 ];
-const buildAndQueryRecordsFilter_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$12, buildAndQueryRecordsFilter_ConfigPropertyMetadata);
-const createResourceParams$12 = /*#__PURE__*/ createResourceParams$13(buildAndQueryRecordsFilter_ConfigPropertyMetadata);
-function typeCheckConfig$12(untrustedConfig) {
+const buildAndQueryRecordsFilter_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$13, buildAndQueryRecordsFilter_ConfigPropertyMetadata);
+const createResourceParams$13 = /*#__PURE__*/ createResourceParams$14(buildAndQueryRecordsFilter_ConfigPropertyMetadata);
+function typeCheckConfig$13(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, buildAndQueryRecordsFilter_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, buildAndQueryRecordsFilter_ConfigPropertyMetadata);
     const untrustedConfig_build = untrustedConfig.build;
     const referenceContextInputRepresentationValidationError = validate$1f(untrustedConfig_build);
     if (referenceContextInputRepresentationValidationError === null) {
@@ -782,30 +782,30 @@ function typeCheckConfig$12(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$12(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$13(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$12(untrustedConfig);
+    const config = typeCheckConfig$13(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$12(luvio, config, options) {
-    const resourceParams = createResourceParams$12(config);
-    const request = createResourceRequest$12(resourceParams);
+function buildNetworkSnapshot$13(luvio, config, options) {
+    const resourceParams = createResourceParams$13(config);
+    const request = createResourceRequest$13(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$R(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$S(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$12(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$13(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -815,28 +815,28 @@ function buildNetworkSnapshot$12(luvio, config, options) {
 }
 const buildAndQueryRecordsFilterAdapterFactory = (luvio) => {
     return function buildAndQueryRecordsFilter(untrustedConfig) {
-        const config = validateAdapterConfig$12(untrustedConfig, buildAndQueryRecordsFilter_ConfigPropertyNames);
+        const config = validateAdapterConfig$13(untrustedConfig, buildAndQueryRecordsFilter_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "buildAndQueryRecordsFilter"');
         }
-        return buildNetworkSnapshot$12(luvio, config);
+        return buildNetworkSnapshot$13(luvio, config);
     };
 };
 
-function select$1o(luvio, params) {
-    return select$1t();
+function select$1p(luvio, params) {
+    return select$1u();
 }
-function getResponseCacheKeys$11(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$12(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$x(storeKeyMap, luvio, response);
 }
-function ingestSuccess$Q(luvio, resourceParams, response) {
+function ingestSuccess$R(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$t(luvio, body);
     luvio.storeIngest(key, ingest$x, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$1o(),
+        node: select$1p(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -847,7 +847,7 @@ function ingestSuccess$Q(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$11(config) {
+function createResourceRequest$12(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -861,16 +861,16 @@ function createResourceRequest$11(config) {
     };
 }
 
-const adapterName$11 = 'buildContext';
+const adapterName$12 = 'buildContext';
 const buildContext_ConfigPropertyMetadata = [
     generateParamConfigMetadata('data', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('metadata', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const buildContext_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$11, buildContext_ConfigPropertyMetadata);
-const createResourceParams$11 = /*#__PURE__*/ createResourceParams$13(buildContext_ConfigPropertyMetadata);
-function typeCheckConfig$11(untrustedConfig) {
+const buildContext_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$12, buildContext_ConfigPropertyMetadata);
+const createResourceParams$12 = /*#__PURE__*/ createResourceParams$14(buildContext_ConfigPropertyMetadata);
+function typeCheckConfig$12(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, buildContext_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, buildContext_ConfigPropertyMetadata);
     const untrustedConfig_metadata = untrustedConfig.metadata;
     const referenceContextMetaDataInputRepresentationValidationError = validate$1g(untrustedConfig_metadata);
     if (referenceContextMetaDataInputRepresentationValidationError === null) {
@@ -878,30 +878,30 @@ function typeCheckConfig$11(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$11(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$12(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$11(untrustedConfig);
+    const config = typeCheckConfig$12(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$11(luvio, config, options) {
-    const resourceParams = createResourceParams$11(config);
-    const request = createResourceRequest$11(resourceParams);
+function buildNetworkSnapshot$12(luvio, config, options) {
+    const resourceParams = createResourceParams$12(config);
+    const request = createResourceRequest$12(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$Q(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$R(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$11(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$12(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -911,12 +911,12 @@ function buildNetworkSnapshot$11(luvio, config, options) {
 }
 const buildContextAdapterFactory = (luvio) => {
     return function buildContext(untrustedConfig) {
-        const config = validateAdapterConfig$11(untrustedConfig, buildContext_ConfigPropertyNames);
+        const config = validateAdapterConfig$12(untrustedConfig, buildContext_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "buildContext"');
         }
-        return buildNetworkSnapshot$11(luvio, config);
+        return buildNetworkSnapshot$12(luvio, config);
     };
 };
 
@@ -1432,7 +1432,7 @@ function keyBuilderFromType$q(luvio, object) {
 function normalize$u(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$1n = function ContextAndQueryOutputRepresentationSelect() {
+const select$1o = function ContextAndQueryOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$z,
@@ -1468,19 +1468,19 @@ function getTypeCacheKeys$u(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-function select$1m(luvio, params) {
-    return select$1n();
+function select$1n(luvio, params) {
+    return select$1o();
 }
-function getResponseCacheKeys$10(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$11(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$u(storeKeyMap, luvio, response);
 }
-function ingestSuccess$P(luvio, resourceParams, response) {
+function ingestSuccess$Q(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$q(luvio, body);
     luvio.storeIngest(key, ingest$u, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$1m(),
+        node: select$1n(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1491,7 +1491,7 @@ function ingestSuccess$P(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$10(config) {
+function createResourceRequest$11(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -1505,7 +1505,7 @@ function createResourceRequest$10(config) {
     };
 }
 
-const adapterName$10 = 'buildContextAndQuery';
+const adapterName$11 = 'buildContextAndQuery';
 const buildContextAndQuery_ConfigPropertyMetadata = [
     generateParamConfigMetadata('attributeUpdateWithTagsRepresentation', false, 2 /* Body */, 4 /* Unsupported */),
     generateParamConfigMetadata('build', false, 2 /* Body */, 4 /* Unsupported */),
@@ -1517,11 +1517,11 @@ const buildContextAndQuery_ConfigPropertyMetadata = [
     generateParamConfigMetadata('tags', false, 2 /* Body */, 0 /* String */, true),
     generateParamConfigMetadata('waitTime', false, 2 /* Body */, 3 /* Integer */),
 ];
-const buildContextAndQuery_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$10, buildContextAndQuery_ConfigPropertyMetadata);
-const createResourceParams$10 = /*#__PURE__*/ createResourceParams$13(buildContextAndQuery_ConfigPropertyMetadata);
-function typeCheckConfig$10(untrustedConfig) {
+const buildContextAndQuery_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$11, buildContextAndQuery_ConfigPropertyMetadata);
+const createResourceParams$11 = /*#__PURE__*/ createResourceParams$14(buildContextAndQuery_ConfigPropertyMetadata);
+function typeCheckConfig$11(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, buildContextAndQuery_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, buildContextAndQuery_ConfigPropertyMetadata);
     const untrustedConfig_attributeUpdateWithTagsRepresentation = untrustedConfig.attributeUpdateWithTagsRepresentation;
     const referenceContextAttributeUpdateWithTagsRepresentationValidationError = validate$15(untrustedConfig_attributeUpdateWithTagsRepresentation);
     if (referenceContextAttributeUpdateWithTagsRepresentationValidationError === null) {
@@ -1549,30 +1549,30 @@ function typeCheckConfig$10(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$10(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$11(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$10(untrustedConfig);
+    const config = typeCheckConfig$11(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$10(luvio, config, options) {
-    const resourceParams = createResourceParams$10(config);
-    const request = createResourceRequest$10(resourceParams);
+function buildNetworkSnapshot$11(luvio, config, options) {
+    const resourceParams = createResourceParams$11(config);
+    const request = createResourceRequest$11(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$P(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$Q(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$10(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$11(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1582,12 +1582,12 @@ function buildNetworkSnapshot$10(luvio, config, options) {
 }
 const buildContextAndQueryAdapterFactory = (luvio) => {
     return function buildContextAndQuery(untrustedConfig) {
-        const config = validateAdapterConfig$10(untrustedConfig, buildContextAndQuery_ConfigPropertyNames);
+        const config = validateAdapterConfig$11(untrustedConfig, buildContextAndQuery_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "buildContextAndQuery"');
         }
-        return buildNetworkSnapshot$10(luvio, config);
+        return buildNetworkSnapshot$11(luvio, config);
     };
 };
 
@@ -1654,7 +1654,7 @@ function validate$V(obj, path = 'ContextAttrContextHydrationDetailRepresentation
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$1l = function ContextAttrContextHydrationDetailRepresentationSelect() {
+const select$1m = function ContextAttrContextHydrationDetailRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$y,
@@ -1856,7 +1856,7 @@ function keyBuilderFromType$p(luvio, object) {
 function normalize$t(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$1k = function ContextAttrHydrationDetailRepresentationSelect() {
+const select$1l = function ContextAttrHydrationDetailRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$x,
@@ -2014,8 +2014,8 @@ function normalize$s(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$1j = function ContextAttributeMappingRepresentationSelect() {
-    const { selections: ContextAttrContextHydrationDetailRepresentation__selections, opaque: ContextAttrContextHydrationDetailRepresentation__opaque, } = select$1l();
+const select$1k = function ContextAttributeMappingRepresentationSelect() {
+    const { selections: ContextAttrContextHydrationDetailRepresentation__selections, opaque: ContextAttrContextHydrationDetailRepresentation__opaque, } = select$1m();
     return {
         kind: 'Fragment',
         version: VERSION$w,
@@ -2037,7 +2037,7 @@ const select$1j = function ContextAttributeMappingRepresentationSelect() {
                 name: 'contextAttrHydrationDetailList',
                 kind: 'Link',
                 plural: true,
-                fragment: select$1k()
+                fragment: select$1l()
             },
             {
                 name: 'contextAttributeId',
@@ -2327,7 +2327,7 @@ function normalize$r(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$1i = function ContextNodeMappingRepresentationSelect() {
+const select$1j = function ContextNodeMappingRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$v,
@@ -2337,7 +2337,7 @@ const select$1i = function ContextNodeMappingRepresentationSelect() {
                 name: 'attributeMappings',
                 kind: 'Link',
                 plural: true,
-                fragment: select$1j()
+                fragment: select$1k()
             },
             {
                 name: 'baseReference',
@@ -2624,7 +2624,7 @@ function normalize$q(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$1h = function ContextMappingRepresentationSelect() {
+const select$1i = function ContextMappingRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$u,
@@ -2648,7 +2648,7 @@ const select$1h = function ContextMappingRepresentationSelect() {
                 name: 'contextNodeMappings',
                 kind: 'Link',
                 plural: true,
-                fragment: select$1i()
+                fragment: select$1j()
             },
             {
                 name: 'description',
@@ -2922,7 +2922,7 @@ function normalize$p(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$1g = function ContextMappingListRepresentationSelect() {
+const select$1h = function ContextMappingListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$t,
@@ -2937,7 +2937,7 @@ const select$1g = function ContextMappingListRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$1h()
+                fragment: select$1i()
             },
             {
                 name: 'isSuccess',
@@ -3014,19 +3014,19 @@ function getTypeCacheKeys$p(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
 
-function select$1f(luvio, params) {
-    return select$1g();
+function select$1g(luvio, params) {
+    return select$1h();
 }
-function getResponseCacheKeys$$(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$10(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$p(storeKeyMap, luvio, response);
 }
-function ingestSuccess$O(luvio, resourceParams, response) {
+function ingestSuccess$P(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$l(luvio, body);
     luvio.storeIngest(key, ingest$p, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$1f(),
+        node: select$1g(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3037,7 +3037,7 @@ function ingestSuccess$O(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$$(config) {
+function createResourceRequest$10(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -3051,13 +3051,13 @@ function createResourceRequest$$(config) {
     };
 }
 
-const adapterName$$ = 'cloneContextMappings';
+const adapterName$10 = 'cloneContextMappings';
 const cloneContextMappings_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingClones', true, 2 /* Body */, 4 /* Unsupported */, true),
 ];
-const cloneContextMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$$, cloneContextMappings_ConfigPropertyMetadata);
-const createResourceParams$$ = /*#__PURE__*/ createResourceParams$13(cloneContextMappings_ConfigPropertyMetadata);
-function typeCheckConfig$$(untrustedConfig) {
+const cloneContextMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$10, cloneContextMappings_ConfigPropertyMetadata);
+const createResourceParams$10 = /*#__PURE__*/ createResourceParams$14(cloneContextMappings_ConfigPropertyMetadata);
+function typeCheckConfig$10(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextMappingClones = untrustedConfig.contextMappingClones;
     if (ArrayIsArray$1(untrustedConfig_contextMappingClones)) {
@@ -3073,30 +3073,30 @@ function typeCheckConfig$$(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$$(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$10(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$$(untrustedConfig);
+    const config = typeCheckConfig$10(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$$(luvio, config, options) {
-    const resourceParams = createResourceParams$$(config);
-    const request = createResourceRequest$$(resourceParams);
+function buildNetworkSnapshot$10(luvio, config, options) {
+    const resourceParams = createResourceParams$10(config);
+    const request = createResourceRequest$10(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$O(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$P(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$$(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$10(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3106,12 +3106,12 @@ function buildNetworkSnapshot$$(luvio, config, options) {
 }
 const cloneContextMappingsAdapterFactory = (luvio) => {
     return function cloneContextMappings(untrustedConfig) {
-        const config = validateAdapterConfig$$(untrustedConfig, cloneContextMappings_ConfigPropertyNames);
+        const config = validateAdapterConfig$10(untrustedConfig, cloneContextMappings_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "cloneContextMappings"');
         }
-        return buildNetworkSnapshot$$(luvio, config);
+        return buildNetworkSnapshot$10(luvio, config);
     };
 };
 
@@ -3255,7 +3255,7 @@ function keyBuilderFromType$k(luvio, object) {
 function normalize$o(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$1e = function ContextDefinitionTransformationRepresentationSelect() {
+const select$1f = function ContextDefinitionTransformationRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$s,
@@ -3570,7 +3570,7 @@ function normalize$n(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$1d = function ContextDefinitionTransformationListRepresentationSelect() {
+const select$1e = function ContextDefinitionTransformationListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$r,
@@ -3590,7 +3590,7 @@ const select$1d = function ContextDefinitionTransformationListRepresentationSele
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$1e()
+                fragment: select$1f()
             },
             {
                 name: 'isSuccess',
@@ -3680,19 +3680,19 @@ function getTypeCacheKeys$n(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
 
-function select$1c(luvio, params) {
-    return select$1d();
+function select$1d(luvio, params) {
+    return select$1e();
 }
-function getResponseCacheKeys$_(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$$(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$n(storeKeyMap, luvio, response);
 }
-function ingestSuccess$N(luvio, resourceParams, response) {
+function ingestSuccess$O(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$j(luvio, body);
     luvio.storeIngest(key, ingest$n, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$1c(),
+        node: select$1d(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3703,7 +3703,7 @@ function ingestSuccess$N(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$_(config) {
+function createResourceRequest$$(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -3717,16 +3717,16 @@ function createResourceRequest$_(config) {
     };
 }
 
-const adapterName$_ = 'contextDefinitionTransformationClone';
+const adapterName$$ = 'contextDefinitionTransformationClone';
 const contextDefinitionTransformationClone_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextDefinitionTransformationClones', true, 2 /* Body */, 4 /* Unsupported */, true),
 ];
-const contextDefinitionTransformationClone_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$_, contextDefinitionTransformationClone_ConfigPropertyMetadata);
-const createResourceParams$_ = /*#__PURE__*/ createResourceParams$13(contextDefinitionTransformationClone_ConfigPropertyMetadata);
-function typeCheckConfig$_(untrustedConfig) {
+const contextDefinitionTransformationClone_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$$, contextDefinitionTransformationClone_ConfigPropertyMetadata);
+const createResourceParams$$ = /*#__PURE__*/ createResourceParams$14(contextDefinitionTransformationClone_ConfigPropertyMetadata);
+function typeCheckConfig$$(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, contextDefinitionTransformationClone_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, contextDefinitionTransformationClone_ConfigPropertyMetadata);
     const untrustedConfig_contextDefinitionTransformationClones = untrustedConfig.contextDefinitionTransformationClones;
     if (ArrayIsArray$1(untrustedConfig_contextDefinitionTransformationClones)) {
         const untrustedConfig_contextDefinitionTransformationClones_array = [];
@@ -3741,30 +3741,30 @@ function typeCheckConfig$_(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$_(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$$(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$_(untrustedConfig);
+    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);
+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$N(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$O(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$_(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$$(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3774,12 +3774,12 @@ function buildNetworkSnapshot$_(luvio, config, options) {
 }
 const contextDefinitionTransformationCloneAdapterFactory = (luvio) => {
     return function contextDefinitionTransformationClone(untrustedConfig) {
-        const config = validateAdapterConfig$_(untrustedConfig, contextDefinitionTransformationClone_ConfigPropertyNames);
+        const config = validateAdapterConfig$$(untrustedConfig, contextDefinitionTransformationClone_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "contextDefinitionTransformationClone"');
         }
-        return buildNetworkSnapshot$_(luvio, config);
+        return buildNetworkSnapshot$$(luvio, config);
     };
 };
 
@@ -3832,19 +3832,19 @@ function validate$L(obj, path = 'ContextAttributeMappingInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function select$1b(luvio, params) {
-    return select$1j();
+function select$1c(luvio, params) {
+    return select$1k();
 }
-function getResponseCacheKeys$Z(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$_(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$s(storeKeyMap, luvio, response);
 }
-function ingestSuccess$M(luvio, resourceParams, response) {
+function ingestSuccess$N(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$o(luvio, body);
     luvio.storeIngest(key, ingest$s, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$1b(),
+        node: select$1c(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3855,7 +3855,7 @@ function ingestSuccess$M(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$Z(config) {
+function createResourceRequest$_(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -3869,13 +3869,13 @@ function createResourceRequest$Z(config) {
     };
 }
 
-const adapterName$Z = 'createContextAttributeMapping';
+const adapterName$_ = 'createContextAttributeMapping';
 const createContextAttributeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$Z, createContextAttributeMapping_ConfigPropertyMetadata);
-const createResourceParams$Z = /*#__PURE__*/ createResourceParams$13(createContextAttributeMapping_ConfigPropertyMetadata);
-function typeCheckConfig$Z(untrustedConfig) {
+const createContextAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$_, createContextAttributeMapping_ConfigPropertyMetadata);
+const createResourceParams$_ = /*#__PURE__*/ createResourceParams$14(createContextAttributeMapping_ConfigPropertyMetadata);
+function typeCheckConfig$_(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextAttributeMappingInput = untrustedConfig.contextAttributeMappingInput;
     const referenceContextAttributeMappingInputRepresentationValidationError = validate$L(untrustedConfig_contextAttributeMappingInput);
@@ -3884,30 +3884,30 @@ function typeCheckConfig$Z(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$Z(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$_(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$Z(untrustedConfig);
+    const config = typeCheckConfig$_(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$Z(luvio, config, options) {
-    const resourceParams = createResourceParams$Z(config);
-    const request = createResourceRequest$Z(resourceParams);
+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$M(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$N(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$Z(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$_(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3917,12 +3917,12 @@ function buildNetworkSnapshot$Z(luvio, config, options) {
 }
 const createContextAttributeMappingAdapterFactory = (luvio) => {
     return function createContextAttributeMapping(untrustedConfig) {
-        const config = validateAdapterConfig$Z(untrustedConfig, createContextAttributeMapping_ConfigPropertyNames);
+        const config = validateAdapterConfig$_(untrustedConfig, createContextAttributeMapping_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextAttributeMapping"');
         }
-        return buildNetworkSnapshot$Z(luvio, config);
+        return buildNetworkSnapshot$_(luvio, config);
     };
 };
 
@@ -4023,7 +4023,7 @@ function normalize$m(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$1a = function ContextAttributeMappingListRepresentationSelect() {
+const select$1b = function ContextAttributeMappingListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$q,
@@ -4038,7 +4038,7 @@ const select$1a = function ContextAttributeMappingListRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$1j()
+                fragment: select$1k()
             },
             {
                 name: 'isSuccess',
@@ -4115,19 +4115,19 @@ function getTypeCacheKeys$m(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
 
-function select$19(luvio, params) {
-    return select$1a();
+function select$1a(luvio, params) {
+    return select$1b();
 }
-function getResponseCacheKeys$Y(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$Z(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$m(storeKeyMap, luvio, response);
 }
-function ingestSuccess$L(luvio, resourceParams, response) {
+function ingestSuccess$M(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$i(luvio, body);
     luvio.storeIngest(key, ingest$m, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$19(),
+        node: select$1a(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -4138,7 +4138,7 @@ function ingestSuccess$L(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$Y(config) {
+function createResourceRequest$Z(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -4152,16 +4152,16 @@ function createResourceRequest$Y(config) {
     };
 }
 
-const adapterName$Y = 'createContextAttributeMappings';
+const adapterName$Z = 'createContextAttributeMappings';
 const createContextAttributeMappings_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextAttributeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextAttributeMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$Y, createContextAttributeMappings_ConfigPropertyMetadata);
-const createResourceParams$Y = /*#__PURE__*/ createResourceParams$13(createContextAttributeMappings_ConfigPropertyMetadata);
-function typeCheckConfig$Y(untrustedConfig) {
+const createContextAttributeMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$Z, createContextAttributeMappings_ConfigPropertyMetadata);
+const createResourceParams$Z = /*#__PURE__*/ createResourceParams$14(createContextAttributeMappings_ConfigPropertyMetadata);
+function typeCheckConfig$Z(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, createContextAttributeMappings_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, createContextAttributeMappings_ConfigPropertyMetadata);
     const untrustedConfig_contextAttributeMappingInput = untrustedConfig.contextAttributeMappingInput;
     const referenceContextAttributeMappingListInputRepresentationValidationError = validate$K(untrustedConfig_contextAttributeMappingInput);
     if (referenceContextAttributeMappingListInputRepresentationValidationError === null) {
@@ -4169,30 +4169,30 @@ function typeCheckConfig$Y(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$Y(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$Z(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$Y(untrustedConfig);
+    const config = typeCheckConfig$Z(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$Y(luvio, config, options) {
-    const resourceParams = createResourceParams$Y(config);
-    const request = createResourceRequest$Y(resourceParams);
+function buildNetworkSnapshot$Z(luvio, config, options) {
+    const resourceParams = createResourceParams$Z(config);
+    const request = createResourceRequest$Z(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$L(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$M(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$Y(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$Z(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -4202,12 +4202,12 @@ function buildNetworkSnapshot$Y(luvio, config, options) {
 }
 const createContextAttributeMappingsAdapterFactory = (luvio) => {
     return function createContextAttributeMappings(untrustedConfig) {
-        const config = validateAdapterConfig$Y(untrustedConfig, createContextAttributeMappings_ConfigPropertyNames);
+        const config = validateAdapterConfig$Z(untrustedConfig, createContextAttributeMappings_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextAttributeMappings"');
         }
-        return buildNetworkSnapshot$Y(luvio, config);
+        return buildNetworkSnapshot$Z(luvio, config);
     };
 };
 
@@ -4295,7 +4295,7 @@ function keyBuilderFromType$h(luvio, object) {
 function normalize$l(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$18 = function ContextAttributeTagRepresentationSelect() {
+const select$19 = function ContextAttributeTagRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$p,
@@ -4596,7 +4596,7 @@ function normalize$k(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$17 = function ContextAttributeRepresentationSelect() {
+const select$18 = function ContextAttributeRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$o,
@@ -4616,7 +4616,7 @@ const select$17 = function ContextAttributeRepresentationSelect() {
                 name: 'attributeTags',
                 kind: 'Link',
                 plural: true,
-                fragment: select$18()
+                fragment: select$19()
             },
             {
                 name: 'baseReference',
@@ -4963,8 +4963,11 @@ function validate$F(obj, path = 'ContextAttributeListRepresentation') {
             for (let i = 0; i < obj_attributes.length; i++) {
                 const obj_attributes_item = obj_attributes[i];
                 const path_attributes_item = path_attributes + '[' + i + ']';
-                if (typeof obj_attributes_item !== 'object' || Array.isArray(obj_attributes_item)) {
-                    return new TypeError('Expected "object" but received "' + typeof obj_attributes_item + '" (at "' + path_attributes_item + '")');
+                const referencepath_attributes_itemValidationError = validate$G(obj_attributes_item, path_attributes_item);
+                if (referencepath_attributes_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match ContextAttributeRepresentation (at "' + path_attributes_item + '")\n';
+                    message += referencepath_attributes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
                 }
             }
         }
@@ -4999,97 +5002,20 @@ function keyBuilderFromType$f(luvio, object) {
     return keyBuilder$14(luvio, keyParams);
 }
 function normalize$j(input, existing, path, luvio, store, timestamp) {
-    const input_attributes = input.attributes;
-    const input_attributes_id = path.fullPath + '__attributes';
-    if (input_attributes !== undefined) {
-        for (let i = 0; i < input_attributes.length; i++) {
-            const input_attributes_item = input_attributes[i];
-            let input_attributes_item_id = input_attributes_id + '__' + i;
-            input_attributes[i] = ingest$k(input_attributes_item, {
-                fullPath: input_attributes_item_id,
-                propertyName: i,
-                parent: {
-                    data: input,
-                    key: path.fullPath,
-                    existing: existing,
-                },
-                ttl: path.ttl
-            }, luvio, store, timestamp);
-        }
-    }
     return input;
 }
-const select$16 = function ContextAttributeListRepresentationSelect() {
+const select$17 = function ContextAttributeListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$n,
         private: [],
-        selections: [
-            {
-                name: 'attributes',
-                kind: 'Link',
-                plural: true,
-                required: false,
-                fragment: select$17()
-            },
-            {
-                name: 'contextAttributeListId',
-                kind: 'Scalar'
-            },
-            {
-                name: 'contextNodeId',
-                kind: 'Scalar'
-            },
-            {
-                name: 'isSuccess',
-                kind: 'Scalar',
-                required: false
-            }
-        ]
+        opaque: true
     };
 };
 function equals$n(existing, incoming) {
-    const existing_isSuccess = existing.isSuccess;
-    const incoming_isSuccess = incoming.isSuccess;
-    // if at least one of these optionals is defined
-    if (existing_isSuccess !== undefined || incoming_isSuccess !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_isSuccess === undefined || incoming_isSuccess === undefined) {
-            return false;
-        }
-        if (!(existing_isSuccess === incoming_isSuccess)) {
-            return false;
-        }
-    }
-    const existing_contextAttributeListId = existing.contextAttributeListId;
-    const incoming_contextAttributeListId = incoming.contextAttributeListId;
-    if (!(existing_contextAttributeListId === incoming_contextAttributeListId)) {
-        return false;
-    }
-    const existing_contextNodeId = existing.contextNodeId;
-    const incoming_contextNodeId = incoming.contextNodeId;
-    if (!(existing_contextNodeId === incoming_contextNodeId)) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
-    const existing_attributes = existing.attributes;
-    const incoming_attributes = incoming.attributes;
-    // if at least one of these optionals is defined
-    if (existing_attributes !== undefined || incoming_attributes !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_attributes === undefined || incoming_attributes === undefined) {
-            return false;
-        }
-        const equals_attributes_items = equalsArray(existing_attributes, incoming_attributes, (existing_attributes_item, incoming_attributes_item) => {
-            if (!(existing_attributes_item.__ref === incoming_attributes_item.__ref)) {
-                return false;
-            }
-        });
-        if (equals_attributes_items === false) {
-            return false;
-        }
-    }
     return true;
 }
 const ingest$j = function ContextAttributeListRepresentationIngest(input, path, luvio, store, timestamp) {
@@ -5112,27 +5038,21 @@ function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
         representationName: RepresentationType$j,
         mergeable: false
     });
-    if (input.attributes !== undefined) {
-        const input_attributes_length = input.attributes.length;
-        for (let i = 0; i < input_attributes_length; i++) {
-            getTypeCacheKeys$k(rootKeySet, luvio, input.attributes[i]);
-        }
-    }
 }
 
-function select$15(luvio, params) {
-    return select$16();
+function select$16(luvio, params) {
+    return select$17();
 }
-function getResponseCacheKeys$X(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$Y(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$j(storeKeyMap, luvio, response);
 }
-function ingestSuccess$K(luvio, resourceParams, response) {
+function ingestSuccess$L(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$f(luvio, body);
     luvio.storeIngest(key, ingest$j, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$15(),
+        node: select$16(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -5143,7 +5063,7 @@ function ingestSuccess$K(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$X(config) {
+function createResourceRequest$Y(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -5157,16 +5077,16 @@ function createResourceRequest$X(config) {
     };
 }
 
-const adapterName$X = 'createContextAttributes';
+const adapterName$Y = 'createContextAttributes';
 const createContextAttributes_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextAttributeListInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextAttributes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$X, createContextAttributes_ConfigPropertyMetadata);
-const createResourceParams$X = /*#__PURE__*/ createResourceParams$13(createContextAttributes_ConfigPropertyMetadata);
-function typeCheckConfig$X(untrustedConfig) {
+const createContextAttributes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$Y, createContextAttributes_ConfigPropertyMetadata);
+const createResourceParams$Y = /*#__PURE__*/ createResourceParams$14(createContextAttributes_ConfigPropertyMetadata);
+function typeCheckConfig$Y(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, createContextAttributes_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, createContextAttributes_ConfigPropertyMetadata);
     const untrustedConfig_contextAttributeListInput = untrustedConfig.contextAttributeListInput;
     const referenceContextAttributesListInputRepresentationValidationError = validate$I(untrustedConfig_contextAttributeListInput);
     if (referenceContextAttributesListInputRepresentationValidationError === null) {
@@ -5174,30 +5094,30 @@ function typeCheckConfig$X(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$X(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$Y(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$X(untrustedConfig);
+    const config = typeCheckConfig$Y(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$X(luvio, config, options) {
-    const resourceParams = createResourceParams$X(config);
-    const request = createResourceRequest$X(resourceParams);
+function buildNetworkSnapshot$Y(luvio, config, options) {
+    const resourceParams = createResourceParams$Y(config);
+    const request = createResourceRequest$Y(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$K(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$L(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$X(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$Y(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -5207,12 +5127,12 @@ function buildNetworkSnapshot$X(luvio, config, options) {
 }
 const createContextAttributesAdapterFactory = (luvio) => {
     return function createContextAttributes(untrustedConfig) {
-        const config = validateAdapterConfig$X(untrustedConfig, createContextAttributes_ConfigPropertyNames);
+        const config = validateAdapterConfig$Y(untrustedConfig, createContextAttributes_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextAttributes"');
         }
-        return buildNetworkSnapshot$X(luvio, config);
+        return buildNetworkSnapshot$Y(luvio, config);
     };
 };
 
@@ -5344,7 +5264,7 @@ function keyBuilderFromType$e(luvio, object) {
 function normalize$i(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$14 = function ContextDefinitionFilterRepresentationSelect() {
+const select$15 = function ContextDefinitionFilterRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$m,
@@ -5585,7 +5505,7 @@ function normalize$h(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$13 = function ContextDefinitionFilterListRepresentationSelect() {
+const select$14 = function ContextDefinitionFilterListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$l,
@@ -5596,7 +5516,7 @@ const select$13 = function ContextDefinitionFilterListRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$14()
+                fragment: select$15()
             },
             {
                 name: 'contextDefinitionFilterListId',
@@ -5686,19 +5606,19 @@ function getTypeCacheKeys$h(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
 
-function select$12(luvio, params) {
-    return select$13();
+function select$13(luvio, params) {
+    return select$14();
 }
-function getResponseCacheKeys$W(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$X(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$h(storeKeyMap, luvio, response);
 }
-function ingestSuccess$J(luvio, resourceParams, response) {
+function ingestSuccess$K(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$d(luvio, body);
     luvio.storeIngest(key, ingest$h, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$12(),
+        node: select$13(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -5709,7 +5629,7 @@ function ingestSuccess$J(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$W(config) {
+function createResourceRequest$X(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -5723,16 +5643,16 @@ function createResourceRequest$W(config) {
     };
 }
 
-const adapterName$W = 'createContextFilters';
+const adapterName$X = 'createContextFilters';
 const createContextFilters_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('filters', true, 2 /* Body */, 4 /* Unsupported */, true),
 ];
-const createContextFilters_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$W, createContextFilters_ConfigPropertyMetadata);
-const createResourceParams$W = /*#__PURE__*/ createResourceParams$13(createContextFilters_ConfigPropertyMetadata);
-function typeCheckConfig$W(untrustedConfig) {
+const createContextFilters_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$X, createContextFilters_ConfigPropertyMetadata);
+const createResourceParams$X = /*#__PURE__*/ createResourceParams$14(createContextFilters_ConfigPropertyMetadata);
+function typeCheckConfig$X(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, createContextFilters_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, createContextFilters_ConfigPropertyMetadata);
     const untrustedConfig_filters = untrustedConfig.filters;
     if (ArrayIsArray$1(untrustedConfig_filters)) {
         const untrustedConfig_filters_array = [];
@@ -5747,30 +5667,30 @@ function typeCheckConfig$W(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$W(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$X(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$W(untrustedConfig);
+    const config = typeCheckConfig$X(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$W(luvio, config, options) {
-    const resourceParams = createResourceParams$W(config);
-    const request = createResourceRequest$W(resourceParams);
+function buildNetworkSnapshot$X(luvio, config, options) {
+    const resourceParams = createResourceParams$X(config);
+    const request = createResourceRequest$X(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$J(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$K(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$W(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$X(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -5780,12 +5700,12 @@ function buildNetworkSnapshot$W(luvio, config, options) {
 }
 const createContextFiltersAdapterFactory = (luvio) => {
     return function createContextFilters(untrustedConfig) {
-        const config = validateAdapterConfig$W(untrustedConfig, createContextFilters_ConfigPropertyNames);
+        const config = validateAdapterConfig$X(untrustedConfig, createContextFilters_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextFilters"');
         }
-        return buildNetworkSnapshot$W(luvio, config);
+        return buildNetworkSnapshot$X(luvio, config);
     };
 };
 
@@ -5850,19 +5770,19 @@ function validate$B(obj, path = 'ContextMappingInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function select$11(luvio, params) {
-    return select$1h();
+function select$12(luvio, params) {
+    return select$1i();
 }
-function getResponseCacheKeys$V(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$W(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$q(storeKeyMap, luvio, response);
 }
-function ingestSuccess$I(luvio, resourceParams, response) {
+function ingestSuccess$J(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$m(luvio, body);
     luvio.storeIngest(key, ingest$q, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$11(),
+        node: select$12(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -5873,7 +5793,7 @@ function ingestSuccess$I(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$V(config) {
+function createResourceRequest$W(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -5887,13 +5807,13 @@ function createResourceRequest$V(config) {
     };
 }
 
-const adapterName$V = 'createContextMapping';
+const adapterName$W = 'createContextMapping';
 const createContextMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$V, createContextMapping_ConfigPropertyMetadata);
-const createResourceParams$V = /*#__PURE__*/ createResourceParams$13(createContextMapping_ConfigPropertyMetadata);
-function typeCheckConfig$V(untrustedConfig) {
+const createContextMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$W, createContextMapping_ConfigPropertyMetadata);
+const createResourceParams$W = /*#__PURE__*/ createResourceParams$14(createContextMapping_ConfigPropertyMetadata);
+function typeCheckConfig$W(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextMappingInput = untrustedConfig.contextMappingInput;
     const referenceContextMappingInputRepresentationValidationError = validate$B(untrustedConfig_contextMappingInput);
@@ -5902,30 +5822,30 @@ function typeCheckConfig$V(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$V(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$W(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$V(untrustedConfig);
+    const config = typeCheckConfig$W(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$V(luvio, config, options) {
-    const resourceParams = createResourceParams$V(config);
-    const request = createResourceRequest$V(resourceParams);
+function buildNetworkSnapshot$W(luvio, config, options) {
+    const resourceParams = createResourceParams$W(config);
+    const request = createResourceRequest$W(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$I(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$J(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$V(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$W(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -5935,12 +5855,12 @@ function buildNetworkSnapshot$V(luvio, config, options) {
 }
 const createContextMappingAdapterFactory = (luvio) => {
     return function createContextMapping(untrustedConfig) {
-        const config = validateAdapterConfig$V(untrustedConfig, createContextMapping_ConfigPropertyNames);
+        const config = validateAdapterConfig$W(untrustedConfig, createContextMapping_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextMapping"');
         }
-        return buildNetworkSnapshot$V(luvio, config);
+        return buildNetworkSnapshot$W(luvio, config);
     };
 };
 
@@ -5979,19 +5899,19 @@ function validate$A(obj, path = 'ContextMappingListInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function select$10(luvio, params) {
-    return select$1g();
+function select$11(luvio, params) {
+    return select$1h();
 }
-function getResponseCacheKeys$U(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$V(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$p(storeKeyMap, luvio, response);
 }
-function ingestSuccess$H(luvio, resourceParams, response) {
+function ingestSuccess$I(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$l(luvio, body);
     luvio.storeIngest(key, ingest$p, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$10(),
+        node: select$11(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -6002,7 +5922,7 @@ function ingestSuccess$H(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$U(config) {
+function createResourceRequest$V(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -6016,16 +5936,16 @@ function createResourceRequest$U(config) {
     };
 }
 
-const adapterName$U = 'createContextMappings';
+const adapterName$V = 'createContextMappings';
 const createContextMappings_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$U, createContextMappings_ConfigPropertyMetadata);
-const createResourceParams$U = /*#__PURE__*/ createResourceParams$13(createContextMappings_ConfigPropertyMetadata);
-function typeCheckConfig$U(untrustedConfig) {
+const createContextMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$V, createContextMappings_ConfigPropertyMetadata);
+const createResourceParams$V = /*#__PURE__*/ createResourceParams$14(createContextMappings_ConfigPropertyMetadata);
+function typeCheckConfig$V(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, createContextMappings_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, createContextMappings_ConfigPropertyMetadata);
     const untrustedConfig_contextMappingInput = untrustedConfig.contextMappingInput;
     const referenceContextMappingListInputRepresentationValidationError = validate$A(untrustedConfig_contextMappingInput);
     if (referenceContextMappingListInputRepresentationValidationError === null) {
@@ -6033,30 +5953,30 @@ function typeCheckConfig$U(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$U(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$V(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$U(untrustedConfig);
+    const config = typeCheckConfig$V(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$U(luvio, config, options) {
-    const resourceParams = createResourceParams$U(config);
-    const request = createResourceRequest$U(resourceParams);
+function buildNetworkSnapshot$V(luvio, config, options) {
+    const resourceParams = createResourceParams$V(config);
+    const request = createResourceRequest$V(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$H(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$I(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$U(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$V(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -6066,12 +5986,12 @@ function buildNetworkSnapshot$U(luvio, config, options) {
 }
 const createContextMappingsAdapterFactory = (luvio) => {
     return function createContextMappings(untrustedConfig) {
-        const config = validateAdapterConfig$U(untrustedConfig, createContextMappings_ConfigPropertyNames);
+        const config = validateAdapterConfig$V(untrustedConfig, createContextMappings_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextMappings"');
         }
-        return buildNetworkSnapshot$U(luvio, config);
+        return buildNetworkSnapshot$V(luvio, config);
     };
 };
 
@@ -6111,19 +6031,19 @@ function validate$z(obj, path = 'ContextNodeMappingInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function select$$(luvio, params) {
-    return select$1i();
+function select$10(luvio, params) {
+    return select$1j();
 }
-function getResponseCacheKeys$T(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$U(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$r(storeKeyMap, luvio, response);
 }
-function ingestSuccess$G(luvio, resourceParams, response) {
+function ingestSuccess$H(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$n(luvio, body);
     luvio.storeIngest(key, ingest$r, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$$(),
+        node: select$10(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -6134,7 +6054,7 @@ function ingestSuccess$G(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$T(config) {
+function createResourceRequest$U(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -6148,13 +6068,13 @@ function createResourceRequest$T(config) {
     };
 }
 
-const adapterName$T = 'createContextNodeMapping';
+const adapterName$U = 'createContextNodeMapping';
 const createContextNodeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$T, createContextNodeMapping_ConfigPropertyMetadata);
-const createResourceParams$T = /*#__PURE__*/ createResourceParams$13(createContextNodeMapping_ConfigPropertyMetadata);
-function typeCheckConfig$T(untrustedConfig) {
+const createContextNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$U, createContextNodeMapping_ConfigPropertyMetadata);
+const createResourceParams$U = /*#__PURE__*/ createResourceParams$14(createContextNodeMapping_ConfigPropertyMetadata);
+function typeCheckConfig$U(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextNodeMappingInput = untrustedConfig.contextNodeMappingInput;
     const referenceContextNodeMappingInputRepresentationValidationError = validate$z(untrustedConfig_contextNodeMappingInput);
@@ -6163,30 +6083,30 @@ function typeCheckConfig$T(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$T(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$U(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$T(untrustedConfig);
+    const config = typeCheckConfig$U(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$T(luvio, config, options) {
-    const resourceParams = createResourceParams$T(config);
-    const request = createResourceRequest$T(resourceParams);
+function buildNetworkSnapshot$U(luvio, config, options) {
+    const resourceParams = createResourceParams$U(config);
+    const request = createResourceRequest$U(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$G(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$H(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$T(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$U(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -6196,12 +6116,12 @@ function buildNetworkSnapshot$T(luvio, config, options) {
 }
 const createContextNodeMappingAdapterFactory = (luvio) => {
     return function createContextNodeMapping(untrustedConfig) {
-        const config = validateAdapterConfig$T(untrustedConfig, createContextNodeMapping_ConfigPropertyNames);
+        const config = validateAdapterConfig$U(untrustedConfig, createContextNodeMapping_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextNodeMapping"');
         }
-        return buildNetworkSnapshot$T(luvio, config);
+        return buildNetworkSnapshot$U(luvio, config);
     };
 };
 
@@ -6293,7 +6213,7 @@ function normalize$g(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$_ = function ContextNodeMappingListRepresentationSelect() {
+const select$$ = function ContextNodeMappingListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$k,
@@ -6308,7 +6228,7 @@ const select$_ = function ContextNodeMappingListRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$1i()
+                fragment: select$1j()
             },
             {
                 name: 'isSuccess',
@@ -6385,19 +6305,19 @@ function getTypeCacheKeys$g(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
 
-function select$Z(luvio, params) {
-    return select$_();
+function select$_(luvio, params) {
+    return select$$();
 }
-function getResponseCacheKeys$S(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$T(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$g(storeKeyMap, luvio, response);
 }
-function ingestSuccess$F(luvio, resourceParams, response) {
+function ingestSuccess$G(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$c(luvio, body);
     luvio.storeIngest(key, ingest$g, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$Z(),
+        node: select$_(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -6408,7 +6328,7 @@ function ingestSuccess$F(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$S(config) {
+function createResourceRequest$T(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -6422,16 +6342,16 @@ function createResourceRequest$S(config) {
     };
 }
 
-const adapterName$S = 'createContextNodeMappings';
+const adapterName$T = 'createContextNodeMappings';
 const createContextNodeMappings_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextNodeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextNodeMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$S, createContextNodeMappings_ConfigPropertyMetadata);
-const createResourceParams$S = /*#__PURE__*/ createResourceParams$13(createContextNodeMappings_ConfigPropertyMetadata);
-function typeCheckConfig$S(untrustedConfig) {
+const createContextNodeMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$T, createContextNodeMappings_ConfigPropertyMetadata);
+const createResourceParams$T = /*#__PURE__*/ createResourceParams$14(createContextNodeMappings_ConfigPropertyMetadata);
+function typeCheckConfig$T(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, createContextNodeMappings_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, createContextNodeMappings_ConfigPropertyMetadata);
     const untrustedConfig_contextNodeMappingInput = untrustedConfig.contextNodeMappingInput;
     const referenceContextNodeMappingListInputRepresentationValidationError = validate$y(untrustedConfig_contextNodeMappingInput);
     if (referenceContextNodeMappingListInputRepresentationValidationError === null) {
@@ -6439,30 +6359,30 @@ function typeCheckConfig$S(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$S(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$T(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$S(untrustedConfig);
+    const config = typeCheckConfig$T(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$S(luvio, config, options) {
-    const resourceParams = createResourceParams$S(config);
-    const request = createResourceRequest$S(resourceParams);
+function buildNetworkSnapshot$T(luvio, config, options) {
+    const resourceParams = createResourceParams$T(config);
+    const request = createResourceRequest$T(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$F(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$G(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$S(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$T(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -6472,12 +6392,12 @@ function buildNetworkSnapshot$S(luvio, config, options) {
 }
 const createContextNodeMappingsAdapterFactory = (luvio) => {
     return function createContextNodeMappings(untrustedConfig) {
-        const config = validateAdapterConfig$S(untrustedConfig, createContextNodeMappings_ConfigPropertyNames);
+        const config = validateAdapterConfig$T(untrustedConfig, createContextNodeMappings_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextNodeMappings"');
         }
-        return buildNetworkSnapshot$S(luvio, config);
+        return buildNetworkSnapshot$T(luvio, config);
     };
 };
 
@@ -6639,7 +6559,7 @@ function keyBuilderFromType$b(luvio, object) {
 function normalize$f(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$Y = function ContextNodeRepresentationSelect() {
+const select$Z = function ContextNodeRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$j,
@@ -6742,7 +6662,7 @@ function normalize$e(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$X = function ContextNodeListRepresentationSelect() {
+const select$Y = function ContextNodeListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$i,
@@ -6757,7 +6677,7 @@ const select$X = function ContextNodeListRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$Y()
+                fragment: select$Z()
             },
             {
                 name: 'isSuccess',
@@ -6834,19 +6754,19 @@ function getTypeCacheKeys$e(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
 
-function select$W(luvio, params) {
-    return select$X();
+function select$X(luvio, params) {
+    return select$Y();
 }
-function getResponseCacheKeys$R(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$S(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$e(storeKeyMap, luvio, response);
 }
-function ingestSuccess$E(luvio, resourceParams, response) {
+function ingestSuccess$F(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$a(luvio, body);
     luvio.storeIngest(key, ingest$e, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$W(),
+        node: select$X(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -6857,7 +6777,7 @@ function ingestSuccess$E(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$R(config) {
+function createResourceRequest$S(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -6871,16 +6791,16 @@ function createResourceRequest$R(config) {
     };
 }
 
-const adapterName$R = 'createContextNodes';
+const adapterName$S = 'createContextNodes';
 const createContextNodes_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextNodeInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextNodes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$R, createContextNodes_ConfigPropertyMetadata);
-const createResourceParams$R = /*#__PURE__*/ createResourceParams$13(createContextNodes_ConfigPropertyMetadata);
-function typeCheckConfig$R(untrustedConfig) {
+const createContextNodes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$S, createContextNodes_ConfigPropertyMetadata);
+const createResourceParams$S = /*#__PURE__*/ createResourceParams$14(createContextNodes_ConfigPropertyMetadata);
+function typeCheckConfig$S(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, createContextNodes_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, createContextNodes_ConfigPropertyMetadata);
     const untrustedConfig_contextNodeInput = untrustedConfig.contextNodeInput;
     const referenceContextNodeListInputRepresentationValidationError = validate$w(untrustedConfig_contextNodeInput);
     if (referenceContextNodeListInputRepresentationValidationError === null) {
@@ -6888,30 +6808,30 @@ function typeCheckConfig$R(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$R(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$S(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$R(untrustedConfig);
+    const config = typeCheckConfig$S(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$R(luvio, config, options) {
-    const resourceParams = createResourceParams$R(config);
-    const request = createResourceRequest$R(resourceParams);
+function buildNetworkSnapshot$S(luvio, config, options) {
+    const resourceParams = createResourceParams$S(config);
+    const request = createResourceRequest$S(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$E(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$F(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$R(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$S(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -6921,12 +6841,12 @@ function buildNetworkSnapshot$R(luvio, config, options) {
 }
 const createContextNodesAdapterFactory = (luvio) => {
     return function createContextNodes(untrustedConfig) {
-        const config = validateAdapterConfig$R(untrustedConfig, createContextNodes_ConfigPropertyNames);
+        const config = validateAdapterConfig$S(untrustedConfig, createContextNodes_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextNodes"');
         }
-        return buildNetworkSnapshot$R(luvio, config);
+        return buildNetworkSnapshot$S(luvio, config);
     };
 };
 
@@ -6967,19 +6887,19 @@ function validate$t(obj, path = 'QueryRecordsInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function select$V(luvio, params) {
-    return select$1r();
+function select$W(luvio, params) {
+    return select$1s();
 }
-function getResponseCacheKeys$Q(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$R(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$w(storeKeyMap, luvio, response);
 }
-function ingestSuccess$D(luvio, resourceParams, response) {
+function ingestSuccess$E(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$s(luvio, body);
     luvio.storeIngest(key, ingest$w, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$V(),
+        node: select$W(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -6990,7 +6910,7 @@ function ingestSuccess$D(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$Q(config) {
+function createResourceRequest$R(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -7004,13 +6924,13 @@ function createResourceRequest$Q(config) {
     };
 }
 
-const adapterName$Q = 'createContextQueryRecords';
+const adapterName$R = 'createContextQueryRecords';
 const createContextQueryRecords_ConfigPropertyMetadata = [
     generateParamConfigMetadata('queryRecordsInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextQueryRecords_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$Q, createContextQueryRecords_ConfigPropertyMetadata);
-const createResourceParams$Q = /*#__PURE__*/ createResourceParams$13(createContextQueryRecords_ConfigPropertyMetadata);
-function typeCheckConfig$Q(untrustedConfig) {
+const createContextQueryRecords_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$R, createContextQueryRecords_ConfigPropertyMetadata);
+const createResourceParams$R = /*#__PURE__*/ createResourceParams$14(createContextQueryRecords_ConfigPropertyMetadata);
+function typeCheckConfig$R(untrustedConfig) {
     const config = {};
     const untrustedConfig_queryRecordsInput = untrustedConfig.queryRecordsInput;
     const referenceQueryRecordsInputRepresentationValidationError = validate$t(untrustedConfig_queryRecordsInput);
@@ -7019,30 +6939,30 @@ function typeCheckConfig$Q(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$Q(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$R(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$Q(untrustedConfig);
+    const config = typeCheckConfig$R(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$Q(luvio, config, options) {
-    const resourceParams = createResourceParams$Q(config);
-    const request = createResourceRequest$Q(resourceParams);
+function buildNetworkSnapshot$R(luvio, config, options) {
+    const resourceParams = createResourceParams$R(config);
+    const request = createResourceRequest$R(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$D(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$E(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$Q(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$R(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -7052,12 +6972,12 @@ function buildNetworkSnapshot$Q(luvio, config, options) {
 }
 const createContextQueryRecordsAdapterFactory = (luvio) => {
     return function createContextQueryRecords(untrustedConfig) {
-        const config = validateAdapterConfig$Q(untrustedConfig, createContextQueryRecords_ConfigPropertyNames);
+        const config = validateAdapterConfig$R(untrustedConfig, createContextQueryRecords_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextQueryRecords"');
         }
-        return buildNetworkSnapshot$Q(luvio, config);
+        return buildNetworkSnapshot$R(luvio, config);
     };
 };
 
@@ -7159,7 +7079,7 @@ function keyBuilderFromType$9(luvio, object) {
 function normalize$d(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$U = function QueryTagsResultRepresentationSelect() {
+const select$V = function QueryTagsResultRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$h,
@@ -7195,19 +7115,19 @@ function getTypeCacheKeys$d(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-function select$T(luvio, params) {
-    return select$U();
+function select$U(luvio, params) {
+    return select$V();
 }
-function getResponseCacheKeys$P(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$Q(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$d(storeKeyMap, luvio, response);
 }
-function ingestSuccess$C(luvio, resourceParams, response) {
+function ingestSuccess$D(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$9(luvio, body);
     luvio.storeIngest(key, ingest$d, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$T(),
+        node: select$U(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -7218,7 +7138,7 @@ function ingestSuccess$C(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$P(config) {
+function createResourceRequest$Q(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -7232,17 +7152,17 @@ function createResourceRequest$P(config) {
     };
 }
 
-const adapterName$P = 'createContextQueryTags';
+const adapterName$Q = 'createContextQueryTags';
 const createContextQueryTags_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextId', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('tags', true, 2 /* Body */, 0 /* String */, true),
     generateParamConfigMetadata('filter', false, 2 /* Body */, 4 /* Unsupported */, true),
 ];
-const createContextQueryTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$P, createContextQueryTags_ConfigPropertyMetadata);
-const createResourceParams$P = /*#__PURE__*/ createResourceParams$13(createContextQueryTags_ConfigPropertyMetadata);
-function typeCheckConfig$P(untrustedConfig) {
+const createContextQueryTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$Q, createContextQueryTags_ConfigPropertyMetadata);
+const createResourceParams$Q = /*#__PURE__*/ createResourceParams$14(createContextQueryTags_ConfigPropertyMetadata);
+function typeCheckConfig$Q(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, createContextQueryTags_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, createContextQueryTags_ConfigPropertyMetadata);
     const untrustedConfig_filter = untrustedConfig.filter;
     if (ArrayIsArray$1(untrustedConfig_filter)) {
         const untrustedConfig_filter_array = [];
@@ -7257,30 +7177,30 @@ function typeCheckConfig$P(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$P(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$Q(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$P(untrustedConfig);
+    const config = typeCheckConfig$Q(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$P(luvio, config, options) {
-    const resourceParams = createResourceParams$P(config);
-    const request = createResourceRequest$P(resourceParams);
+function buildNetworkSnapshot$Q(luvio, config, options) {
+    const resourceParams = createResourceParams$Q(config);
+    const request = createResourceRequest$Q(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$C(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$D(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$P(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$Q(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -7290,12 +7210,12 @@ function buildNetworkSnapshot$P(luvio, config, options) {
 }
 const createContextQueryTagsAdapterFactory = (luvio) => {
     return function createContextQueryTags(untrustedConfig) {
-        const config = validateAdapterConfig$P(untrustedConfig, createContextQueryTags_ConfigPropertyNames);
+        const config = validateAdapterConfig$Q(untrustedConfig, createContextQueryTags_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextQueryTags"');
         }
-        return buildNetworkSnapshot$P(luvio, config);
+        return buildNetworkSnapshot$Q(luvio, config);
     };
 };
 
@@ -7531,7 +7451,7 @@ function validate$n(obj, path = 'ContextDefinitionReferenceRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$S = function ContextDefinitionReferenceRepresentationSelect() {
+const select$T = function ContextDefinitionReferenceRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$g,
@@ -7852,8 +7772,8 @@ function keyBuilderFromType$8(luvio, object) {
 function normalize$c(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$R = function ContextDefinitionInfoRepresentationSelect() {
-    const { selections: ContextDefinitionReferenceRepresentation__selections, opaque: ContextDefinitionReferenceRepresentation__opaque, } = select$S();
+const select$S = function ContextDefinitionInfoRepresentationSelect() {
+    const { selections: ContextDefinitionReferenceRepresentation__selections, opaque: ContextDefinitionReferenceRepresentation__opaque, } = select$T();
     return {
         kind: 'Fragment',
         version: VERSION$f,
@@ -8377,19 +8297,19 @@ function getTypeCacheKeys$c(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-function select$Q(luvio, params) {
-    return select$R();
+function select$R(luvio, params) {
+    return select$S();
 }
-function getResponseCacheKeys$O(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$P(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$c(storeKeyMap, luvio, response);
 }
-function ingestSuccess$B(luvio, resourceParams, response) {
+function ingestSuccess$C(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$8(luvio, body);
     luvio.storeIngest(key, ingest$c, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$Q(),
+        node: select$R(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -8400,7 +8320,7 @@ function ingestSuccess$B(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$O(config) {
+function createResourceRequest$P(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -8414,13 +8334,13 @@ function createResourceRequest$O(config) {
     };
 }
 
-const adapterName$O = 'createContextServiceDefinition';
+const adapterName$P = 'createContextServiceDefinition';
 const createContextServiceDefinition_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$O, createContextServiceDefinition_ConfigPropertyMetadata);
-const createResourceParams$O = /*#__PURE__*/ createResourceParams$13(createContextServiceDefinition_ConfigPropertyMetadata);
-function typeCheckConfig$O(untrustedConfig) {
+const createContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$P, createContextServiceDefinition_ConfigPropertyMetadata);
+const createResourceParams$P = /*#__PURE__*/ createResourceParams$14(createContextServiceDefinition_ConfigPropertyMetadata);
+function typeCheckConfig$P(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextDefinitionInput = untrustedConfig.contextDefinitionInput;
     const referenceContextDefinitionsInputRepresentationValidationError = validate$o(untrustedConfig_contextDefinitionInput);
@@ -8429,30 +8349,30 @@ function typeCheckConfig$O(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$O(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$P(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$O(untrustedConfig);
+    const config = typeCheckConfig$P(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$O(luvio, config, options) {
-    const resourceParams = createResourceParams$O(config);
-    const request = createResourceRequest$O(resourceParams);
+function buildNetworkSnapshot$P(luvio, config, options) {
+    const resourceParams = createResourceParams$P(config);
+    const request = createResourceRequest$P(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$B(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$C(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$O(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$P(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -8462,12 +8382,12 @@ function buildNetworkSnapshot$O(luvio, config, options) {
 }
 const createContextServiceDefinitionAdapterFactory = (luvio) => {
     return function createContextServiceDefinition(untrustedConfig) {
-        const config = validateAdapterConfig$O(untrustedConfig, createContextServiceDefinition_ConfigPropertyNames);
+        const config = validateAdapterConfig$P(untrustedConfig, createContextServiceDefinition_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextServiceDefinition"');
         }
-        return buildNetworkSnapshot$O(luvio, config);
+        return buildNetworkSnapshot$P(luvio, config);
     };
 };
 
@@ -8564,7 +8484,7 @@ function normalize$b(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$P = function ContextTagListRepresentationSelect() {
+const select$Q = function ContextTagListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$e,
@@ -8583,7 +8503,7 @@ const select$P = function ContextTagListRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$18()
+                fragment: select$19()
             },
             {
                 name: 'isSuccess',
@@ -8665,19 +8585,19 @@ function getTypeCacheKeys$b(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
 
-function select$O(luvio, params) {
-    return select$P();
+function select$P(luvio, params) {
+    return select$Q();
 }
-function getResponseCacheKeys$N(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$O(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$b(storeKeyMap, luvio, response);
 }
-function ingestSuccess$A(luvio, resourceParams, response) {
+function ingestSuccess$B(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$7(luvio, body);
     luvio.storeIngest(key, ingest$b, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$O(),
+        node: select$P(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -8688,7 +8608,7 @@ function ingestSuccess$A(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$N(config) {
+function createResourceRequest$O(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -8702,16 +8622,16 @@ function createResourceRequest$N(config) {
     };
 }
 
-const adapterName$N = 'createContextTags';
+const adapterName$O = 'createContextTags';
 const createContextTags_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextTagInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$N, createContextTags_ConfigPropertyMetadata);
-const createResourceParams$N = /*#__PURE__*/ createResourceParams$13(createContextTags_ConfigPropertyMetadata);
-function typeCheckConfig$N(untrustedConfig) {
+const createContextTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$O, createContextTags_ConfigPropertyMetadata);
+const createResourceParams$O = /*#__PURE__*/ createResourceParams$14(createContextTags_ConfigPropertyMetadata);
+function typeCheckConfig$O(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, createContextTags_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, createContextTags_ConfigPropertyMetadata);
     const untrustedConfig_contextTagInput = untrustedConfig.contextTagInput;
     const referenceContextTagListInputRepresentationValidationError = validate$l(untrustedConfig_contextTagInput);
     if (referenceContextTagListInputRepresentationValidationError === null) {
@@ -8719,30 +8639,30 @@ function typeCheckConfig$N(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$N(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$O(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$N(untrustedConfig);
+    const config = typeCheckConfig$O(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$N(luvio, config, options) {
-    const resourceParams = createResourceParams$N(config);
-    const request = createResourceRequest$N(resourceParams);
+function buildNetworkSnapshot$O(luvio, config, options) {
+    const resourceParams = createResourceParams$O(config);
+    const request = createResourceRequest$O(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$A(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$B(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$N(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$O(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -8752,12 +8672,12 @@ function buildNetworkSnapshot$N(luvio, config, options) {
 }
 const createContextTagsAdapterFactory = (luvio) => {
     return function createContextTags(untrustedConfig) {
-        const config = validateAdapterConfig$N(untrustedConfig, createContextTags_ConfigPropertyNames);
+        const config = validateAdapterConfig$O(untrustedConfig, createContextTags_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextTags"');
         }
-        return buildNetworkSnapshot$N(luvio, config);
+        return buildNetworkSnapshot$O(luvio, config);
     };
 };
 
@@ -8847,7 +8767,7 @@ function keyBuilderFromType$6(luvio, object) {
 function normalize$a(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$N = function ContextOutputRepresentationSelect() {
+const select$O = function ContextOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$d,
@@ -8883,19 +8803,19 @@ function getTypeCacheKeys$a(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-function select$M(luvio, params) {
-    return select$N();
+function select$N(luvio, params) {
+    return select$O();
 }
-function getResponseCacheKeys$M(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$N(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$a(storeKeyMap, luvio, response);
 }
-function ingestSuccess$z(luvio, resourceParams, response) {
+function ingestSuccess$A(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$6(luvio, body);
     luvio.storeIngest(key, ingest$a, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$M(),
+        node: select$N(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -8906,7 +8826,7 @@ function ingestSuccess$z(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$M(config) {
+function createResourceRequest$N(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -8920,16 +8840,16 @@ function createResourceRequest$M(config) {
     };
 }
 
-const adapterName$M = 'createContextUpdateAttribute';
+const adapterName$N = 'createContextUpdateAttribute';
 const createContextUpdateAttribute_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextId', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('nodePathAndAttributes', true, 2 /* Body */, 4 /* Unsupported */, true),
 ];
-const createContextUpdateAttribute_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$M, createContextUpdateAttribute_ConfigPropertyMetadata);
-const createResourceParams$M = /*#__PURE__*/ createResourceParams$13(createContextUpdateAttribute_ConfigPropertyMetadata);
-function typeCheckConfig$M(untrustedConfig) {
+const createContextUpdateAttribute_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$N, createContextUpdateAttribute_ConfigPropertyMetadata);
+const createResourceParams$N = /*#__PURE__*/ createResourceParams$14(createContextUpdateAttribute_ConfigPropertyMetadata);
+function typeCheckConfig$N(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, createContextUpdateAttribute_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, createContextUpdateAttribute_ConfigPropertyMetadata);
     const untrustedConfig_nodePathAndAttributes = untrustedConfig.nodePathAndAttributes;
     if (ArrayIsArray$1(untrustedConfig_nodePathAndAttributes)) {
         const untrustedConfig_nodePathAndAttributes_array = [];
@@ -8944,30 +8864,30 @@ function typeCheckConfig$M(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$M(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$N(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$M(untrustedConfig);
+    const config = typeCheckConfig$N(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$M(luvio, config, options) {
-    const resourceParams = createResourceParams$M(config);
-    const request = createResourceRequest$M(resourceParams);
+function buildNetworkSnapshot$N(luvio, config, options) {
+    const resourceParams = createResourceParams$N(config);
+    const request = createResourceRequest$N(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$z(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$A(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$M(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$N(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -8977,12 +8897,12 @@ function buildNetworkSnapshot$M(luvio, config, options) {
 }
 const createContextUpdateAttributeAdapterFactory = (luvio) => {
     return function createContextUpdateAttribute(untrustedConfig) {
-        const config = validateAdapterConfig$M(untrustedConfig, createContextUpdateAttribute_ConfigPropertyNames);
+        const config = validateAdapterConfig$N(untrustedConfig, createContextUpdateAttribute_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextUpdateAttribute"');
         }
-        return buildNetworkSnapshot$M(luvio, config);
+        return buildNetworkSnapshot$N(luvio, config);
     };
 };
 
@@ -9037,19 +8957,19 @@ function validate$f(obj, path = 'NodePathAndTagValuesInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function select$L(luvio, params) {
-    return select$N();
+function select$M(luvio, params) {
+    return select$O();
 }
-function getResponseCacheKeys$L(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$M(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$a(storeKeyMap, luvio, response);
 }
-function ingestSuccess$y(luvio, resourceParams, response) {
+function ingestSuccess$z(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$6(luvio, body);
     luvio.storeIngest(key, ingest$a, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$L(),
+        node: select$M(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -9060,7 +8980,7 @@ function ingestSuccess$y(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$L(config) {
+function createResourceRequest$M(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -9074,16 +8994,16 @@ function createResourceRequest$L(config) {
     };
 }
 
-const adapterName$L = 'createWriteThroughTags';
+const adapterName$M = 'createWriteThroughTags';
 const createWriteThroughTags_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextId', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('nodePathAndTagValues', true, 2 /* Body */, 4 /* Unsupported */, true),
 ];
-const createWriteThroughTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$L, createWriteThroughTags_ConfigPropertyMetadata);
-const createResourceParams$L = /*#__PURE__*/ createResourceParams$13(createWriteThroughTags_ConfigPropertyMetadata);
-function typeCheckConfig$L(untrustedConfig) {
+const createWriteThroughTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$M, createWriteThroughTags_ConfigPropertyMetadata);
+const createResourceParams$M = /*#__PURE__*/ createResourceParams$14(createWriteThroughTags_ConfigPropertyMetadata);
+function typeCheckConfig$M(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, createWriteThroughTags_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, createWriteThroughTags_ConfigPropertyMetadata);
     const untrustedConfig_nodePathAndTagValues = untrustedConfig.nodePathAndTagValues;
     if (ArrayIsArray$1(untrustedConfig_nodePathAndTagValues)) {
         const untrustedConfig_nodePathAndTagValues_array = [];
@@ -9098,30 +9018,30 @@ function typeCheckConfig$L(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$L(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$M(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$L(untrustedConfig);
+    const config = typeCheckConfig$M(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$L(luvio, config, options) {
-    const resourceParams = createResourceParams$L(config);
-    const request = createResourceRequest$L(resourceParams);
+function buildNetworkSnapshot$M(luvio, config, options) {
+    const resourceParams = createResourceParams$M(config);
+    const request = createResourceRequest$M(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$y(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$z(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$L(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$M(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -9131,12 +9051,12 @@ function buildNetworkSnapshot$L(luvio, config, options) {
 }
 const createWriteThroughTagsAdapterFactory = (luvio) => {
     return function createWriteThroughTags(untrustedConfig) {
-        const config = validateAdapterConfig$L(untrustedConfig, createWriteThroughTags_ConfigPropertyNames);
+        const config = validateAdapterConfig$M(untrustedConfig, createWriteThroughTags_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createWriteThroughTags"');
         }
-        return buildNetworkSnapshot$L(luvio, config);
+        return buildNetworkSnapshot$M(luvio, config);
     };
 };
 
@@ -9145,7 +9065,7 @@ function keyBuilder$W(luvio, params) {
         id: params.urlParams.contextId
     });
 }
-function getResponseCacheKeys$K(cacheKeyMap, luvio, resourceParams) {
+function getResponseCacheKeys$L(cacheKeyMap, luvio, resourceParams) {
     const key = keyBuilder$W(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
@@ -9157,7 +9077,7 @@ function evictSuccess$c(luvio, resourceParams) {
     const key = keyBuilder$W(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$K(config) {
+function createResourceRequest$L(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -9171,33 +9091,33 @@ function createResourceRequest$K(config) {
     };
 }
 
-const adapterName$K = 'deleteContext';
+const adapterName$L = 'deleteContext';
 const deleteContext_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteContext_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$K, deleteContext_ConfigPropertyMetadata);
-const createResourceParams$K = /*#__PURE__*/ createResourceParams$13(deleteContext_ConfigPropertyMetadata);
-function typeCheckConfig$K(untrustedConfig) {
+const deleteContext_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$L, deleteContext_ConfigPropertyMetadata);
+const createResourceParams$L = /*#__PURE__*/ createResourceParams$14(deleteContext_ConfigPropertyMetadata);
+function typeCheckConfig$L(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, deleteContext_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, deleteContext_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$K(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$L(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$K(untrustedConfig);
+    const config = typeCheckConfig$L(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$K(luvio, config, options) {
-    const resourceParams = createResourceParams$K(config);
-    const request = createResourceRequest$K(resourceParams);
+function buildNetworkSnapshot$L(luvio, config, options) {
+    const resourceParams = createResourceParams$L(config);
+    const request = createResourceRequest$L(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
@@ -9205,7 +9125,7 @@ function buildNetworkSnapshot$K(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$K(cache, luvio, resourceParams);
+            getResponseCacheKeys$L(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -9215,12 +9135,12 @@ function buildNetworkSnapshot$K(luvio, config, options) {
 }
 const deleteContextAdapterFactory = (luvio) => {
     return function IndustriesContextdeleteContext(untrustedConfig) {
-        const config = validateAdapterConfig$K(untrustedConfig, deleteContext_ConfigPropertyNames);
+        const config = validateAdapterConfig$L(untrustedConfig, deleteContext_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$K}"`);
+            throw new Error(`Invalid config for "${adapterName$L}"`);
         }
-        return buildNetworkSnapshot$K(luvio, config);
+        return buildNetworkSnapshot$L(luvio, config);
     };
 };
 
@@ -9229,7 +9149,7 @@ function keyBuilder$V(luvio, params) {
         id: params.urlParams.contextAttributeMappingId
     });
 }
-function getResponseCacheKeys$J(cacheKeyMap, luvio, resourceParams) {
+function getResponseCacheKeys$K(cacheKeyMap, luvio, resourceParams) {
     const key = keyBuilder$V(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
@@ -9241,7 +9161,7 @@ function evictSuccess$b(luvio, resourceParams) {
     const key = keyBuilder$V(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$J(config) {
+function createResourceRequest$K(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -9255,33 +9175,33 @@ function createResourceRequest$J(config) {
     };
 }
 
-const adapterName$J = 'deleteContextAttributeMapping';
+const adapterName$K = 'deleteContextAttributeMapping';
 const deleteContextAttributeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteContextAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$J, deleteContextAttributeMapping_ConfigPropertyMetadata);
-const createResourceParams$J = /*#__PURE__*/ createResourceParams$13(deleteContextAttributeMapping_ConfigPropertyMetadata);
-function typeCheckConfig$J(untrustedConfig) {
+const deleteContextAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$K, deleteContextAttributeMapping_ConfigPropertyMetadata);
+const createResourceParams$K = /*#__PURE__*/ createResourceParams$14(deleteContextAttributeMapping_ConfigPropertyMetadata);
+function typeCheckConfig$K(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, deleteContextAttributeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, deleteContextAttributeMapping_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$J(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$K(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$J(untrustedConfig);
+    const config = typeCheckConfig$K(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$J(luvio, config, options) {
-    const resourceParams = createResourceParams$J(config);
-    const request = createResourceRequest$J(resourceParams);
+function buildNetworkSnapshot$K(luvio, config, options) {
+    const resourceParams = createResourceParams$K(config);
+    const request = createResourceRequest$K(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
@@ -9289,7 +9209,7 @@ function buildNetworkSnapshot$J(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$J(cache, luvio, resourceParams);
+            getResponseCacheKeys$K(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -9299,12 +9219,12 @@ function buildNetworkSnapshot$J(luvio, config, options) {
 }
 const deleteContextAttributeMappingAdapterFactory = (luvio) => {
     return function IndustriesContextdeleteContextAttributeMapping(untrustedConfig) {
-        const config = validateAdapterConfig$J(untrustedConfig, deleteContextAttributeMapping_ConfigPropertyNames);
+        const config = validateAdapterConfig$K(untrustedConfig, deleteContextAttributeMapping_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$J}"`);
+            throw new Error(`Invalid config for "${adapterName$K}"`);
         }
-        return buildNetworkSnapshot$J(luvio, config);
+        return buildNetworkSnapshot$K(luvio, config);
     };
 };
 
@@ -9313,7 +9233,7 @@ function keyBuilder$U(luvio, params) {
         id: params.urlParams.contextDefinitionFilterId
     });
 }
-function getResponseCacheKeys$I(cacheKeyMap, luvio, resourceParams) {
+function getResponseCacheKeys$J(cacheKeyMap, luvio, resourceParams) {
     const key = keyBuilder$U(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
@@ -9325,7 +9245,7 @@ function evictSuccess$a(luvio, resourceParams) {
     const key = keyBuilder$U(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$I(config) {
+function createResourceRequest$J(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -9339,34 +9259,34 @@ function createResourceRequest$I(config) {
     };
 }
 
-const adapterName$I = 'deleteContextFilter';
+const adapterName$J = 'deleteContextFilter';
 const deleteContextFilter_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionFilterId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteContextFilter_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$I, deleteContextFilter_ConfigPropertyMetadata);
-const createResourceParams$I = /*#__PURE__*/ createResourceParams$13(deleteContextFilter_ConfigPropertyMetadata);
-function typeCheckConfig$I(untrustedConfig) {
+const deleteContextFilter_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$J, deleteContextFilter_ConfigPropertyMetadata);
+const createResourceParams$J = /*#__PURE__*/ createResourceParams$14(deleteContextFilter_ConfigPropertyMetadata);
+function typeCheckConfig$J(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, deleteContextFilter_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, deleteContextFilter_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$I(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$J(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$I(untrustedConfig);
+    const config = typeCheckConfig$J(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$I(luvio, config, options) {
-    const resourceParams = createResourceParams$I(config);
-    const request = createResourceRequest$I(resourceParams);
+function buildNetworkSnapshot$J(luvio, config, options) {
+    const resourceParams = createResourceParams$J(config);
+    const request = createResourceRequest$J(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
@@ -9374,7 +9294,7 @@ function buildNetworkSnapshot$I(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$I(cache, luvio, resourceParams);
+            getResponseCacheKeys$J(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -9384,12 +9304,12 @@ function buildNetworkSnapshot$I(luvio, config, options) {
 }
 const deleteContextFilterAdapterFactory = (luvio) => {
     return function IndustriesContextdeleteContextFilter(untrustedConfig) {
-        const config = validateAdapterConfig$I(untrustedConfig, deleteContextFilter_ConfigPropertyNames);
+        const config = validateAdapterConfig$J(untrustedConfig, deleteContextFilter_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$I}"`);
+            throw new Error(`Invalid config for "${adapterName$J}"`);
         }
-        return buildNetworkSnapshot$I(luvio, config);
+        return buildNetworkSnapshot$J(luvio, config);
     };
 };
 
@@ -9398,7 +9318,7 @@ function keyBuilder$T(luvio, params) {
         id: params.urlParams.contextMappingId
     });
 }
-function getResponseCacheKeys$H(cacheKeyMap, luvio, resourceParams) {
+function getResponseCacheKeys$I(cacheKeyMap, luvio, resourceParams) {
     const key = keyBuilder$T(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
@@ -9410,7 +9330,7 @@ function evictSuccess$9(luvio, resourceParams) {
     const key = keyBuilder$T(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$H(config) {
+function createResourceRequest$I(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -9424,33 +9344,33 @@ function createResourceRequest$H(config) {
     };
 }
 
-const adapterName$H = 'deleteContextMapping';
+const adapterName$I = 'deleteContextMapping';
 const deleteContextMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteContextMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$H, deleteContextMapping_ConfigPropertyMetadata);
-const createResourceParams$H = /*#__PURE__*/ createResourceParams$13(deleteContextMapping_ConfigPropertyMetadata);
-function typeCheckConfig$H(untrustedConfig) {
+const deleteContextMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$I, deleteContextMapping_ConfigPropertyMetadata);
+const createResourceParams$I = /*#__PURE__*/ createResourceParams$14(deleteContextMapping_ConfigPropertyMetadata);
+function typeCheckConfig$I(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, deleteContextMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, deleteContextMapping_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$H(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$I(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$H(untrustedConfig);
+    const config = typeCheckConfig$I(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$H(luvio, config, options) {
-    const resourceParams = createResourceParams$H(config);
-    const request = createResourceRequest$H(resourceParams);
+function buildNetworkSnapshot$I(luvio, config, options) {
+    const resourceParams = createResourceParams$I(config);
+    const request = createResourceRequest$I(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
@@ -9458,7 +9378,7 @@ function buildNetworkSnapshot$H(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$H(cache, luvio, resourceParams);
+            getResponseCacheKeys$I(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -9468,12 +9388,12 @@ function buildNetworkSnapshot$H(luvio, config, options) {
 }
 const deleteContextMappingAdapterFactory = (luvio) => {
     return function IndustriesContextdeleteContextMapping(untrustedConfig) {
-        const config = validateAdapterConfig$H(untrustedConfig, deleteContextMapping_ConfigPropertyNames);
+        const config = validateAdapterConfig$I(untrustedConfig, deleteContextMapping_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$H}"`);
+            throw new Error(`Invalid config for "${adapterName$I}"`);
         }
-        return buildNetworkSnapshot$H(luvio, config);
+        return buildNetworkSnapshot$I(luvio, config);
     };
 };
 
@@ -9482,7 +9402,7 @@ function keyBuilder$S(luvio, params) {
         id: params.urlParams.contextNodeMappingId
     });
 }
-function getResponseCacheKeys$G(cacheKeyMap, luvio, resourceParams) {
+function getResponseCacheKeys$H(cacheKeyMap, luvio, resourceParams) {
     const key = keyBuilder$S(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
@@ -9494,7 +9414,7 @@ function evictSuccess$8(luvio, resourceParams) {
     const key = keyBuilder$S(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$G(config) {
+function createResourceRequest$H(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -9508,33 +9428,33 @@ function createResourceRequest$G(config) {
     };
 }
 
-const adapterName$G = 'deleteContextNodeMapping';
+const adapterName$H = 'deleteContextNodeMapping';
 const deleteContextNodeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteContextNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$G, deleteContextNodeMapping_ConfigPropertyMetadata);
-const createResourceParams$G = /*#__PURE__*/ createResourceParams$13(deleteContextNodeMapping_ConfigPropertyMetadata);
-function typeCheckConfig$G(untrustedConfig) {
+const deleteContextNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$H, deleteContextNodeMapping_ConfigPropertyMetadata);
+const createResourceParams$H = /*#__PURE__*/ createResourceParams$14(deleteContextNodeMapping_ConfigPropertyMetadata);
+function typeCheckConfig$H(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, deleteContextNodeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, deleteContextNodeMapping_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$G(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$H(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$G(untrustedConfig);
+    const config = typeCheckConfig$H(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$G(luvio, config, options) {
-    const resourceParams = createResourceParams$G(config);
-    const request = createResourceRequest$G(resourceParams);
+function buildNetworkSnapshot$H(luvio, config, options) {
+    const resourceParams = createResourceParams$H(config);
+    const request = createResourceRequest$H(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
@@ -9542,7 +9462,7 @@ function buildNetworkSnapshot$G(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$G(cache, luvio, resourceParams);
+            getResponseCacheKeys$H(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -9552,12 +9472,12 @@ function buildNetworkSnapshot$G(luvio, config, options) {
 }
 const deleteContextNodeMappingAdapterFactory = (luvio) => {
     return function IndustriesContextdeleteContextNodeMapping(untrustedConfig) {
-        const config = validateAdapterConfig$G(untrustedConfig, deleteContextNodeMapping_ConfigPropertyNames);
+        const config = validateAdapterConfig$H(untrustedConfig, deleteContextNodeMapping_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$G}"`);
+            throw new Error(`Invalid config for "${adapterName$H}"`);
         }
-        return buildNetworkSnapshot$G(luvio, config);
+        return buildNetworkSnapshot$H(luvio, config);
     };
 };
 
@@ -9566,7 +9486,7 @@ function keyBuilder$R(luvio, params) {
         id: params.urlParams.contextAttributeId
     });
 }
-function getResponseCacheKeys$F(cacheKeyMap, luvio, resourceParams) {
+function getResponseCacheKeys$G(cacheKeyMap, luvio, resourceParams) {
     const key = keyBuilder$R(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
@@ -9578,7 +9498,7 @@ function evictSuccess$7(luvio, resourceParams) {
     const key = keyBuilder$R(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$F(config) {
+function createResourceRequest$G(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -9592,34 +9512,34 @@ function createResourceRequest$F(config) {
     };
 }
 
-const adapterName$F = 'deleteContextServiceAttribute';
+const adapterName$G = 'deleteContextServiceAttribute';
 const deleteContextServiceAttribute_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextNodeId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteContextServiceAttribute_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$F, deleteContextServiceAttribute_ConfigPropertyMetadata);
-const createResourceParams$F = /*#__PURE__*/ createResourceParams$13(deleteContextServiceAttribute_ConfigPropertyMetadata);
-function typeCheckConfig$F(untrustedConfig) {
+const deleteContextServiceAttribute_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$G, deleteContextServiceAttribute_ConfigPropertyMetadata);
+const createResourceParams$G = /*#__PURE__*/ createResourceParams$14(deleteContextServiceAttribute_ConfigPropertyMetadata);
+function typeCheckConfig$G(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, deleteContextServiceAttribute_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, deleteContextServiceAttribute_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$F(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$G(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$F(untrustedConfig);
+    const config = typeCheckConfig$G(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$F(luvio, config, options) {
-    const resourceParams = createResourceParams$F(config);
-    const request = createResourceRequest$F(resourceParams);
+function buildNetworkSnapshot$G(luvio, config, options) {
+    const resourceParams = createResourceParams$G(config);
+    const request = createResourceRequest$G(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
@@ -9627,7 +9547,7 @@ function buildNetworkSnapshot$F(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$F(cache, luvio, resourceParams);
+            getResponseCacheKeys$G(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -9637,12 +9557,12 @@ function buildNetworkSnapshot$F(luvio, config, options) {
 }
 const deleteContextServiceAttributeAdapterFactory = (luvio) => {
     return function IndustriesContextdeleteContextServiceAttribute(untrustedConfig) {
-        const config = validateAdapterConfig$F(untrustedConfig, deleteContextServiceAttribute_ConfigPropertyNames);
+        const config = validateAdapterConfig$G(untrustedConfig, deleteContextServiceAttribute_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$F}"`);
+            throw new Error(`Invalid config for "${adapterName$G}"`);
         }
-        return buildNetworkSnapshot$F(luvio, config);
+        return buildNetworkSnapshot$G(luvio, config);
     };
 };
 
@@ -9651,7 +9571,7 @@ function keyBuilder$Q(luvio, params) {
         id: params.urlParams.contextAttributeMappingId
     });
 }
-function getResponseCacheKeys$E(cacheKeyMap, luvio, resourceParams) {
+function getResponseCacheKeys$F(cacheKeyMap, luvio, resourceParams) {
     const key = keyBuilder$Q(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
@@ -9663,7 +9583,7 @@ function evictSuccess$6(luvio, resourceParams) {
     const key = keyBuilder$Q(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$E(config) {
+function createResourceRequest$F(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v68.0',
@@ -9677,16 +9597,112 @@ function createResourceRequest$E(config) {
     };
 }
 
-const adapterName$E = 'deleteContextServiceAttributeMapping';
+const adapterName$F = 'deleteContextServiceAttributeMapping';
 const deleteContextServiceAttributeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextNodeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteContextServiceAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$E, deleteContextServiceAttributeMapping_ConfigPropertyMetadata);
-const createResourceParams$E = /*#__PURE__*/ createResourceParams$13(deleteContextServiceAttributeMapping_ConfigPropertyMetadata);
+const deleteContextServiceAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$F, deleteContextServiceAttributeMapping_ConfigPropertyMetadata);
+const createResourceParams$F = /*#__PURE__*/ createResourceParams$14(deleteContextServiceAttributeMapping_ConfigPropertyMetadata);
+function typeCheckConfig$F(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$14(untrustedConfig, config, deleteContextServiceAttributeMapping_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$F(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$F(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$F(luvio, config, options) {
+    const resourceParams = createResourceParams$F(config);
+    const request = createResourceRequest$F(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then(() => {
+        return luvio.handleSuccessResponse(() => {
+            evictSuccess$6(luvio, resourceParams);
+            return luvio.storeBroadcast();
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$F(cache, luvio, resourceParams);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const deleteContextServiceAttributeMappingAdapterFactory = (luvio) => {
+    return function IndustriesContextdeleteContextServiceAttributeMapping(untrustedConfig) {
+        const config = validateAdapterConfig$F(untrustedConfig, deleteContextServiceAttributeMapping_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error(`Invalid config for "${adapterName$F}"`);
+        }
+        return buildNetworkSnapshot$F(luvio, config);
+    };
+};
+
+function select$L(luvio, params) {
+    return select$17();
+}
+function getResponseCacheKeys$E(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$j(storeKeyMap, luvio, response);
+}
+function ingestSuccess$y(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$f(luvio, body);
+    luvio.storeIngest(key, ingest$j, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$L(),
+        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$E(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v68.0',
+        basePath: '/connect/context-nodes/' + config.urlParams.contextNodeId + '/context-attributes/delete',
+        method: 'post',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$E = 'deleteContextServiceAttributes';
+const deleteContextServiceAttributes_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contextNodeId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('contextAttributeListInput', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const deleteContextServiceAttributes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$E, deleteContextServiceAttributes_ConfigPropertyMetadata);
+const createResourceParams$E = /*#__PURE__*/ createResourceParams$14(deleteContextServiceAttributes_ConfigPropertyMetadata);
 function typeCheckConfig$E(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, deleteContextServiceAttributeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, deleteContextServiceAttributes_ConfigPropertyMetadata);
+    const untrustedConfig_contextAttributeListInput = untrustedConfig.contextAttributeListInput;
+    const referenceContextAttributesListInputRepresentationValidationError = validate$I(untrustedConfig_contextAttributeListInput);
+    if (referenceContextAttributesListInputRepresentationValidationError === null) {
+        config.contextAttributeListInput = untrustedConfig_contextAttributeListInput;
+    }
     return config;
 }
 function validateAdapterConfig$E(untrustedConfig, configPropertyNames) {
@@ -9706,13 +9722,13 @@ function buildNetworkSnapshot$E(luvio, config, options) {
     const resourceParams = createResourceParams$E(config);
     const request = createResourceRequest$E(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
-        .then(() => {
+        .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            evictSuccess$6(luvio, resourceParams);
-            return luvio.storeBroadcast();
+            const snapshot = ingestSuccess$y(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$E(cache, luvio, resourceParams);
+            getResponseCacheKeys$E(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -9720,12 +9736,12 @@ function buildNetworkSnapshot$E(luvio, config, options) {
         throw response;
     });
 }
-const deleteContextServiceAttributeMappingAdapterFactory = (luvio) => {
-    return function IndustriesContextdeleteContextServiceAttributeMapping(untrustedConfig) {
-        const config = validateAdapterConfig$E(untrustedConfig, deleteContextServiceAttributeMapping_ConfigPropertyNames);
+const deleteContextServiceAttributesAdapterFactory = (luvio) => {
+    return function deleteContextServiceAttributes(untrustedConfig) {
+        const config = validateAdapterConfig$E(untrustedConfig, deleteContextServiceAttributes_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$E}"`);
+            throw new Error('Invalid config for "deleteContextServiceAttributes"');
         }
         return buildNetworkSnapshot$E(luvio, config);
     };
@@ -10067,7 +10083,7 @@ function normalize$8(input, existing, path, luvio, store, timestamp) {
     return input;
 }
 const select$J = function ContextDefinitionRepresentationSelect() {
-    const { selections: ContextDefinitionReferenceRepresentation__selections, opaque: ContextDefinitionReferenceRepresentation__opaque, } = select$S();
+    const { selections: ContextDefinitionReferenceRepresentation__selections, opaque: ContextDefinitionReferenceRepresentation__opaque, } = select$T();
     return {
         kind: 'Fragment',
         version: VERSION$b,
@@ -10443,10 +10459,10 @@ const deleteContextServiceDefinition_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$D, deleteContextServiceDefinition_ConfigPropertyMetadata);
-const createResourceParams$D = /*#__PURE__*/ createResourceParams$13(deleteContextServiceDefinition_ConfigPropertyMetadata);
+const createResourceParams$D = /*#__PURE__*/ createResourceParams$14(deleteContextServiceDefinition_ConfigPropertyMetadata);
 function typeCheckConfig$D(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, deleteContextServiceDefinition_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, deleteContextServiceDefinition_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$D(untrustedConfig, configPropertyNames) {
@@ -10528,10 +10544,10 @@ const deleteContextServiceMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteContextServiceMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$C, deleteContextServiceMapping_ConfigPropertyMetadata);
-const createResourceParams$C = /*#__PURE__*/ createResourceParams$13(deleteContextServiceMapping_ConfigPropertyMetadata);
+const createResourceParams$C = /*#__PURE__*/ createResourceParams$14(deleteContextServiceMapping_ConfigPropertyMetadata);
 function typeCheckConfig$C(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, deleteContextServiceMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, deleteContextServiceMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$C(untrustedConfig, configPropertyNames) {
@@ -10613,10 +10629,10 @@ const deleteContextServiceNode_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteContextServiceNode_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$B, deleteContextServiceNode_ConfigPropertyMetadata);
-const createResourceParams$B = /*#__PURE__*/ createResourceParams$13(deleteContextServiceNode_ConfigPropertyMetadata);
+const createResourceParams$B = /*#__PURE__*/ createResourceParams$14(deleteContextServiceNode_ConfigPropertyMetadata);
 function typeCheckConfig$B(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, deleteContextServiceNode_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, deleteContextServiceNode_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$B(untrustedConfig, configPropertyNames) {
@@ -10698,10 +10714,10 @@ const deleteContextServiceNodeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteContextServiceNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$A, deleteContextServiceNodeMapping_ConfigPropertyMetadata);
-const createResourceParams$A = /*#__PURE__*/ createResourceParams$13(deleteContextServiceNodeMapping_ConfigPropertyMetadata);
+const createResourceParams$A = /*#__PURE__*/ createResourceParams$14(deleteContextServiceNodeMapping_ConfigPropertyMetadata);
 function typeCheckConfig$A(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, deleteContextServiceNodeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, deleteContextServiceNodeMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$A(untrustedConfig, configPropertyNames) {
@@ -10783,10 +10799,10 @@ const deleteContextServiceTag_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextTagId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteContextServiceTag_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$z, deleteContextServiceTag_ConfigPropertyMetadata);
-const createResourceParams$z = /*#__PURE__*/ createResourceParams$13(deleteContextServiceTag_ConfigPropertyMetadata);
+const createResourceParams$z = /*#__PURE__*/ createResourceParams$14(deleteContextServiceTag_ConfigPropertyMetadata);
 function typeCheckConfig$z(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, deleteContextServiceTag_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, deleteContextServiceTag_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$z(untrustedConfig, configPropertyNames) {
@@ -10868,10 +10884,10 @@ const deleteContextTransformations_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionTransformationId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteContextTransformations_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$y, deleteContextTransformations_ConfigPropertyMetadata);
-const createResourceParams$y = /*#__PURE__*/ createResourceParams$13(deleteContextTransformations_ConfigPropertyMetadata);
+const createResourceParams$y = /*#__PURE__*/ createResourceParams$14(deleteContextTransformations_ConfigPropertyMetadata);
 function typeCheckConfig$y(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, deleteContextTransformations_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, deleteContextTransformations_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$y(untrustedConfig, configPropertyNames) {
@@ -10917,7 +10933,7 @@ const deleteContextTransformationsAdapterFactory = (luvio) => {
 };
 
 function select$I(luvio, params) {
-    return select$1t();
+    return select$1u();
 }
 function keyBuilder$H(luvio, params) {
     return keyBuilder$1i(luvio, {
@@ -10982,14 +10998,14 @@ const getContext_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContext_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$x, getContext_ConfigPropertyMetadata);
-const createResourceParams$x = /*#__PURE__*/ createResourceParams$13(getContext_ConfigPropertyMetadata);
+const createResourceParams$x = /*#__PURE__*/ createResourceParams$14(getContext_ConfigPropertyMetadata);
 function keyBuilder$G(luvio, config) {
     const resourceParams = createResourceParams$x(config);
     return keyBuilder$H(luvio, resourceParams);
 }
 function typeCheckConfig$x(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContext_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContext_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$x(untrustedConfig, configPropertyNames) {
@@ -11098,7 +11114,7 @@ const notifyChangeFactory$h = (luvio, options) => {
 };
 
 function select$H(luvio, params) {
-    return select$1j();
+    return select$1k();
 }
 function keyBuilder$F(luvio, params) {
     return keyBuilder$1d(luvio, {
@@ -11163,14 +11179,14 @@ const getContextAttributeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$w, getContextAttributeMapping_ConfigPropertyMetadata);
-const createResourceParams$w = /*#__PURE__*/ createResourceParams$13(getContextAttributeMapping_ConfigPropertyMetadata);
+const createResourceParams$w = /*#__PURE__*/ createResourceParams$14(getContextAttributeMapping_ConfigPropertyMetadata);
 function keyBuilder$E(luvio, config) {
     const resourceParams = createResourceParams$w(config);
     return keyBuilder$F(luvio, resourceParams);
 }
 function typeCheckConfig$w(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextAttributeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextAttributeMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$w(untrustedConfig, configPropertyNames) {
@@ -11342,7 +11358,7 @@ const select$G = function ContextDefinitionListRepresentationSelect() {
                 name: 'contextDefinitionList',
                 kind: 'Link',
                 plural: true,
-                fragment: select$R()
+                fragment: select$S()
             },
             {
                 name: 'contextDefinitionListId',
@@ -11471,14 +11487,14 @@ const getContextDefinitions_ConfigPropertyMetadata = [
     generateParamConfigMetadata('includeUpgrade', false, 1 /* QueryParameter */, 1 /* Boolean */),
 ];
 const getContextDefinitions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$v, getContextDefinitions_ConfigPropertyMetadata);
-const createResourceParams$v = /*#__PURE__*/ createResourceParams$13(getContextDefinitions_ConfigPropertyMetadata);
+const createResourceParams$v = /*#__PURE__*/ createResourceParams$14(getContextDefinitions_ConfigPropertyMetadata);
 function keyBuilder$C(luvio, config) {
     const resourceParams = createResourceParams$v(config);
     return keyBuilder$D(luvio, resourceParams);
 }
 function typeCheckConfig$v(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextDefinitions_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextDefinitions_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$v(untrustedConfig, configPropertyNames) {
@@ -11553,7 +11569,7 @@ const getContextDefinitionsAdapterFactory = (luvio) => function IndustriesContex
 };
 
 function select$E(luvio, params) {
-    return select$14();
+    return select$15();
 }
 function keyBuilder$B(luvio, params) {
     return keyBuilder$13(luvio, {
@@ -11619,14 +11635,14 @@ const getContextFilter_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextFilter_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$u, getContextFilter_ConfigPropertyMetadata);
-const createResourceParams$u = /*#__PURE__*/ createResourceParams$13(getContextFilter_ConfigPropertyMetadata);
+const createResourceParams$u = /*#__PURE__*/ createResourceParams$14(getContextFilter_ConfigPropertyMetadata);
 function keyBuilder$A(luvio, config) {
     const resourceParams = createResourceParams$u(config);
     return keyBuilder$B(luvio, resourceParams);
 }
 function typeCheckConfig$u(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextFilter_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextFilter_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$u(untrustedConfig, configPropertyNames) {
@@ -11735,7 +11751,7 @@ const notifyChangeFactory$f = (luvio, options) => {
 };
 
 function select$D(luvio, params) {
-    return select$13();
+    return select$14();
 }
 function keyBuilder$z(luvio, params) {
     return keyBuilder$12(luvio, {
@@ -11800,14 +11816,14 @@ const getContextFilters_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextFilters_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$t, getContextFilters_ConfigPropertyMetadata);
-const createResourceParams$t = /*#__PURE__*/ createResourceParams$13(getContextFilters_ConfigPropertyMetadata);
+const createResourceParams$t = /*#__PURE__*/ createResourceParams$14(getContextFilters_ConfigPropertyMetadata);
 function keyBuilder$y(luvio, config) {
     const resourceParams = createResourceParams$t(config);
     return keyBuilder$z(luvio, resourceParams);
 }
 function typeCheckConfig$t(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextFilters_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextFilters_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$t(untrustedConfig, configPropertyNames) {
@@ -11916,7 +11932,7 @@ const notifyChangeFactory$e = (luvio, options) => {
 };
 
 function select$C(luvio, params) {
-    return select$1t();
+    return select$1u();
 }
 function keyBuilder$x(luvio, params) {
     return keyBuilder$1i(luvio, {
@@ -11981,14 +11997,14 @@ const getContextInfo_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextInfo_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$s, getContextInfo_ConfigPropertyMetadata);
-const createResourceParams$s = /*#__PURE__*/ createResourceParams$13(getContextInfo_ConfigPropertyMetadata);
+const createResourceParams$s = /*#__PURE__*/ createResourceParams$14(getContextInfo_ConfigPropertyMetadata);
 function keyBuilder$w(luvio, config) {
     const resourceParams = createResourceParams$s(config);
     return keyBuilder$x(luvio, resourceParams);
 }
 function typeCheckConfig$s(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextInfo_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextInfo_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$s(untrustedConfig, configPropertyNames) {
@@ -12097,7 +12113,7 @@ const notifyChangeFactory$d = (luvio, options) => {
 };
 
 function select$B(luvio, params) {
-    return select$1h();
+    return select$1i();
 }
 function keyBuilder$v(luvio, params) {
     return keyBuilder$1b(luvio, {
@@ -12162,14 +12178,14 @@ const getContextMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$r, getContextMapping_ConfigPropertyMetadata);
-const createResourceParams$r = /*#__PURE__*/ createResourceParams$13(getContextMapping_ConfigPropertyMetadata);
+const createResourceParams$r = /*#__PURE__*/ createResourceParams$14(getContextMapping_ConfigPropertyMetadata);
 function keyBuilder$u(luvio, config) {
     const resourceParams = createResourceParams$r(config);
     return keyBuilder$v(luvio, resourceParams);
 }
 function typeCheckConfig$r(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$r(untrustedConfig, configPropertyNames) {
@@ -12278,7 +12294,7 @@ const notifyChangeFactory$c = (luvio, options) => {
 };
 
 function select$A(luvio, params) {
-    return select$1i();
+    return select$1j();
 }
 function keyBuilder$t(luvio, params) {
     return keyBuilder$1c(luvio, {
@@ -12343,14 +12359,14 @@ const getContextNodeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$q, getContextNodeMapping_ConfigPropertyMetadata);
-const createResourceParams$q = /*#__PURE__*/ createResourceParams$13(getContextNodeMapping_ConfigPropertyMetadata);
+const createResourceParams$q = /*#__PURE__*/ createResourceParams$14(getContextNodeMapping_ConfigPropertyMetadata);
 function keyBuilder$s(luvio, config) {
     const resourceParams = createResourceParams$q(config);
     return keyBuilder$t(luvio, resourceParams);
 }
 function typeCheckConfig$q(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextNodeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextNodeMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$q(untrustedConfig, configPropertyNames) {
@@ -12621,14 +12637,14 @@ const getContextServiceAccess_ConfigPropertyMetadata = [
     generateParamConfigMetadata('uniqueIdentifier', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextServiceAccess_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$p, getContextServiceAccess_ConfigPropertyMetadata);
-const createResourceParams$p = /*#__PURE__*/ createResourceParams$13(getContextServiceAccess_ConfigPropertyMetadata);
+const createResourceParams$p = /*#__PURE__*/ createResourceParams$14(getContextServiceAccess_ConfigPropertyMetadata);
 function keyBuilder$p(luvio, config) {
     const resourceParams = createResourceParams$p(config);
     return keyBuilder$q(luvio, resourceParams);
 }
 function typeCheckConfig$p(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextServiceAccess_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextServiceAccess_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$p(untrustedConfig, configPropertyNames) {
@@ -12737,7 +12753,7 @@ const notifyChangeFactory$a = (luvio, options) => {
 };
 
 function select$x(luvio, params) {
-    return select$17();
+    return select$18();
 }
 function keyBuilder$o(luvio, params) {
     return keyBuilder$15(luvio, {
@@ -12803,14 +12819,14 @@ const getContextServiceAttribute_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextServiceAttribute_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$o, getContextServiceAttribute_ConfigPropertyMetadata);
-const createResourceParams$o = /*#__PURE__*/ createResourceParams$13(getContextServiceAttribute_ConfigPropertyMetadata);
+const createResourceParams$o = /*#__PURE__*/ createResourceParams$14(getContextServiceAttribute_ConfigPropertyMetadata);
 function keyBuilder$n(luvio, config) {
     const resourceParams = createResourceParams$o(config);
     return keyBuilder$o(luvio, resourceParams);
 }
 function typeCheckConfig$o(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextServiceAttribute_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextServiceAttribute_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$o(untrustedConfig, configPropertyNames) {
@@ -12919,7 +12935,7 @@ const notifyChangeFactory$9 = (luvio, options) => {
 };
 
 function select$w(luvio, params) {
-    return select$1j();
+    return select$1k();
 }
 function keyBuilder$m(luvio, params) {
     return keyBuilder$1d(luvio, {
@@ -12985,14 +13001,14 @@ const getContextServiceAttributeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextServiceAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$n, getContextServiceAttributeMapping_ConfigPropertyMetadata);
-const createResourceParams$n = /*#__PURE__*/ createResourceParams$13(getContextServiceAttributeMapping_ConfigPropertyMetadata);
+const createResourceParams$n = /*#__PURE__*/ createResourceParams$14(getContextServiceAttributeMapping_ConfigPropertyMetadata);
 function keyBuilder$l(luvio, config) {
     const resourceParams = createResourceParams$n(config);
     return keyBuilder$m(luvio, resourceParams);
 }
 function typeCheckConfig$n(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextServiceAttributeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextServiceAttributeMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$n(untrustedConfig, configPropertyNames) {
@@ -13169,14 +13185,14 @@ const getContextServiceDefinition_ConfigPropertyMetadata = [
     generateParamConfigMetadata('mappingIdsOrDevelopersNames', false, 1 /* QueryParameter */, 0 /* String */, true),
 ];
 const getContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$m, getContextServiceDefinition_ConfigPropertyMetadata);
-const createResourceParams$m = /*#__PURE__*/ createResourceParams$13(getContextServiceDefinition_ConfigPropertyMetadata);
+const createResourceParams$m = /*#__PURE__*/ createResourceParams$14(getContextServiceDefinition_ConfigPropertyMetadata);
 function keyBuilder$j(luvio, config) {
     const resourceParams = createResourceParams$m(config);
     return keyBuilder$k(luvio, resourceParams);
 }
 function typeCheckConfig$m(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextServiceDefinition_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextServiceDefinition_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$m(untrustedConfig, configPropertyNames) {
@@ -13285,7 +13301,7 @@ const notifyChangeFactory$7 = (luvio, options) => {
 };
 
 function select$u(luvio, params) {
-    return select$R();
+    return select$S();
 }
 function keyBuilder$i(luvio, params) {
     return keyBuilder$Z(luvio, {
@@ -13350,14 +13366,14 @@ const getContextServiceDefinitionInfo_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextServiceDefinitionInfo_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$l, getContextServiceDefinitionInfo_ConfigPropertyMetadata);
-const createResourceParams$l = /*#__PURE__*/ createResourceParams$13(getContextServiceDefinitionInfo_ConfigPropertyMetadata);
+const createResourceParams$l = /*#__PURE__*/ createResourceParams$14(getContextServiceDefinitionInfo_ConfigPropertyMetadata);
 function keyBuilder$h(luvio, config) {
     const resourceParams = createResourceParams$l(config);
     return keyBuilder$i(luvio, resourceParams);
 }
 function typeCheckConfig$l(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextServiceDefinitionInfo_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextServiceDefinitionInfo_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$l(untrustedConfig, configPropertyNames) {
@@ -13466,7 +13482,7 @@ const notifyChangeFactory$6 = (luvio, options) => {
 };
 
 function select$t(luvio, params) {
-    return select$1h();
+    return select$1i();
 }
 function keyBuilder$g(luvio, params) {
     return keyBuilder$1b(luvio, {
@@ -13532,14 +13548,14 @@ const getContextServiceMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextServiceMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$k, getContextServiceMapping_ConfigPropertyMetadata);
-const createResourceParams$k = /*#__PURE__*/ createResourceParams$13(getContextServiceMapping_ConfigPropertyMetadata);
+const createResourceParams$k = /*#__PURE__*/ createResourceParams$14(getContextServiceMapping_ConfigPropertyMetadata);
 function keyBuilder$f(luvio, config) {
     const resourceParams = createResourceParams$k(config);
     return keyBuilder$g(luvio, resourceParams);
 }
 function typeCheckConfig$k(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextServiceMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextServiceMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$k(untrustedConfig, configPropertyNames) {
@@ -13648,7 +13664,7 @@ const notifyChangeFactory$5 = (luvio, options) => {
 };
 
 function select$s(luvio, params) {
-    return select$Y();
+    return select$Z();
 }
 function keyBuilder$e(luvio, params) {
     return keyBuilder$10(luvio, {
@@ -13714,14 +13730,14 @@ const getContextServiceNode_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextServiceNode_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$j, getContextServiceNode_ConfigPropertyMetadata);
-const createResourceParams$j = /*#__PURE__*/ createResourceParams$13(getContextServiceNode_ConfigPropertyMetadata);
+const createResourceParams$j = /*#__PURE__*/ createResourceParams$14(getContextServiceNode_ConfigPropertyMetadata);
 function keyBuilder$d(luvio, config) {
     const resourceParams = createResourceParams$j(config);
     return keyBuilder$e(luvio, resourceParams);
 }
 function typeCheckConfig$j(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextServiceNode_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextServiceNode_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$j(untrustedConfig, configPropertyNames) {
@@ -13830,7 +13846,7 @@ const notifyChangeFactory$4 = (luvio, options) => {
 };
 
 function select$r(luvio, params) {
-    return select$1i();
+    return select$1j();
 }
 function keyBuilder$c(luvio, params) {
     return keyBuilder$1c(luvio, {
@@ -13896,14 +13912,14 @@ const getContextServiceNodeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextServiceNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$i, getContextServiceNodeMapping_ConfigPropertyMetadata);
-const createResourceParams$i = /*#__PURE__*/ createResourceParams$13(getContextServiceNodeMapping_ConfigPropertyMetadata);
+const createResourceParams$i = /*#__PURE__*/ createResourceParams$14(getContextServiceNodeMapping_ConfigPropertyMetadata);
 function keyBuilder$b(luvio, config) {
     const resourceParams = createResourceParams$i(config);
     return keyBuilder$c(luvio, resourceParams);
 }
 function typeCheckConfig$i(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextServiceNodeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextServiceNodeMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$i(untrustedConfig, configPropertyNames) {
@@ -14012,7 +14028,7 @@ const notifyChangeFactory$3 = (luvio, options) => {
 };
 
 function select$q(luvio, params) {
-    return select$18();
+    return select$19();
 }
 function keyBuilder$a(luvio, params) {
     return keyBuilder$16(luvio, {
@@ -14078,14 +14094,14 @@ const getContextServiceTag_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextTagId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextServiceTag_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$h, getContextServiceTag_ConfigPropertyMetadata);
-const createResourceParams$h = /*#__PURE__*/ createResourceParams$13(getContextServiceTag_ConfigPropertyMetadata);
+const createResourceParams$h = /*#__PURE__*/ createResourceParams$14(getContextServiceTag_ConfigPropertyMetadata);
 function keyBuilder$9(luvio, config) {
     const resourceParams = createResourceParams$h(config);
     return keyBuilder$a(luvio, resourceParams);
 }
 function typeCheckConfig$h(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextServiceTag_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextServiceTag_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$h(untrustedConfig, configPropertyNames) {
@@ -14194,7 +14210,7 @@ const notifyChangeFactory$2 = (luvio, options) => {
 };
 
 function select$p(luvio, params) {
-    return select$P();
+    return select$Q();
 }
 function keyBuilder$8(luvio, params) {
     return keyBuilder$Y(luvio, {
@@ -14261,14 +14277,14 @@ const getContextTags_ConfigPropertyMetadata = [
     generateParamConfigMetadata('includeReferencedDefinitionTags', false, 1 /* QueryParameter */, 1 /* Boolean */),
 ];
 const getContextTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$g, getContextTags_ConfigPropertyMetadata);
-const createResourceParams$g = /*#__PURE__*/ createResourceParams$13(getContextTags_ConfigPropertyMetadata);
+const createResourceParams$g = /*#__PURE__*/ createResourceParams$14(getContextTags_ConfigPropertyMetadata);
 function keyBuilder$7(luvio, config) {
     const resourceParams = createResourceParams$g(config);
     return keyBuilder$8(luvio, resourceParams);
 }
 function typeCheckConfig$g(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextTags_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextTags_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$g(untrustedConfig, configPropertyNames) {
@@ -14581,14 +14597,14 @@ const getContextTranslation_ConfigPropertyMetadata = [
     generateParamConfigMetadata('removeRestrictedFields', false, 1 /* QueryParameter */, 1 /* Boolean */),
 ];
 const getContextTranslation_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, getContextTranslation_ConfigPropertyMetadata);
-const createResourceParams$f = /*#__PURE__*/ createResourceParams$13(getContextTranslation_ConfigPropertyMetadata);
+const createResourceParams$f = /*#__PURE__*/ createResourceParams$14(getContextTranslation_ConfigPropertyMetadata);
 function keyBuilder$5(luvio, config) {
     const resourceParams = createResourceParams$f(config);
     return keyBuilder$6(luvio, resourceParams);
 }
 function typeCheckConfig$f(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getContextTranslation_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getContextTranslation_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
@@ -14718,7 +14734,7 @@ const select$l = function DynamicAttributeByNodeSearchResultRepresentationSelect
                 name: 'dynamicContextAttributes',
                 kind: 'Link',
                 plural: true,
-                fragment: select$17()
+                fragment: select$18()
             },
             {
                 name: 'nodeName',
@@ -15098,14 +15114,14 @@ const getDynamicAttributes_ConfigPropertyMetadata = [
     generateParamConfigMetadata('nodeName', false, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getDynamicAttributes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, getDynamicAttributes_ConfigPropertyMetadata);
-const createResourceParams$e = /*#__PURE__*/ createResourceParams$13(getDynamicAttributes_ConfigPropertyMetadata);
+const createResourceParams$e = /*#__PURE__*/ createResourceParams$14(getDynamicAttributes_ConfigPropertyMetadata);
 function keyBuilder$2(luvio, config) {
     const resourceParams = createResourceParams$e(config);
     return keyBuilder$3(luvio, resourceParams);
 }
 function typeCheckConfig$e(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, getDynamicAttributes_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, getDynamicAttributes_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
@@ -15271,10 +15287,10 @@ const putContextServiceAccess_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextServiceAccessInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const putContextServiceAccess_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, putContextServiceAccess_ConfigPropertyMetadata);
-const createResourceParams$d = /*#__PURE__*/ createResourceParams$13(putContextServiceAccess_ConfigPropertyMetadata);
+const createResourceParams$d = /*#__PURE__*/ createResourceParams$14(putContextServiceAccess_ConfigPropertyMetadata);
 function typeCheckConfig$d(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, putContextServiceAccess_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, putContextServiceAccess_ConfigPropertyMetadata);
     const untrustedConfig_contextServiceAccessInput = untrustedConfig.contextServiceAccessInput;
     const referenceContextServiceAccessInputRepresentationValidationError = validate$5(untrustedConfig_contextServiceAccessInput);
     if (referenceContextServiceAccessInputRepresentationValidationError === null) {
@@ -15957,10 +15973,10 @@ const queryContextRecordAndChildren_ConfigPropertyMetadata = [
     generateParamConfigMetadata('queryContextRecordInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const queryContextRecordAndChildren_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, queryContextRecordAndChildren_ConfigPropertyMetadata);
-const createResourceParams$c = /*#__PURE__*/ createResourceParams$13(queryContextRecordAndChildren_ConfigPropertyMetadata);
+const createResourceParams$c = /*#__PURE__*/ createResourceParams$14(queryContextRecordAndChildren_ConfigPropertyMetadata);
 function typeCheckConfig$c(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, queryContextRecordAndChildren_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, queryContextRecordAndChildren_ConfigPropertyMetadata);
     const untrustedConfig_queryContextRecordInput = untrustedConfig.queryContextRecordInput;
     const referenceQueryContextRecordInputRepresentationValidationError = validate$13(untrustedConfig_queryContextRecordInput);
     if (referenceQueryContextRecordInputRepresentationValidationError === null) {
@@ -16011,7 +16027,7 @@ const queryContextRecordAndChildrenAdapterFactory = (luvio) => {
 };
 
 function select$c(luvio, params) {
-    return select$1j();
+    return select$1k();
 }
 function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$s(storeKeyMap, luvio, response);
@@ -16053,10 +16069,10 @@ const updateContextAttributeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, updateContextAttributeMapping_ConfigPropertyMetadata);
-const createResourceParams$b = /*#__PURE__*/ createResourceParams$13(updateContextAttributeMapping_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$14(updateContextAttributeMapping_ConfigPropertyMetadata);
 function typeCheckConfig$b(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, updateContextAttributeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, updateContextAttributeMapping_ConfigPropertyMetadata);
     const untrustedConfig_contextAttributeMappingInput = untrustedConfig.contextAttributeMappingInput;
     const referenceContextAttributeMappingInputRepresentationValidationError = validate$L(untrustedConfig_contextAttributeMappingInput);
     if (referenceContextAttributeMappingInputRepresentationValidationError === null) {
@@ -16107,7 +16123,7 @@ const updateContextAttributeMappingAdapterFactory = (luvio) => {
 };
 
 function select$b(luvio, params) {
-    return select$1a();
+    return select$1b();
 }
 function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$m(storeKeyMap, luvio, response);
@@ -16149,10 +16165,10 @@ const updateContextAttributeMappings_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextAttributeMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, updateContextAttributeMappings_ConfigPropertyMetadata);
-const createResourceParams$a = /*#__PURE__*/ createResourceParams$13(updateContextAttributeMappings_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$14(updateContextAttributeMappings_ConfigPropertyMetadata);
 function typeCheckConfig$a(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, updateContextAttributeMappings_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, updateContextAttributeMappings_ConfigPropertyMetadata);
     const untrustedConfig_contextAttributeMappingInput = untrustedConfig.contextAttributeMappingInput;
     const referenceContextAttributeMappingListInputRepresentationValidationError = validate$K(untrustedConfig_contextAttributeMappingInput);
     if (referenceContextAttributeMappingListInputRepresentationValidationError === null) {
@@ -16203,7 +16219,7 @@ const updateContextAttributeMappingsAdapterFactory = (luvio) => {
 };
 
 function select$a(luvio, params) {
-    return select$16();
+    return select$17();
 }
 function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$j(storeKeyMap, luvio, response);
@@ -16245,10 +16261,10 @@ const updateContextAttributes_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeListInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextAttributes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, updateContextAttributes_ConfigPropertyMetadata);
-const createResourceParams$9 = /*#__PURE__*/ createResourceParams$13(updateContextAttributes_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$14(updateContextAttributes_ConfigPropertyMetadata);
 function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, updateContextAttributes_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, updateContextAttributes_ConfigPropertyMetadata);
     const untrustedConfig_contextAttributeListInput = untrustedConfig.contextAttributeListInput;
     const referenceContextAttributesListInputRepresentationValidationError = validate$I(untrustedConfig_contextAttributeListInput);
     if (referenceContextAttributesListInputRepresentationValidationError === null) {
@@ -16299,7 +16315,7 @@ const updateContextAttributesAdapterFactory = (luvio) => {
 };
 
 function select$9(luvio, params) {
-    return select$14();
+    return select$15();
 }
 function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$i(storeKeyMap, luvio, response);
@@ -16347,10 +16363,10 @@ const updateContextFilter_ConfigPropertyMetadata = [
     generateParamConfigMetadata('inheritedFrom', false, 2 /* Body */, 0 /* String */),
 ];
 const updateContextFilter_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, updateContextFilter_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$13(updateContextFilter_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$14(updateContextFilter_ConfigPropertyMetadata);
 function typeCheckConfig$8(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, updateContextFilter_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, updateContextFilter_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
@@ -16396,7 +16412,7 @@ const updateContextFilterAdapterFactory = (luvio) => {
 };
 
 function select$8(luvio, params) {
-    return select$1h();
+    return select$1i();
 }
 function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$q(storeKeyMap, luvio, response);
@@ -16438,10 +16454,10 @@ const updateContextMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, updateContextMapping_ConfigPropertyMetadata);
-const createResourceParams$7 = /*#__PURE__*/ createResourceParams$13(updateContextMapping_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$14(updateContextMapping_ConfigPropertyMetadata);
 function typeCheckConfig$7(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, updateContextMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, updateContextMapping_ConfigPropertyMetadata);
     const untrustedConfig_contextMappingInput = untrustedConfig.contextMappingInput;
     const referenceContextMappingInputRepresentationValidationError = validate$B(untrustedConfig_contextMappingInput);
     if (referenceContextMappingInputRepresentationValidationError === null) {
@@ -16492,7 +16508,7 @@ const updateContextMappingAdapterFactory = (luvio) => {
 };
 
 function select$7(luvio, params) {
-    return select$1g();
+    return select$1h();
 }
 function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$p(storeKeyMap, luvio, response);
@@ -16534,10 +16550,10 @@ const updateContextMappings_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, updateContextMappings_ConfigPropertyMetadata);
-const createResourceParams$6 = /*#__PURE__*/ createResourceParams$13(updateContextMappings_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$14(updateContextMappings_ConfigPropertyMetadata);
 function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, updateContextMappings_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, updateContextMappings_ConfigPropertyMetadata);
     const untrustedConfig_contextMappingInput = untrustedConfig.contextMappingInput;
     const referenceContextMappingListInputRepresentationValidationError = validate$A(untrustedConfig_contextMappingInput);
     if (referenceContextMappingListInputRepresentationValidationError === null) {
@@ -16588,7 +16604,7 @@ const updateContextMappingsAdapterFactory = (luvio) => {
 };
 
 function select$6(luvio, params) {
-    return select$1i();
+    return select$1j();
 }
 function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$r(storeKeyMap, luvio, response);
@@ -16630,10 +16646,10 @@ const updateContextNodeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, updateContextNodeMapping_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$13(updateContextNodeMapping_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$14(updateContextNodeMapping_ConfigPropertyMetadata);
 function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, updateContextNodeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, updateContextNodeMapping_ConfigPropertyMetadata);
     const untrustedConfig_contextNodeMappingInput = untrustedConfig.contextNodeMappingInput;
     const referenceContextNodeMappingInputRepresentationValidationError = validate$z(untrustedConfig_contextNodeMappingInput);
     if (referenceContextNodeMappingInputRepresentationValidationError === null) {
@@ -16684,7 +16700,7 @@ const updateContextNodeMappingAdapterFactory = (luvio) => {
 };
 
 function select$5(luvio, params) {
-    return select$_();
+    return select$$();
 }
 function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$g(storeKeyMap, luvio, response);
@@ -16726,10 +16742,10 @@ const updateContextNodeMappings_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextNodeMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, updateContextNodeMappings_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$13(updateContextNodeMappings_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$14(updateContextNodeMappings_ConfigPropertyMetadata);
 function typeCheckConfig$4(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, updateContextNodeMappings_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, updateContextNodeMappings_ConfigPropertyMetadata);
     const untrustedConfig_contextNodeMappingInput = untrustedConfig.contextNodeMappingInput;
     const referenceContextNodeMappingListInputRepresentationValidationError = validate$y(untrustedConfig_contextNodeMappingInput);
     if (referenceContextNodeMappingListInputRepresentationValidationError === null) {
@@ -16780,7 +16796,7 @@ const updateContextNodeMappingsAdapterFactory = (luvio) => {
 };
 
 function select$4(luvio, params) {
-    return select$X();
+    return select$Y();
 }
 function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$e(storeKeyMap, luvio, response);
@@ -16822,10 +16838,10 @@ const updateContextNodes_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextNodes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, updateContextNodes_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$13(updateContextNodes_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$14(updateContextNodes_ConfigPropertyMetadata);
 function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, updateContextNodes_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, updateContextNodes_ConfigPropertyMetadata);
     const untrustedConfig_contextNodeInput = untrustedConfig.contextNodeInput;
     const referenceContextNodeListInputRepresentationValidationError = validate$w(untrustedConfig_contextNodeInput);
     if (referenceContextNodeListInputRepresentationValidationError === null) {
@@ -16876,7 +16892,7 @@ const updateContextNodesAdapterFactory = (luvio) => {
 };
 
 function select$3(luvio, params) {
-    return select$R();
+    return select$S();
 }
 function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$c(storeKeyMap, luvio, response);
@@ -16918,10 +16934,10 @@ const updateContextServiceDefinition_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, updateContextServiceDefinition_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$13(updateContextServiceDefinition_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$14(updateContextServiceDefinition_ConfigPropertyMetadata);
 function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, updateContextServiceDefinition_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, updateContextServiceDefinition_ConfigPropertyMetadata);
     const untrustedConfig_contextDefinitionInput = untrustedConfig.contextDefinitionInput;
     const referenceContextDefinitionsInputRepresentationValidationError = validate$o(untrustedConfig_contextDefinitionInput);
     if (referenceContextDefinitionsInputRepresentationValidationError === null) {
@@ -16972,7 +16988,7 @@ const updateContextServiceDefinitionAdapterFactory = (luvio) => {
 };
 
 function select$2(luvio, params) {
-    return select$P();
+    return select$Q();
 }
 function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$b(storeKeyMap, luvio, response);
@@ -17014,10 +17030,10 @@ const updateContextTags_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextTagInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, updateContextTags_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$13(updateContextTags_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$14(updateContextTags_ConfigPropertyMetadata);
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
-    typeCheckConfig$13(untrustedConfig, config, updateContextTags_ConfigPropertyMetadata);
+    typeCheckConfig$14(untrustedConfig, config, updateContextTags_ConfigPropertyMetadata);
     const untrustedConfig_contextTagInput = untrustedConfig.contextTagInput;
     const referenceContextTagListInputRepresentationValidationError = validate$l(untrustedConfig_contextTagInput);
     if (referenceContextTagListInputRepresentationValidationError === null) {
@@ -17163,7 +17179,7 @@ const select$1 = function ContextDefinitionUpgradeListRepresentationSelect() {
                 name: 'contextDefinitionList',
                 kind: 'Link',
                 plural: true,
-                fragment: select$R()
+                fragment: select$S()
             },
             {
                 name: 'contextDefinitionListId',
@@ -17276,7 +17292,7 @@ const upgradeContextServiceDefinition_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionUpgradesInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const upgradeContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, upgradeContextServiceDefinition_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$13(upgradeContextServiceDefinition_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$14(upgradeContextServiceDefinition_ConfigPropertyMetadata);
 function typeCheckConfig(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextDefinitionUpgradesInput = untrustedConfig.contextDefinitionUpgradesInput;
@@ -17355,6 +17371,7 @@ let deleteContextMapping;
 let deleteContextNodeMapping;
 let deleteContextServiceAttribute;
 let deleteContextServiceAttributeMapping;
+let deleteContextServiceAttributes;
 let deleteContextServiceDefinition;
 let deleteContextServiceMapping;
 let deleteContextServiceNode;
@@ -17578,13 +17595,14 @@ function bindExportsTo(luvio) {
         createContextTags: unwrapSnapshotData(createContextTagsAdapterFactory),
         createContextUpdateAttribute: unwrapSnapshotData(createContextUpdateAttributeAdapterFactory),
         createWriteThroughTags: unwrapSnapshotData(createWriteThroughTagsAdapterFactory),
-        deleteContext: createLDSAdapter(luvio, adapterName$K, deleteContextAdapterFactory),
-        deleteContextAttributeMapping: createLDSAdapter(luvio, adapterName$J, deleteContextAttributeMappingAdapterFactory),
-        deleteContextFilter: createLDSAdapter(luvio, adapterName$I, deleteContextFilterAdapterFactory),
-        deleteContextMapping: createLDSAdapter(luvio, adapterName$H, deleteContextMappingAdapterFactory),
-        deleteContextNodeMapping: createLDSAdapter(luvio, adapterName$G, deleteContextNodeMappingAdapterFactory),
-        deleteContextServiceAttribute: createLDSAdapter(luvio, adapterName$F, deleteContextServiceAttributeAdapterFactory),
-        deleteContextServiceAttributeMapping: createLDSAdapter(luvio, adapterName$E, deleteContextServiceAttributeMappingAdapterFactory),
+        deleteContext: createLDSAdapter(luvio, adapterName$L, deleteContextAdapterFactory),
+        deleteContextAttributeMapping: createLDSAdapter(luvio, adapterName$K, deleteContextAttributeMappingAdapterFactory),
+        deleteContextFilter: createLDSAdapter(luvio, adapterName$J, deleteContextFilterAdapterFactory),
+        deleteContextMapping: createLDSAdapter(luvio, adapterName$I, deleteContextMappingAdapterFactory),
+        deleteContextNodeMapping: createLDSAdapter(luvio, adapterName$H, deleteContextNodeMappingAdapterFactory),
+        deleteContextServiceAttribute: createLDSAdapter(luvio, adapterName$G, deleteContextServiceAttributeAdapterFactory),
+        deleteContextServiceAttributeMapping: createLDSAdapter(luvio, adapterName$F, deleteContextServiceAttributeMappingAdapterFactory),
+        deleteContextServiceAttributes: unwrapSnapshotData(deleteContextServiceAttributesAdapterFactory),
         deleteContextServiceDefinition: createLDSAdapter(luvio, adapterName$D, deleteContextServiceDefinitionAdapterFactory),
         deleteContextServiceMapping: createLDSAdapter(luvio, adapterName$C, deleteContextServiceMappingAdapterFactory),
         deleteContextServiceNode: createLDSAdapter(luvio, adapterName$B, deleteContextServiceNodeAdapterFactory),
@@ -17696,6 +17714,7 @@ withDefaultLuvio((luvio) => {
         deleteContextNodeMapping,
         deleteContextServiceAttribute,
         deleteContextServiceAttributeMapping,
+        deleteContextServiceAttributes,
         deleteContextServiceDefinition,
         deleteContextServiceMapping,
         deleteContextServiceNode,
@@ -17777,5 +17796,5 @@ withDefaultLuvio((luvio) => {
     } = bindExportsTo(luvio));
 });
 
-export { buildAndQueryRecordsFilter, buildContext, buildContextAndQuery, cloneContextMappings, contextDefinitionTransformationClone, createContextAttributeMapping, createContextAttributeMappings, createContextAttributes, createContextFilters, createContextMapping, createContextMappings, createContextNodeMapping, createContextNodeMappings, createContextNodes, createContextQueryRecords, createContextQueryTags, createContextServiceDefinition, createContextTags, createContextUpdateAttribute, createWriteThroughTags, deleteContext, deleteContextAttributeMapping, deleteContextFilter, deleteContextMapping, deleteContextNodeMapping, deleteContextServiceAttribute, deleteContextServiceAttributeMapping, deleteContextServiceDefinition, deleteContextServiceMapping, deleteContextServiceNode, deleteContextServiceNodeMapping, deleteContextServiceTag, deleteContextTransformations, getContext, getContextAttributeMapping, getContextAttributeMappingNotifyChange, getContextAttributeMapping_imperative, getContextDefinitions, getContextDefinitions_imperative, getContextFilter, getContextFilterNotifyChange, getContextFilter_imperative, getContextFilters, getContextFiltersNotifyChange, getContextFilters_imperative, getContextInfo, getContextInfoNotifyChange, getContextInfo_imperative, getContextMapping, getContextMappingNotifyChange, getContextMapping_imperative, getContextNodeMapping, getContextNodeMappingNotifyChange, getContextNodeMapping_imperative, getContextNotifyChange, getContextServiceAccess, getContextServiceAccessNotifyChange, getContextServiceAccess_imperative, getContextServiceAttribute, getContextServiceAttributeMapping, getContextServiceAttributeMappingNotifyChange, getContextServiceAttributeMapping_imperative, getContextServiceAttributeNotifyChange, getContextServiceAttribute_imperative, getContextServiceDefinition, getContextServiceDefinitionInfo, getContextServiceDefinitionInfoNotifyChange, getContextServiceDefinitionInfo_imperative, getContextServiceDefinitionNotifyChange, getContextServiceDefinition_imperative, getContextServiceMapping, getContextServiceMappingNotifyChange, getContextServiceMapping_imperative, getContextServiceNode, getContextServiceNodeMapping, getContextServiceNodeMappingNotifyChange, getContextServiceNodeMapping_imperative, getContextServiceNodeNotifyChange, getContextServiceNode_imperative, getContextServiceTag, getContextServiceTagNotifyChange, getContextServiceTag_imperative, getContextTags, getContextTagsNotifyChange, getContextTags_imperative, getContextTranslation, getContextTranslation_imperative, getContext_imperative, getDynamicAttributes, getDynamicAttributesNotifyChange, getDynamicAttributes_imperative, putContextServiceAccess, queryContextRecordAndChildren, updateContextAttributeMapping, updateContextAttributeMappings, updateContextAttributes, updateContextFilter, updateContextMapping, updateContextMappings, updateContextNodeMapping, updateContextNodeMappings, updateContextNodes, updateContextServiceDefinition, updateContextTags, upgradeContextServiceDefinition };
-// version: 1.444.0-86f5a57eb3
+export { buildAndQueryRecordsFilter, buildContext, buildContextAndQuery, cloneContextMappings, contextDefinitionTransformationClone, createContextAttributeMapping, createContextAttributeMappings, createContextAttributes, createContextFilters, createContextMapping, createContextMappings, createContextNodeMapping, createContextNodeMappings, createContextNodes, createContextQueryRecords, createContextQueryTags, createContextServiceDefinition, createContextTags, createContextUpdateAttribute, createWriteThroughTags, deleteContext, deleteContextAttributeMapping, deleteContextFilter, deleteContextMapping, deleteContextNodeMapping, deleteContextServiceAttribute, deleteContextServiceAttributeMapping, deleteContextServiceAttributes, deleteContextServiceDefinition, deleteContextServiceMapping, deleteContextServiceNode, deleteContextServiceNodeMapping, deleteContextServiceTag, deleteContextTransformations, getContext, getContextAttributeMapping, getContextAttributeMappingNotifyChange, getContextAttributeMapping_imperative, getContextDefinitions, getContextDefinitions_imperative, getContextFilter, getContextFilterNotifyChange, getContextFilter_imperative, getContextFilters, getContextFiltersNotifyChange, getContextFilters_imperative, getContextInfo, getContextInfoNotifyChange, getContextInfo_imperative, getContextMapping, getContextMappingNotifyChange, getContextMapping_imperative, getContextNodeMapping, getContextNodeMappingNotifyChange, getContextNodeMapping_imperative, getContextNotifyChange, getContextServiceAccess, getContextServiceAccessNotifyChange, getContextServiceAccess_imperative, getContextServiceAttribute, getContextServiceAttributeMapping, getContextServiceAttributeMappingNotifyChange, getContextServiceAttributeMapping_imperative, getContextServiceAttributeNotifyChange, getContextServiceAttribute_imperative, getContextServiceDefinition, getContextServiceDefinitionInfo, getContextServiceDefinitionInfoNotifyChange, getContextServiceDefinitionInfo_imperative, getContextServiceDefinitionNotifyChange, getContextServiceDefinition_imperative, getContextServiceMapping, getContextServiceMappingNotifyChange, getContextServiceMapping_imperative, getContextServiceNode, getContextServiceNodeMapping, getContextServiceNodeMappingNotifyChange, getContextServiceNodeMapping_imperative, getContextServiceNodeNotifyChange, getContextServiceNode_imperative, getContextServiceTag, getContextServiceTagNotifyChange, getContextServiceTag_imperative, getContextTags, getContextTagsNotifyChange, getContextTags_imperative, getContextTranslation, getContextTranslation_imperative, getContext_imperative, getDynamicAttributes, getDynamicAttributesNotifyChange, getDynamicAttributes_imperative, putContextServiceAccess, queryContextRecordAndChildren, updateContextAttributeMapping, updateContextAttributeMappings, updateContextAttributes, updateContextFilter, updateContextMapping, updateContextMappings, updateContextNodeMapping, updateContextNodeMappings, updateContextNodes, updateContextServiceDefinition, updateContextTags, upgradeContextServiceDefinition };
+// version: 1.445.0-6d38a08808