npm - @salesforce/lds-adapters-industries-context - Versions diffs - 1.313.0 → 1.315.0 - Mend

@salesforce/lds-adapters-industries-context 1.313.0 → 1.315.0

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

Files changed (13) hide show

package/dist/es/es2018/industries-context.js CHANGED Viewed

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
-import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$Q, typeCheckConfig as typeCheckConfig$Q, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$i } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$R, typeCheckConfig as typeCheckConfig$R, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$i } from '@luvio/engine';
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -112,7 +112,7 @@ function createLink(ref) {
     };
 }
-function validate$J(obj, path = 'QueryContextRecordInputRepresentation') {
+function validate$L(obj, path = 'QueryContextRecordInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -162,7 +162,7 @@ function validate$J(obj, path = 'QueryContextRecordInputRepresentation') {
 }
 const VERSION$u = "6fc1ed5f9fdcaa261c69ec3614505566";
-function validate$I(obj, path = 'ContextDataRecordRepresentation') {
+function validate$K(obj, path = 'ContextDataRecordRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -270,7 +270,7 @@ function validate$I(obj, path = 'ContextDataRecordRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$18 = function ContextDataRecordRepresentationSelect() {
+const select$19 = function ContextDataRecordRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$u,
@@ -499,7 +499,7 @@ function equals$u(existing, incoming) {
 }
 const VERSION$t = "49d8c0b4cc8734f68ac1bc90a4614c4a";
-function validate$H(obj, path = 'ContextQueryRecordRepresentation') {
+function validate$J(obj, path = 'ContextQueryRecordRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -521,7 +521,7 @@ function validate$H(obj, path = 'ContextQueryRecordRepresentation') {
         if (obj.record !== undefined) {
             const obj_record = obj.record;
             const path_record = path + '.record';
-            const referencepath_recordValidationError = validate$I(obj_record, path_record);
+            const referencepath_recordValidationError = validate$K(obj_record, path_record);
             if (referencepath_recordValidationError !== null) {
                 let message = 'Object doesn\'t match ContextDataRecordRepresentation (at "' + path_record + '")\n';
                 message += referencepath_recordValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -531,8 +531,8 @@ function validate$H(obj, path = 'ContextQueryRecordRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$17 = function ContextQueryRecordRepresentationSelect() {
-    const { selections: ContextDataRecordRepresentation__selections, opaque: ContextDataRecordRepresentation__opaque, } = select$18();
+const select$18 = function ContextQueryRecordRepresentationSelect() {
+    const { selections: ContextDataRecordRepresentation__selections, opaque: ContextDataRecordRepresentation__opaque, } = select$19();
     return {
         kind: 'Fragment',
         version: VERSION$t,
@@ -589,7 +589,7 @@ function equals$t(existing, incoming) {
 const TTL$n = 1000;
 const VERSION$s = "d6e0481a792086c09a70a174a9232ada";
-function validate$G(obj, path = 'QueryContextRecordResultRepresentation') {
+function validate$I(obj, path = 'QueryContextRecordResultRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -622,7 +622,7 @@ function validate$G(obj, path = 'QueryContextRecordResultRepresentation') {
             for (let i = 0; i < obj_queryRecords.length; i++) {
                 const obj_queryRecords_item = obj_queryRecords[i];
                 const path_queryRecords_item = path_queryRecords + '[' + i + ']';
-                const referencepath_queryRecords_itemValidationError = validate$H(obj_queryRecords_item, path_queryRecords_item);
+                const referencepath_queryRecords_itemValidationError = validate$J(obj_queryRecords_item, path_queryRecords_item);
                 if (referencepath_queryRecords_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ContextQueryRecordRepresentation (at "' + path_queryRecords_item + '")\n';
                     message += referencepath_queryRecords_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -646,8 +646,8 @@ function keyBuilderFromType$l(luvio, object) {
 function normalize$p(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$16 = function QueryContextRecordResultRepresentationSelect() {
-    const { selections: ContextQueryRecordRepresentation__selections, opaque: ContextQueryRecordRepresentation__opaque, } = select$17();
+const select$17 = function QueryContextRecordResultRepresentationSelect() {
+    const { selections: ContextQueryRecordRepresentation__selections, opaque: ContextQueryRecordRepresentation__opaque, } = select$18();
     return {
         kind: 'Fragment',
         version: VERSION$s,
@@ -731,7 +731,7 @@ function equals$s(existing, incoming) {
 }
 const ingest$p = function QueryContextRecordResultRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$G(input);
+        const validateError = validate$I(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -751,19 +751,19 @@ function getTypeCacheKeys$p(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
-function select$15(luvio, params) {
-    return select$16();
+function select$16(luvio, params) {
+    return select$17();
 }
-function getResponseCacheKeys$P(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$Q(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$p(storeKeyMap, luvio, response);
 }
-function ingestSuccess$F(luvio, resourceParams, response) {
+function ingestSuccess$G(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$15(),
+        node: select$16(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -774,7 +774,7 @@ function ingestSuccess$F(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$P(config) {
+function createResourceRequest$Q(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -788,47 +788,47 @@ function createResourceRequest$P(config) {
     };
 }
-const adapterName$P = 'queryContextRecordAndChildren';
+const adapterName$Q = 'queryContextRecordAndChildren';
 const queryContextRecordAndChildren_ConfigPropertyMetadata = [
     generateParamConfigMetadata('children', false, 1 /* QueryParameter */, 1 /* Boolean */),
     generateParamConfigMetadata('queryContextRecordInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const queryContextRecordAndChildren_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$P, queryContextRecordAndChildren_ConfigPropertyMetadata);
-const createResourceParams$P = /*#__PURE__*/ createResourceParams$Q(queryContextRecordAndChildren_ConfigPropertyMetadata);
-function typeCheckConfig$P(untrustedConfig) {
+const queryContextRecordAndChildren_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$Q, queryContextRecordAndChildren_ConfigPropertyMetadata);
+const createResourceParams$Q = /*#__PURE__*/ createResourceParams$R(queryContextRecordAndChildren_ConfigPropertyMetadata);
+function typeCheckConfig$Q(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, queryContextRecordAndChildren_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, queryContextRecordAndChildren_ConfigPropertyMetadata);
     const untrustedConfig_queryContextRecordInput = untrustedConfig.queryContextRecordInput;
-    const referenceQueryContextRecordInputRepresentationValidationError = validate$J(untrustedConfig_queryContextRecordInput);
+    const referenceQueryContextRecordInputRepresentationValidationError = validate$L(untrustedConfig_queryContextRecordInput);
     if (referenceQueryContextRecordInputRepresentationValidationError === null) {
         config.queryContextRecordInput = untrustedConfig_queryContextRecordInput;
     }
     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$F(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$G(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) => {
@@ -838,18 +838,18 @@ function buildNetworkSnapshot$P(luvio, config, options) {
 }
 const queryContextRecordAndChildrenAdapterFactory = (luvio) => {
     return function queryContextRecordAndChildren(untrustedConfig) {
-        const config = validateAdapterConfig$P(untrustedConfig, queryContextRecordAndChildren_ConfigPropertyNames);
+        const config = validateAdapterConfig$Q(untrustedConfig, queryContextRecordAndChildren_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "queryContextRecordAndChildren"');
         }
-        return buildNetworkSnapshot$P(luvio, config);
+        return buildNetworkSnapshot$Q(luvio, config);
     };
 };
 const TTL$m = 1000;
 const VERSION$r = "f4529c1d2c50b9cc056022fbea50b225";
-function validate$F(obj, path = 'ContextInfoRepresentation') {
+function validate$H(obj, path = 'ContextInfoRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -910,7 +910,7 @@ function keyBuilderFromType$k(luvio, object) {
 function normalize$o(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$14 = function ContextInfoRepresentationSelect() {
+const select$15 = function ContextInfoRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$r,
@@ -926,7 +926,7 @@ function equals$r(existing, incoming) {
 }
 const ingest$o = function ContextInfoRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$F(input);
+        const validateError = validate$H(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -946,24 +946,24 @@ function getTypeCacheKeys$o(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
-function select$13(luvio, params) {
-    return select$14();
+function select$14(luvio, params) {
+    return select$15();
 }
 function keyBuilder$11(luvio, params) {
     return keyBuilder$12(luvio, {
         id: params.urlParams.contextId
     });
 }
-function getResponseCacheKeys$O(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$P(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$o(storeKeyMap, luvio, response);
 }
-function ingestSuccess$E(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$F(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$11(luvio, resourceParams);
     luvio.storeIngest(key, ingest$o, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$13(),
+        node: select$14(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -986,7 +986,7 @@ function ingestError$h(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$O(config) {
+function createResourceRequest$P(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -1000,60 +1000,60 @@ function createResourceRequest$O(config) {
     };
 }
-const adapterName$O = 'getContext';
+const adapterName$P = 'getContext';
 const getContext_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getContext_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$O, getContext_ConfigPropertyMetadata);
-const createResourceParams$O = /*#__PURE__*/ createResourceParams$Q(getContext_ConfigPropertyMetadata);
+const getContext_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$P, getContext_ConfigPropertyMetadata);
+const createResourceParams$P = /*#__PURE__*/ createResourceParams$R(getContext_ConfigPropertyMetadata);
 function keyBuilder$10(luvio, config) {
-    const resourceParams = createResourceParams$O(config);
+    const resourceParams = createResourceParams$P(config);
     return keyBuilder$11(luvio, resourceParams);
 }
-function typeCheckConfig$O(untrustedConfig) {
+function typeCheckConfig$P(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContext_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContext_ConfigPropertyMetadata);
     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 adapterFragment$h(luvio, config) {
-    createResourceParams$O(config);
-    return select$13();
+    createResourceParams$P(config);
+    return select$14();
 }
 function onFetchResponseSuccess$h(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$E(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$F(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$O(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$P(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$h(luvio, config, resourceParams, response) {
     const snapshot = ingestError$h(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$O(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$P(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-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(() => onFetchResponseSuccess$h(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$O(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$P(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1061,7 +1061,7 @@ function buildNetworkSnapshot$O(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$O, undefined, false);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$P, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$h(context, storeLookup) {
     const { luvio, config } = context;
@@ -1072,12 +1072,12 @@ function buildCachedSnapshotCachePolicy$h(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$O(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$P(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getContextAdapterFactory = (luvio) => function IndustriesContext__getContext(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$O(untrustedConfig, getContext_ConfigPropertyNames);
+    const config = validateAdapterConfig$P(untrustedConfig, getContext_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -1088,7 +1088,7 @@ const getContextAdapterFactory = (luvio) => function IndustriesContext__getConte
 const TTL$l = 1000;
 const VERSION$q = "ad70f246fe62dc8126e558799bc7a155";
-function validate$E(obj, path = 'ContextDefinitionInfoRepresentation') {
+function validate$G(obj, path = 'ContextDefinitionInfoRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1233,7 +1233,7 @@ function keyBuilderFromType$j(luvio, object) {
 function normalize$n(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$12 = function ContextDefinitionInfoRepresentationSelect() {
+const select$13 = function ContextDefinitionInfoRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$q,
@@ -1562,7 +1562,7 @@ function equals$q(existing, incoming) {
 }
 const ingest$n = function ContextDefinitionInfoRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$E(input);
+        const validateError = validate$G(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -1584,7 +1584,7 @@ function getTypeCacheKeys$n(rootKeySet, luvio, input, fullPathFactory) {
 const TTL$k = 1000;
 const VERSION$p = "9fd2c86ba3bfc49bd6b1b41332fbad4e";
-function validate$D(obj, path = 'ContextDefinitionListRepresentation') {
+function validate$F(obj, path = 'ContextDefinitionListRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1636,7 +1636,7 @@ function normalize$m(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$11 = function ContextDefinitionListRepresentationSelect() {
+const select$12 = function ContextDefinitionListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$p,
@@ -1646,7 +1646,7 @@ const select$11 = function ContextDefinitionListRepresentationSelect() {
                 name: 'contextDefinitionList',
                 kind: 'Link',
                 plural: true,
-                fragment: select$12()
+                fragment: select$13()
             },
             {
                 name: 'contextDefinitionListId',
@@ -1693,7 +1693,7 @@ function equals$p(existing, incoming) {
 }
 const ingest$m = function ContextDefinitionListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$D(input);
+        const validateError = validate$F(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -1717,22 +1717,22 @@ function getTypeCacheKeys$m(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$10(luvio, params) {
-    return select$11();
+function select$11(luvio, params) {
+    return select$12();
 }
 function keyBuilder$_(luvio, params) {
     return keyPrefix + '::ContextDefinitionListRepresentation:(' + 'includeInactive:' + params.queryParams.includeInactive + ',' + 'includeUpgrade:' + params.queryParams.includeUpgrade + ')';
 }
-function getResponseCacheKeys$N(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$O(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$m(storeKeyMap, luvio, response, () => keyBuilder$_(luvio, resourceParams));
 }
-function ingestSuccess$D(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$E(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$_(luvio, resourceParams);
     luvio.storeIngest(key, ingest$m, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$10(),
+        node: select$11(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1755,7 +1755,7 @@ function ingestError$g(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$N(config) {
+function createResourceRequest$O(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -1769,61 +1769,61 @@ function createResourceRequest$N(config) {
     };
 }
-const adapterName$N = 'getContextDefinitions';
+const adapterName$O = 'getContextDefinitions';
 const getContextDefinitions_ConfigPropertyMetadata = [
     generateParamConfigMetadata('includeInactive', false, 1 /* QueryParameter */, 1 /* Boolean */),
     generateParamConfigMetadata('includeUpgrade', false, 1 /* QueryParameter */, 1 /* Boolean */),
 ];
-const getContextDefinitions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$N, getContextDefinitions_ConfigPropertyMetadata);
-const createResourceParams$N = /*#__PURE__*/ createResourceParams$Q(getContextDefinitions_ConfigPropertyMetadata);
+const getContextDefinitions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$O, getContextDefinitions_ConfigPropertyMetadata);
+const createResourceParams$O = /*#__PURE__*/ createResourceParams$R(getContextDefinitions_ConfigPropertyMetadata);
 function keyBuilder$Z(luvio, config) {
-    const resourceParams = createResourceParams$N(config);
+    const resourceParams = createResourceParams$O(config);
     return keyBuilder$_(luvio, resourceParams);
 }
-function typeCheckConfig$N(untrustedConfig) {
+function typeCheckConfig$O(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextDefinitions_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextDefinitions_ConfigPropertyMetadata);
     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 adapterFragment$g(luvio, config) {
-    createResourceParams$N(config);
-    return select$10();
+    createResourceParams$O(config);
+    return select$11();
 }
 function onFetchResponseSuccess$g(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$D(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$E(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$N(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$O(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$g(luvio, config, resourceParams, response) {
     const snapshot = ingestError$g(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$N(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$O(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-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(() => onFetchResponseSuccess$g(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$N(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$O(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1831,7 +1831,7 @@ function buildNetworkSnapshot$N(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$N, undefined, false);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$O, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$g(context, storeLookup) {
     const { luvio, config } = context;
@@ -1842,12 +1842,12 @@ function buildCachedSnapshotCachePolicy$g(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$N(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$O(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getContextDefinitionsAdapterFactory = (luvio) => function IndustriesContext__getContextDefinitions(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$N(untrustedConfig, getContextDefinitions_ConfigPropertyNames);
+    const config = validateAdapterConfig$O(untrustedConfig, getContextDefinitions_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -1856,7 +1856,7 @@ const getContextDefinitionsAdapterFactory = (luvio) => function IndustriesContex
     buildCachedSnapshotCachePolicy$g, buildNetworkSnapshotCachePolicy$g);
 };
-function validate$C(obj, path = 'ContextDefinitionsInputRepresentation') {
+function validate$E(obj, path = 'ContextDefinitionsInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1935,19 +1935,19 @@ function validate$C(obj, path = 'ContextDefinitionsInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
-function select$$(luvio, params) {
-    return select$12();
+function select$10(luvio, params) {
+    return select$13();
 }
-function getResponseCacheKeys$M(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$N(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$n(storeKeyMap, luvio, response);
 }
-function ingestSuccess$C(luvio, resourceParams, response) {
+function ingestSuccess$D(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$$(),
+        node: select$10(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1958,7 +1958,7 @@ function ingestSuccess$C(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$M(config) {
+function createResourceRequest$N(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -1972,45 +1972,45 @@ function createResourceRequest$M(config) {
     };
 }
-const adapterName$M = 'createContextServiceDefinition';
+const adapterName$N = 'createContextServiceDefinition';
 const createContextServiceDefinition_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$M, createContextServiceDefinition_ConfigPropertyMetadata);
-const createResourceParams$M = /*#__PURE__*/ createResourceParams$Q(createContextServiceDefinition_ConfigPropertyMetadata);
-function typeCheckConfig$M(untrustedConfig) {
+const createContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$N, createContextServiceDefinition_ConfigPropertyMetadata);
+const createResourceParams$N = /*#__PURE__*/ createResourceParams$R(createContextServiceDefinition_ConfigPropertyMetadata);
+function typeCheckConfig$N(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextDefinitionInput = untrustedConfig.contextDefinitionInput;
-    const referenceContextDefinitionsInputRepresentationValidationError = validate$C(untrustedConfig_contextDefinitionInput);
+    const referenceContextDefinitionsInputRepresentationValidationError = validate$E(untrustedConfig_contextDefinitionInput);
     if (referenceContextDefinitionsInputRepresentationValidationError === null) {
         config.contextDefinitionInput = untrustedConfig_contextDefinitionInput;
     }
     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$C(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$D(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) => {
@@ -2020,33 +2020,33 @@ function buildNetworkSnapshot$M(luvio, config, options) {
 }
 const createContextServiceDefinitionAdapterFactory = (luvio) => {
     return function createContextServiceDefinition(untrustedConfig) {
-        const config = validateAdapterConfig$M(untrustedConfig, createContextServiceDefinition_ConfigPropertyNames);
+        const config = validateAdapterConfig$N(untrustedConfig, createContextServiceDefinition_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextServiceDefinition"');
         }
-        return buildNetworkSnapshot$M(luvio, config);
+        return buildNetworkSnapshot$N(luvio, config);
     };
 };
-function select$_(luvio, params) {
-    return select$12();
+function select$$(luvio, params) {
+    return select$13();
 }
 function keyBuilder$Y(luvio, params) {
     return keyBuilder$$(luvio, {
         id: params.urlParams.contextDefinitionId
     });
 }
-function getResponseCacheKeys$L(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$M(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$n(storeKeyMap, luvio, response);
 }
-function ingestSuccess$B(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$C(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$Y(luvio, resourceParams);
     luvio.storeIngest(key, ingest$n, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$_(),
+        node: select$$(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2069,7 +2069,7 @@ function ingestError$f(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$L(config) {
+function createResourceRequest$M(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -2083,60 +2083,60 @@ function createResourceRequest$L(config) {
     };
 }
-const adapterName$L = 'getContextServiceDefinitionInfo';
+const adapterName$M = 'getContextServiceDefinitionInfo';
 const getContextServiceDefinitionInfo_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getContextServiceDefinitionInfo_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$L, getContextServiceDefinitionInfo_ConfigPropertyMetadata);
-const createResourceParams$L = /*#__PURE__*/ createResourceParams$Q(getContextServiceDefinitionInfo_ConfigPropertyMetadata);
+const getContextServiceDefinitionInfo_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$M, getContextServiceDefinitionInfo_ConfigPropertyMetadata);
+const createResourceParams$M = /*#__PURE__*/ createResourceParams$R(getContextServiceDefinitionInfo_ConfigPropertyMetadata);
 function keyBuilder$X(luvio, config) {
-    const resourceParams = createResourceParams$L(config);
+    const resourceParams = createResourceParams$M(config);
     return keyBuilder$Y(luvio, resourceParams);
 }
-function typeCheckConfig$L(untrustedConfig) {
+function typeCheckConfig$M(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextServiceDefinitionInfo_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextServiceDefinitionInfo_ConfigPropertyMetadata);
     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 adapterFragment$f(luvio, config) {
-    createResourceParams$L(config);
-    return select$_();
+    createResourceParams$M(config);
+    return select$$();
 }
 function onFetchResponseSuccess$f(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$B(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$C(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$L(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$M(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$f(luvio, config, resourceParams, response) {
     const snapshot = ingestError$f(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$L(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$M(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-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(() => onFetchResponseSuccess$f(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$L(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$M(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2144,7 +2144,7 @@ function buildNetworkSnapshot$L(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$L, undefined, false);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$M, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$f(context, storeLookup) {
     const { luvio, config } = context;
@@ -2155,12 +2155,12 @@ function buildCachedSnapshotCachePolicy$f(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$L(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$M(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getContextServiceDefinitionInfoAdapterFactory = (luvio) => function IndustriesContext__getContextServiceDefinitionInfo(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$L(untrustedConfig, getContextServiceDefinitionInfo_ConfigPropertyNames);
+    const config = validateAdapterConfig$M(untrustedConfig, getContextServiceDefinitionInfo_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -2169,7 +2169,7 @@ const getContextServiceDefinitionInfoAdapterFactory = (luvio) => function Indust
     buildCachedSnapshotCachePolicy$f, buildNetworkSnapshotCachePolicy$f);
 };
-function validate$B(obj, path = 'ContextDefinitionUpgradeListInputRepresentation') {
+function validate$D(obj, path = 'ContextDefinitionUpgradeListInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2194,7 +2194,7 @@ function validate$B(obj, path = 'ContextDefinitionUpgradeListInputRepresentation
 const TTL$j = 1000;
 const VERSION$o = "0f55f143dba32bcf6d4a3ba8ced13b41";
-function validate$A(obj, path = 'ContextDefinitionUpgradeListRepresentation') {
+function validate$C(obj, path = 'ContextDefinitionUpgradeListRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2255,7 +2255,7 @@ function normalize$l(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$Z = function ContextDefinitionUpgradeListRepresentationSelect() {
+const select$_ = function ContextDefinitionUpgradeListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$o,
@@ -2265,7 +2265,7 @@ const select$Z = function ContextDefinitionUpgradeListRepresentationSelect() {
                 name: 'contextDefinitionList',
                 kind: 'Link',
                 plural: true,
-                fragment: select$12()
+                fragment: select$13()
             },
             {
                 name: 'contextDefinitionListId',
@@ -2312,7 +2312,7 @@ function equals$o(existing, incoming) {
 }
 const ingest$l = function ContextDefinitionUpgradeListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$A(input);
+        const validateError = validate$C(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -2336,19 +2336,19 @@ function getTypeCacheKeys$l(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$Y(luvio, params) {
-    return select$Z();
+function select$Z(luvio, params) {
+    return select$_();
 }
-function getResponseCacheKeys$K(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$L(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$l(storeKeyMap, luvio, response);
 }
-function ingestSuccess$A(luvio, resourceParams, response) {
+function ingestSuccess$B(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$i(luvio, body);
     luvio.storeIngest(key, ingest$l, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$Y(),
+        node: select$Z(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -2359,7 +2359,7 @@ function ingestSuccess$A(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$K(config) {
+function createResourceRequest$L(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -2373,45 +2373,45 @@ function createResourceRequest$K(config) {
     };
 }
-const adapterName$K = 'upgradeContextServiceDefinition';
+const adapterName$L = 'upgradeContextServiceDefinition';
 const upgradeContextServiceDefinition_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionUpgradesInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const upgradeContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$K, upgradeContextServiceDefinition_ConfigPropertyMetadata);
-const createResourceParams$K = /*#__PURE__*/ createResourceParams$Q(upgradeContextServiceDefinition_ConfigPropertyMetadata);
-function typeCheckConfig$K(untrustedConfig) {
+const upgradeContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$L, upgradeContextServiceDefinition_ConfigPropertyMetadata);
+const createResourceParams$L = /*#__PURE__*/ createResourceParams$R(upgradeContextServiceDefinition_ConfigPropertyMetadata);
+function typeCheckConfig$L(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextDefinitionUpgradesInput = untrustedConfig.contextDefinitionUpgradesInput;
-    const referenceContextDefinitionUpgradeListInputRepresentationValidationError = validate$B(untrustedConfig_contextDefinitionUpgradesInput);
+    const referenceContextDefinitionUpgradeListInputRepresentationValidationError = validate$D(untrustedConfig_contextDefinitionUpgradesInput);
     if (referenceContextDefinitionUpgradeListInputRepresentationValidationError === null) {
         config.contextDefinitionUpgradesInput = untrustedConfig_contextDefinitionUpgradesInput;
     }
     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((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$K(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$L(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2421,17 +2421,17 @@ function buildNetworkSnapshot$K(luvio, config, options) {
 }
 const upgradeContextServiceDefinitionAdapterFactory = (luvio) => {
     return function upgradeContextServiceDefinition(untrustedConfig) {
-        const config = validateAdapterConfig$K(untrustedConfig, upgradeContextServiceDefinition_ConfigPropertyNames);
+        const config = validateAdapterConfig$L(untrustedConfig, upgradeContextServiceDefinition_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "upgradeContextServiceDefinition"');
         }
-        return buildNetworkSnapshot$K(luvio, config);
+        return buildNetworkSnapshot$L(luvio, config);
     };
 };
 const VERSION$n = "40b52866e6f56ae5b7cfb279bcfae6ce";
-function validate$z(obj, path = 'ContextAttrContextHydrationDetailRepresentation') {
+function validate$B(obj, path = 'ContextAttrContextHydrationDetailRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2467,7 +2467,7 @@ function validate$z(obj, path = 'ContextAttrContextHydrationDetailRepresentation
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$X = function ContextAttrContextHydrationDetailRepresentationSelect() {
+const select$Y = function ContextAttrContextHydrationDetailRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$n,
@@ -2552,7 +2552,7 @@ function equals$n(existing, incoming) {
     return true;
 }
-function validate$y(obj, path = 'MappedAttributeDataTypeInfoRepresentation') {
+function validate$A(obj, path = 'MappedAttributeDataTypeInfoRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2584,7 +2584,7 @@ function validate$y(obj, path = 'MappedAttributeDataTypeInfoRepresentation') {
 const TTL$i = 1000;
 const VERSION$m = "c80a3e493f49341d9f4ab684e28db7ba";
-function validate$x(obj, path = 'ContextAttrHydrationDetailRepresentation') {
+function validate$z(obj, path = 'ContextAttrHydrationDetailRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2625,7 +2625,7 @@ function validate$x(obj, path = 'ContextAttrHydrationDetailRepresentation') {
         if (obj.mappedAttributeDataTypeInfo !== undefined) {
             const obj_mappedAttributeDataTypeInfo = obj.mappedAttributeDataTypeInfo;
             const path_mappedAttributeDataTypeInfo = path + '.mappedAttributeDataTypeInfo';
-            const referencepath_mappedAttributeDataTypeInfoValidationError = validate$y(obj_mappedAttributeDataTypeInfo, path_mappedAttributeDataTypeInfo);
+            const referencepath_mappedAttributeDataTypeInfoValidationError = validate$A(obj_mappedAttributeDataTypeInfo, path_mappedAttributeDataTypeInfo);
             if (referencepath_mappedAttributeDataTypeInfoValidationError !== null) {
                 let message = 'Object doesn\'t match MappedAttributeDataTypeInfoRepresentation (at "' + path_mappedAttributeDataTypeInfo + '")\n';
                 message += referencepath_mappedAttributeDataTypeInfoValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2669,7 +2669,7 @@ function keyBuilderFromType$h(luvio, object) {
 function normalize$k(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$W = function ContextAttrHydrationDetailRepresentationSelect() {
+const select$X = function ContextAttrHydrationDetailRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$m,
@@ -2685,7 +2685,7 @@ function equals$m(existing, incoming) {
 }
 const ingest$k = function ContextAttrHydrationDetailRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$x(input);
+        const validateError = validate$z(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -2707,7 +2707,7 @@ function getTypeCacheKeys$k(rootKeySet, luvio, input, fullPathFactory) {
 const TTL$h = 1000;
 const VERSION$l = "539359f9069e5a51a579221aeaef8234";
-function validate$w(obj, path = 'ContextAttributeMappingRepresentation') {
+function validate$y(obj, path = 'ContextAttributeMappingRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2728,7 +2728,7 @@ function validate$w(obj, path = 'ContextAttributeMappingRepresentation') {
             for (let i = 0; i < obj_contextAttrContextHydrationDetailList.length; i++) {
                 const obj_contextAttrContextHydrationDetailList_item = obj_contextAttrContextHydrationDetailList[i];
                 const path_contextAttrContextHydrationDetailList_item = path_contextAttrContextHydrationDetailList + '[' + i + ']';
-                const referencepath_contextAttrContextHydrationDetailList_itemValidationError = validate$z(obj_contextAttrContextHydrationDetailList_item, path_contextAttrContextHydrationDetailList_item);
+                const referencepath_contextAttrContextHydrationDetailList_itemValidationError = validate$B(obj_contextAttrContextHydrationDetailList_item, path_contextAttrContextHydrationDetailList_item);
                 if (referencepath_contextAttrContextHydrationDetailList_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ContextAttrContextHydrationDetailRepresentation (at "' + path_contextAttrContextHydrationDetailList_item + '")\n';
                     message += referencepath_contextAttrContextHydrationDetailList_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2827,8 +2827,8 @@ function normalize$j(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$V = function ContextAttributeMappingRepresentationSelect() {
-    const { selections: ContextAttrContextHydrationDetailRepresentation__selections, opaque: ContextAttrContextHydrationDetailRepresentation__opaque, } = select$X();
+const select$W = function ContextAttributeMappingRepresentationSelect() {
+    const { selections: ContextAttrContextHydrationDetailRepresentation__selections, opaque: ContextAttrContextHydrationDetailRepresentation__opaque, } = select$Y();
     return {
         kind: 'Fragment',
         version: VERSION$l,
@@ -2850,7 +2850,7 @@ const select$V = function ContextAttributeMappingRepresentationSelect() {
                 name: 'contextAttrHydrationDetailList',
                 kind: 'Link',
                 plural: true,
-                fragment: select$W()
+                fragment: select$X()
             },
             {
                 name: 'contextAttributeId',
@@ -3018,7 +3018,7 @@ function equals$l(existing, incoming) {
 }
 const ingest$j = function ContextAttributeMappingRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$w(input);
+        const validateError = validate$y(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -3044,7 +3044,7 @@ function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
 const TTL$g = 1000;
 const VERSION$k = "0f7420d3c8dbe149876b673d81e43341";
-function validate$v(obj, path = 'ContextNodeMappingRepresentation') {
+function validate$x(obj, path = 'ContextNodeMappingRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3140,7 +3140,7 @@ function normalize$i(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$U = function ContextNodeMappingRepresentationSelect() {
+const select$V = function ContextNodeMappingRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$k,
@@ -3150,7 +3150,7 @@ const select$U = function ContextNodeMappingRepresentationSelect() {
                 name: 'attributeMappings',
                 kind: 'Link',
                 plural: true,
-                fragment: select$V()
+                fragment: select$W()
             },
             {
                 name: 'baseReference',
@@ -3287,7 +3287,7 @@ function equals$k(existing, incoming) {
 }
 const ingest$i = function ContextNodeMappingRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$v(input);
+        const validateError = validate$x(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -3313,7 +3313,7 @@ function getTypeCacheKeys$i(rootKeySet, luvio, input, fullPathFactory) {
 const TTL$f = 1000;
 const VERSION$j = "6625536779234428522beec438ddd863";
-function validate$u(obj, path = 'ContextMappingRepresentation') {
+function validate$w(obj, path = 'ContextMappingRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3437,7 +3437,7 @@ function normalize$h(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$T = function ContextMappingRepresentationSelect() {
+const select$U = function ContextMappingRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$j,
@@ -3461,7 +3461,7 @@ const select$T = function ContextMappingRepresentationSelect() {
                 name: 'contextNodeMappings',
                 kind: 'Link',
                 plural: true,
-                fragment: select$U()
+                fragment: select$V()
             },
             {
                 name: 'description',
@@ -3644,7 +3644,7 @@ function equals$j(existing, incoming) {
 }
 const ingest$h = function ContextMappingRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$u(input);
+        const validateError = validate$w(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -3670,7 +3670,7 @@ function getTypeCacheKeys$h(rootKeySet, luvio, input, fullPathFactory) {
 const TTL$e = 1000;
 const VERSION$i = "a300c24f902a30815a81527b587d20c1";
-function validate$t(obj, path = 'ContextAttributeTagRepresentation') {
+function validate$v(obj, path = 'ContextAttributeTagRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3731,7 +3731,7 @@ function keyBuilderFromType$d(luvio, object) {
 function normalize$g(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$S = function ContextAttributeTagRepresentationSelect() {
+const select$T = function ContextAttributeTagRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$i,
@@ -3844,7 +3844,7 @@ function equals$i(existing, incoming) {
 }
 const ingest$g = function ContextAttributeTagRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$t(input);
+        const validateError = validate$v(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -3866,7 +3866,7 @@ function getTypeCacheKeys$g(rootKeySet, luvio, input, fullPathFactory) {
 const TTL$d = 1000;
 const VERSION$h = "282c9c4929283780bca9810492255898";
-function validate$s(obj, path = 'ContextAttributeRepresentation') {
+function validate$u(obj, path = 'ContextAttributeRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4011,7 +4011,7 @@ function normalize$f(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$R = function ContextAttributeRepresentationSelect() {
+const select$S = function ContextAttributeRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$h,
@@ -4031,7 +4031,7 @@ const select$R = function ContextAttributeRepresentationSelect() {
                 name: 'attributeTags',
                 kind: 'Link',
                 plural: true,
-                fragment: select$S()
+                fragment: select$T()
             },
             {
                 name: 'baseReference',
@@ -4284,7 +4284,7 @@ function equals$h(existing, incoming) {
 }
 const ingest$f = function ContextAttributeRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$s(input);
+        const validateError = validate$u(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -4310,7 +4310,7 @@ function getTypeCacheKeys$f(rootKeySet, luvio, input, fullPathFactory) {
 const TTL$c = 1000;
 const VERSION$g = "a2112475391d5036b4b433a57296e868";
-function validate$r(obj, path = 'ContextNodeRepresentation') {
+function validate$t(obj, path = 'ContextNodeRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4324,7 +4324,7 @@ function validate$r(obj, path = 'ContextNodeRepresentation') {
             for (let i = 0; i < obj_attributes.length; i++) {
                 const obj_attributes_item = obj_attributes[i];
                 const path_attributes_item = path_attributes + '[' + i + ']';
-                const referencepath_attributes_itemValidationError = validate$s(obj_attributes_item, path_attributes_item);
+                const referencepath_attributes_itemValidationError = validate$u(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');
@@ -4348,7 +4348,7 @@ function validate$r(obj, path = 'ContextNodeRepresentation') {
             for (let i = 0; i < obj_childNodes.length; i++) {
                 const obj_childNodes_item = obj_childNodes[i];
                 const path_childNodes_item = path_childNodes + '[' + i + ']';
-                const referencepath_childNodes_itemValidationError = validate$r(obj_childNodes_item, path_childNodes_item);
+                const referencepath_childNodes_itemValidationError = validate$t(obj_childNodes_item, path_childNodes_item);
                 if (referencepath_childNodes_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ContextNodeRepresentation (at "' + path_childNodes_item + '")\n';
                     message += referencepath_childNodes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4405,7 +4405,7 @@ function validate$r(obj, path = 'ContextNodeRepresentation') {
             for (let i = 0; i < obj_tags.length; i++) {
                 const obj_tags_item = obj_tags[i];
                 const path_tags_item = path_tags + '[' + i + ']';
-                const referencepath_tags_itemValidationError = validate$t(obj_tags_item, path_tags_item);
+                const referencepath_tags_itemValidationError = validate$v(obj_tags_item, path_tags_item);
                 if (referencepath_tags_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ContextAttributeTagRepresentation (at "' + path_tags_item + '")\n';
                     message += referencepath_tags_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4429,7 +4429,7 @@ function keyBuilderFromType$b(luvio, object) {
 function normalize$e(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$Q = function ContextNodeRepresentationSelect() {
+const select$R = function ContextNodeRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$g,
@@ -4445,7 +4445,7 @@ function equals$g(existing, incoming) {
 }
 const ingest$e = function ContextNodeRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$r(input);
+        const validateError = validate$t(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -4467,7 +4467,7 @@ function getTypeCacheKeys$e(rootKeySet, luvio, input, fullPathFactory) {
 const TTL$b = 1000;
 const VERSION$f = "6425fc4d86a786410d0253c23dffe29d";
-function validate$q(obj, path = 'ContextDefinitionVersionRepresentation') {
+function validate$s(obj, path = 'ContextDefinitionVersionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4493,7 +4493,7 @@ function validate$q(obj, path = 'ContextDefinitionVersionRepresentation') {
             for (let i = 0; i < obj_contextMappings.length; i++) {
                 const obj_contextMappings_item = obj_contextMappings[i];
                 const path_contextMappings_item = path_contextMappings + '[' + i + ']';
-                const referencepath_contextMappings_itemValidationError = validate$u(obj_contextMappings_item, path_contextMappings_item);
+                const referencepath_contextMappings_itemValidationError = validate$w(obj_contextMappings_item, path_contextMappings_item);
                 if (referencepath_contextMappings_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ContextMappingRepresentation (at "' + path_contextMappings_item + '")\n';
                     message += referencepath_contextMappings_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4510,7 +4510,7 @@ function validate$q(obj, path = 'ContextDefinitionVersionRepresentation') {
             for (let i = 0; i < obj_contextNodes.length; i++) {
                 const obj_contextNodes_item = obj_contextNodes[i];
                 const path_contextNodes_item = path_contextNodes + '[' + i + ']';
-                const referencepath_contextNodes_itemValidationError = validate$r(obj_contextNodes_item, path_contextNodes_item);
+                const referencepath_contextNodes_itemValidationError = validate$t(obj_contextNodes_item, path_contextNodes_item);
                 if (referencepath_contextNodes_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ContextNodeRepresentation (at "' + path_contextNodes_item + '")\n';
                     message += referencepath_contextNodes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4576,7 +4576,7 @@ function keyBuilderFromType$a(luvio, object) {
 function normalize$d(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$P = function ContextDefinitionVersionRepresentationSelect() {
+const select$Q = function ContextDefinitionVersionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$f,
@@ -4592,7 +4592,7 @@ function equals$f(existing, incoming) {
 }
 const ingest$d = function ContextDefinitionVersionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$q(input);
+        const validateError = validate$s(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -4614,7 +4614,7 @@ function getTypeCacheKeys$d(rootKeySet, luvio, input, fullPathFactory) {
 const TTL$a = 1000;
 const VERSION$e = "99ff491146690a2811567bddaad66d11";
-function validate$p(obj, path = 'ContextDefinitionRepresentation') {
+function validate$r(obj, path = 'ContextDefinitionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4745,7 +4745,7 @@ function normalize$c(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$O = function ContextDefinitionRepresentationSelect() {
+const select$P = function ContextDefinitionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$e,
@@ -4769,7 +4769,7 @@ const select$O = function ContextDefinitionRepresentationSelect() {
                 name: 'contextDefinitionVersionList',
                 kind: 'Link',
                 plural: true,
-                fragment: select$P()
+                fragment: select$Q()
             },
             {
                 name: 'contextTtl',
@@ -4982,7 +4982,7 @@ function equals$e(existing, incoming) {
 }
 const ingest$c = function ContextDefinitionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$p(input);
+        const validateError = validate$r(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -5011,7 +5011,7 @@ function keyBuilder$M(luvio, params) {
         id: params.urlParams.contextDefinitionId
     });
 }
-function getResponseCacheKeys$J(cacheKeyMap, luvio, resourceParams) {
+function getResponseCacheKeys$K(cacheKeyMap, luvio, resourceParams) {
     const key = keyBuilder$M(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
@@ -5023,7 +5023,7 @@ function evictSuccess$9(luvio, resourceParams) {
     const key = keyBuilder$M(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$J(config) {
+function createResourceRequest$K(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -5037,33 +5037,33 @@ function createResourceRequest$J(config) {
     };
 }
-const adapterName$J = 'deleteContextServiceDefinition';
+const adapterName$K = 'deleteContextServiceDefinition';
 const deleteContextServiceDefinition_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$J, deleteContextServiceDefinition_ConfigPropertyMetadata);
-const createResourceParams$J = /*#__PURE__*/ createResourceParams$Q(deleteContextServiceDefinition_ConfigPropertyMetadata);
-function typeCheckConfig$J(untrustedConfig) {
+const deleteContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$K, deleteContextServiceDefinition_ConfigPropertyMetadata);
+const createResourceParams$K = /*#__PURE__*/ createResourceParams$R(deleteContextServiceDefinition_ConfigPropertyMetadata);
+function typeCheckConfig$K(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, deleteContextServiceDefinition_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, deleteContextServiceDefinition_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(() => {
@@ -5071,7 +5071,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) => {
@@ -5081,33 +5081,33 @@ function buildNetworkSnapshot$J(luvio, config, options) {
 }
 const deleteContextServiceDefinitionAdapterFactory = (luvio) => {
     return function IndustriesContextdeleteContextServiceDefinition(untrustedConfig) {
-        const config = validateAdapterConfig$J(untrustedConfig, deleteContextServiceDefinition_ConfigPropertyNames);
+        const config = validateAdapterConfig$K(untrustedConfig, deleteContextServiceDefinition_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);
     };
 };
-function select$N(luvio, params) {
-    return select$O();
+function select$O(luvio, params) {
+    return select$P();
 }
 function keyBuilder$L(luvio, params) {
     return keyBuilder$N(luvio, {
         id: params.urlParams.contextDefinitionId
     });
 }
-function getResponseCacheKeys$I(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$J(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$c(storeKeyMap, luvio, response);
 }
-function ingestSuccess$z(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$A(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$L(luvio, resourceParams);
     luvio.storeIngest(key, ingest$c, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$N(),
+        node: select$O(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -5130,7 +5130,7 @@ function ingestError$e(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$I(config) {
+function createResourceRequest$J(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -5144,62 +5144,62 @@ function createResourceRequest$I(config) {
     };
 }
-const adapterName$I = 'getContextServiceDefinition';
+const adapterName$J = 'getContextServiceDefinition';
 const getContextServiceDefinition_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('isMappingRequiredExclusively', false, 1 /* QueryParameter */, 1 /* Boolean */),
     generateParamConfigMetadata('mappingIdsOrDevelopersNames', false, 1 /* QueryParameter */, 0 /* String */, true),
 ];
-const getContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$I, getContextServiceDefinition_ConfigPropertyMetadata);
-const createResourceParams$I = /*#__PURE__*/ createResourceParams$Q(getContextServiceDefinition_ConfigPropertyMetadata);
+const getContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$J, getContextServiceDefinition_ConfigPropertyMetadata);
+const createResourceParams$J = /*#__PURE__*/ createResourceParams$R(getContextServiceDefinition_ConfigPropertyMetadata);
 function keyBuilder$K(luvio, config) {
-    const resourceParams = createResourceParams$I(config);
+    const resourceParams = createResourceParams$J(config);
     return keyBuilder$L(luvio, resourceParams);
 }
-function typeCheckConfig$I(untrustedConfig) {
+function typeCheckConfig$J(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextServiceDefinition_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextServiceDefinition_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 adapterFragment$e(luvio, config) {
-    createResourceParams$I(config);
-    return select$N();
+    createResourceParams$J(config);
+    return select$O();
 }
 function onFetchResponseSuccess$e(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$z(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$A(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$I(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$J(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$e(luvio, config, resourceParams, response) {
     const snapshot = ingestError$e(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$I(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$J(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-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((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$e(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$I(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$J(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -5207,7 +5207,7 @@ function buildNetworkSnapshot$I(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$e(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$I, undefined, false);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$J, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
     const { luvio, config } = context;
@@ -5218,12 +5218,12 @@ function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$I(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$J(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getContextServiceDefinitionAdapterFactory = (luvio) => function IndustriesContext__getContextServiceDefinition(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$I(untrustedConfig, getContextServiceDefinition_ConfigPropertyNames);
+    const config = validateAdapterConfig$J(untrustedConfig, getContextServiceDefinition_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -5232,19 +5232,19 @@ const getContextServiceDefinitionAdapterFactory = (luvio) => function Industries
     buildCachedSnapshotCachePolicy$e, buildNetworkSnapshotCachePolicy$e);
 };
-function select$M(luvio, params) {
-    return select$12();
+function select$N(luvio, params) {
+    return select$13();
 }
-function getResponseCacheKeys$H(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$I(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$n(storeKeyMap, luvio, response);
 }
-function ingestSuccess$y(luvio, resourceParams, response) {
+function ingestSuccess$z(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$M(),
+        node: select$N(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -5255,7 +5255,7 @@ function ingestSuccess$y(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$H(config) {
+function createResourceRequest$I(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -5269,47 +5269,47 @@ function createResourceRequest$H(config) {
     };
 }
-const adapterName$H = 'updateContextServiceDefinition';
+const adapterName$I = 'updateContextServiceDefinition';
 const updateContextServiceDefinition_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextDefinitionInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const updateContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$H, updateContextServiceDefinition_ConfigPropertyMetadata);
-const createResourceParams$H = /*#__PURE__*/ createResourceParams$Q(updateContextServiceDefinition_ConfigPropertyMetadata);
-function typeCheckConfig$H(untrustedConfig) {
+const updateContextServiceDefinition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$I, updateContextServiceDefinition_ConfigPropertyMetadata);
+const createResourceParams$I = /*#__PURE__*/ createResourceParams$R(updateContextServiceDefinition_ConfigPropertyMetadata);
+function typeCheckConfig$I(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, updateContextServiceDefinition_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, updateContextServiceDefinition_ConfigPropertyMetadata);
     const untrustedConfig_contextDefinitionInput = untrustedConfig.contextDefinitionInput;
-    const referenceContextDefinitionsInputRepresentationValidationError = validate$C(untrustedConfig_contextDefinitionInput);
+    const referenceContextDefinitionsInputRepresentationValidationError = validate$E(untrustedConfig_contextDefinitionInput);
     if (referenceContextDefinitionsInputRepresentationValidationError === null) {
         config.contextDefinitionInput = untrustedConfig_contextDefinitionInput;
     }
     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((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$H(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$I(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -5319,16 +5319,16 @@ function buildNetworkSnapshot$H(luvio, config, options) {
 }
 const updateContextServiceDefinitionAdapterFactory = (luvio) => {
     return function updateContextServiceDefinition(untrustedConfig) {
-        const config = validateAdapterConfig$H(untrustedConfig, updateContextServiceDefinition_ConfigPropertyNames);
+        const config = validateAdapterConfig$I(untrustedConfig, updateContextServiceDefinition_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "updateContextServiceDefinition"');
         }
-        return buildNetworkSnapshot$H(luvio, config);
+        return buildNetworkSnapshot$I(luvio, config);
     };
 };
-function validate$o(obj, path = 'ContextMappingListInputRepresentation') {
+function validate$q(obj, path = 'ContextMappingListInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5365,7 +5365,7 @@ function validate$o(obj, path = 'ContextMappingListInputRepresentation') {
 const TTL$9 = 1000;
 const VERSION$d = "d7c8141e7fbfa6da28615ba495c4b07e";
-function validate$n(obj, path = 'ContextMappingListRepresentation') {
+function validate$p(obj, path = 'ContextMappingListRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5430,7 +5430,7 @@ function normalize$b(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$L = function ContextMappingListRepresentationSelect() {
+const select$M = function ContextMappingListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$d,
@@ -5445,7 +5445,7 @@ const select$L = function ContextMappingListRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$T()
+                fragment: select$U()
             },
             {
                 name: 'isSuccess',
@@ -5496,7 +5496,7 @@ function equals$d(existing, incoming) {
 }
 const ingest$b = function ContextMappingListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$n(input);
+        const validateError = validate$p(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -5522,19 +5522,19 @@ function getTypeCacheKeys$b(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$K(luvio, params) {
-    return select$L();
+function select$L(luvio, params) {
+    return select$M();
 }
-function getResponseCacheKeys$G(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$H(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$b(storeKeyMap, luvio, response);
 }
-function ingestSuccess$x(luvio, resourceParams, response) {
+function ingestSuccess$y(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$8(luvio, body);
     luvio.storeIngest(key, ingest$b, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$K(),
+        node: select$L(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -5545,7 +5545,7 @@ function ingestSuccess$x(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$G(config) {
+function createResourceRequest$H(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -5559,47 +5559,47 @@ function createResourceRequest$G(config) {
     };
 }
-const adapterName$G = 'updateContextMappings';
+const adapterName$H = 'updateContextMappings';
 const updateContextMappings_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const updateContextMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$G, updateContextMappings_ConfigPropertyMetadata);
-const createResourceParams$G = /*#__PURE__*/ createResourceParams$Q(updateContextMappings_ConfigPropertyMetadata);
-function typeCheckConfig$G(untrustedConfig) {
+const updateContextMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$H, updateContextMappings_ConfigPropertyMetadata);
+const createResourceParams$H = /*#__PURE__*/ createResourceParams$R(updateContextMappings_ConfigPropertyMetadata);
+function typeCheckConfig$H(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, updateContextMappings_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, updateContextMappings_ConfigPropertyMetadata);
     const untrustedConfig_contextMappingInput = untrustedConfig.contextMappingInput;
-    const referenceContextMappingListInputRepresentationValidationError = validate$o(untrustedConfig_contextMappingInput);
+    const referenceContextMappingListInputRepresentationValidationError = validate$q(untrustedConfig_contextMappingInput);
     if (referenceContextMappingListInputRepresentationValidationError === null) {
         config.contextMappingInput = untrustedConfig_contextMappingInput;
     }
     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((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$x(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$y(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$G(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$H(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -5609,28 +5609,28 @@ function buildNetworkSnapshot$G(luvio, config, options) {
 }
 const updateContextMappingsAdapterFactory = (luvio) => {
     return function updateContextMappings(untrustedConfig) {
-        const config = validateAdapterConfig$G(untrustedConfig, updateContextMappings_ConfigPropertyNames);
+        const config = validateAdapterConfig$H(untrustedConfig, updateContextMappings_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "updateContextMappings"');
         }
-        return buildNetworkSnapshot$G(luvio, config);
+        return buildNetworkSnapshot$H(luvio, config);
     };
 };
-function select$J(luvio, params) {
-    return select$L();
+function select$K(luvio, params) {
+    return select$M();
 }
-function getResponseCacheKeys$F(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$G(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$b(storeKeyMap, luvio, response);
 }
-function ingestSuccess$w(luvio, resourceParams, response) {
+function ingestSuccess$x(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$8(luvio, body);
     luvio.storeIngest(key, ingest$b, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$J(),
+        node: select$K(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -5641,7 +5641,7 @@ function ingestSuccess$w(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$F(config) {
+function createResourceRequest$G(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -5655,47 +5655,47 @@ function createResourceRequest$F(config) {
     };
 }
-const adapterName$F = 'createContextMappings';
+const adapterName$G = 'createContextMappings';
 const createContextMappings_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$F, createContextMappings_ConfigPropertyMetadata);
-const createResourceParams$F = /*#__PURE__*/ createResourceParams$Q(createContextMappings_ConfigPropertyMetadata);
-function typeCheckConfig$F(untrustedConfig) {
+const createContextMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$G, createContextMappings_ConfigPropertyMetadata);
+const createResourceParams$G = /*#__PURE__*/ createResourceParams$R(createContextMappings_ConfigPropertyMetadata);
+function typeCheckConfig$G(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, createContextMappings_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, createContextMappings_ConfigPropertyMetadata);
     const untrustedConfig_contextMappingInput = untrustedConfig.contextMappingInput;
-    const referenceContextMappingListInputRepresentationValidationError = validate$o(untrustedConfig_contextMappingInput);
+    const referenceContextMappingListInputRepresentationValidationError = validate$q(untrustedConfig_contextMappingInput);
     if (referenceContextMappingListInputRepresentationValidationError === null) {
         config.contextMappingInput = untrustedConfig_contextMappingInput;
     }
     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((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$w(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$x(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$F(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$G(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -5705,12 +5705,12 @@ function buildNetworkSnapshot$F(luvio, config, options) {
 }
 const createContextMappingsAdapterFactory = (luvio) => {
     return function createContextMappings(untrustedConfig) {
-        const config = validateAdapterConfig$F(untrustedConfig, createContextMappings_ConfigPropertyNames);
+        const config = validateAdapterConfig$G(untrustedConfig, createContextMappings_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextMappings"');
         }
-        return buildNetworkSnapshot$F(luvio, config);
+        return buildNetworkSnapshot$G(luvio, config);
     };
 };
@@ -5719,7 +5719,7 @@ function keyBuilder$I(luvio, params) {
         id: params.urlParams.contextMappingId
     });
 }
-function getResponseCacheKeys$E(cacheKeyMap, luvio, resourceParams) {
+function getResponseCacheKeys$F(cacheKeyMap, luvio, resourceParams) {
     const key = keyBuilder$I(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
@@ -5731,7 +5731,7 @@ function evictSuccess$8(luvio, resourceParams) {
     const key = keyBuilder$I(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$E(config) {
+function createResourceRequest$F(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -5745,34 +5745,34 @@ function createResourceRequest$E(config) {
     };
 }
-const adapterName$E = 'deleteContextServiceMapping';
+const adapterName$F = 'deleteContextServiceMapping';
 const deleteContextServiceMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteContextServiceMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$E, deleteContextServiceMapping_ConfigPropertyMetadata);
-const createResourceParams$E = /*#__PURE__*/ createResourceParams$Q(deleteContextServiceMapping_ConfigPropertyMetadata);
-function typeCheckConfig$E(untrustedConfig) {
+const deleteContextServiceMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$F, deleteContextServiceMapping_ConfigPropertyMetadata);
+const createResourceParams$F = /*#__PURE__*/ createResourceParams$R(deleteContextServiceMapping_ConfigPropertyMetadata);
+function typeCheckConfig$F(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, deleteContextServiceMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, deleteContextServiceMapping_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$E(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$F(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$E(untrustedConfig);
+    const config = typeCheckConfig$F(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$E(luvio, config, options) {
-    const resourceParams = createResourceParams$E(config);
-    const request = createResourceRequest$E(resourceParams);
+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(() => {
@@ -5780,7 +5780,7 @@ function buildNetworkSnapshot$E(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$E(cache, luvio, resourceParams);
+            getResponseCacheKeys$F(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -5790,33 +5790,33 @@ function buildNetworkSnapshot$E(luvio, config, options) {
 }
 const deleteContextServiceMappingAdapterFactory = (luvio) => {
     return function IndustriesContextdeleteContextServiceMapping(untrustedConfig) {
-        const config = validateAdapterConfig$E(untrustedConfig, deleteContextServiceMapping_ConfigPropertyNames);
+        const config = validateAdapterConfig$F(untrustedConfig, deleteContextServiceMapping_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$E}"`);
+            throw new Error(`Invalid config for "${adapterName$F}"`);
         }
-        return buildNetworkSnapshot$E(luvio, config);
+        return buildNetworkSnapshot$F(luvio, config);
     };
 };
-function select$I(luvio, params) {
-    return select$T();
+function select$J(luvio, params) {
+    return select$U();
 }
 function keyBuilder$H(luvio, params) {
     return keyBuilder$S(luvio, {
         id: params.urlParams.contextMappingId
     });
 }
-function getResponseCacheKeys$D(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$E(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$h(storeKeyMap, luvio, response);
 }
-function ingestSuccess$v(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$w(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$H(luvio, resourceParams);
     luvio.storeIngest(key, ingest$h, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$I(),
+        node: select$J(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -5839,7 +5839,7 @@ function ingestError$d(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$D(config) {
+function createResourceRequest$E(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -5853,61 +5853,61 @@ function createResourceRequest$D(config) {
     };
 }
-const adapterName$D = 'getContextServiceMapping';
+const adapterName$E = 'getContextServiceMapping';
 const getContextServiceMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getContextServiceMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$D, getContextServiceMapping_ConfigPropertyMetadata);
-const createResourceParams$D = /*#__PURE__*/ createResourceParams$Q(getContextServiceMapping_ConfigPropertyMetadata);
+const getContextServiceMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$E, getContextServiceMapping_ConfigPropertyMetadata);
+const createResourceParams$E = /*#__PURE__*/ createResourceParams$R(getContextServiceMapping_ConfigPropertyMetadata);
 function keyBuilder$G(luvio, config) {
-    const resourceParams = createResourceParams$D(config);
+    const resourceParams = createResourceParams$E(config);
     return keyBuilder$H(luvio, resourceParams);
 }
-function typeCheckConfig$D(untrustedConfig) {
+function typeCheckConfig$E(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextServiceMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextServiceMapping_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$D(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$E(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$D(untrustedConfig);
+    const config = typeCheckConfig$E(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$d(luvio, config) {
-    createResourceParams$D(config);
-    return select$I();
+    createResourceParams$E(config);
+    return select$J();
 }
 function onFetchResponseSuccess$d(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$v(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$w(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$D(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$E(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$d(luvio, config, resourceParams, response) {
     const snapshot = ingestError$d(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$D(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$E(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$D(luvio, config, options) {
-    const resourceParams = createResourceParams$D(config);
-    const request = createResourceRequest$D(resourceParams);
+function buildNetworkSnapshot$E(luvio, config, options) {
+    const resourceParams = createResourceParams$E(config);
+    const request = createResourceRequest$E(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$d(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$D(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$E(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -5915,7 +5915,7 @@ function buildNetworkSnapshot$D(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$d(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$D, undefined, false);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$E, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$d(context, storeLookup) {
     const { luvio, config } = context;
@@ -5926,12 +5926,12 @@ function buildCachedSnapshotCachePolicy$d(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$D(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$E(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getContextServiceMappingAdapterFactory = (luvio) => function IndustriesContext__getContextServiceMapping(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$D(untrustedConfig, getContextServiceMapping_ConfigPropertyNames);
+    const config = validateAdapterConfig$E(untrustedConfig, getContextServiceMapping_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -5940,7 +5940,7 @@ const getContextServiceMappingAdapterFactory = (luvio) => function IndustriesCon
     buildCachedSnapshotCachePolicy$d, buildNetworkSnapshotCachePolicy$d);
 };
-function validate$m(obj, path = 'ContextNodeListInputRepresentation') {
+function validate$o(obj, path = 'ContextNodeListInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5965,7 +5965,7 @@ function validate$m(obj, path = 'ContextNodeListInputRepresentation') {
 const TTL$8 = 1000;
 const VERSION$c = "2846b17386c4627d73c9b82f1333605f";
-function validate$l(obj, path = 'ContextNodeListRepresentation') {
+function validate$n(obj, path = 'ContextNodeListRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -6030,7 +6030,7 @@ function normalize$a(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$H = function ContextNodeListRepresentationSelect() {
+const select$I = function ContextNodeListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$c,
@@ -6045,7 +6045,7 @@ const select$H = function ContextNodeListRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$Q()
+                fragment: select$R()
             },
             {
                 name: 'isSuccess',
@@ -6096,7 +6096,7 @@ function equals$c(existing, incoming) {
 }
 const ingest$a = function ContextNodeListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$l(input);
+        const validateError = validate$n(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -6122,19 +6122,19 @@ function getTypeCacheKeys$a(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$G(luvio, params) {
-    return select$H();
+function select$H(luvio, params) {
+    return select$I();
 }
-function getResponseCacheKeys$C(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$D(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$a(storeKeyMap, luvio, response);
 }
-function ingestSuccess$u(luvio, resourceParams, response) {
+function ingestSuccess$v(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$7(luvio, body);
     luvio.storeIngest(key, ingest$a, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$G(),
+        node: select$H(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -6145,7 +6145,7 @@ function ingestSuccess$u(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$C(config) {
+function createResourceRequest$D(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -6159,47 +6159,47 @@ function createResourceRequest$C(config) {
     };
 }
-const adapterName$C = 'updateContextNodes';
+const adapterName$D = 'updateContextNodes';
 const updateContextNodes_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextNodeInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const updateContextNodes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$C, updateContextNodes_ConfigPropertyMetadata);
-const createResourceParams$C = /*#__PURE__*/ createResourceParams$Q(updateContextNodes_ConfigPropertyMetadata);
-function typeCheckConfig$C(untrustedConfig) {
+const updateContextNodes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$D, updateContextNodes_ConfigPropertyMetadata);
+const createResourceParams$D = /*#__PURE__*/ createResourceParams$R(updateContextNodes_ConfigPropertyMetadata);
+function typeCheckConfig$D(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, updateContextNodes_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, updateContextNodes_ConfigPropertyMetadata);
     const untrustedConfig_contextNodeInput = untrustedConfig.contextNodeInput;
-    const referenceContextNodeListInputRepresentationValidationError = validate$m(untrustedConfig_contextNodeInput);
+    const referenceContextNodeListInputRepresentationValidationError = validate$o(untrustedConfig_contextNodeInput);
     if (referenceContextNodeListInputRepresentationValidationError === null) {
         config.contextNodeInput = untrustedConfig_contextNodeInput;
     }
     return config;
 }
-function validateAdapterConfig$C(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$D(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$C(untrustedConfig);
+    const config = typeCheckConfig$D(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$C(luvio, config, options) {
-    const resourceParams = createResourceParams$C(config);
-    const request = createResourceRequest$C(resourceParams);
+function buildNetworkSnapshot$D(luvio, config, options) {
+    const resourceParams = createResourceParams$D(config);
+    const request = createResourceRequest$D(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$u(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$v(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$C(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$D(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -6209,28 +6209,28 @@ function buildNetworkSnapshot$C(luvio, config, options) {
 }
 const updateContextNodesAdapterFactory = (luvio) => {
     return function updateContextNodes(untrustedConfig) {
-        const config = validateAdapterConfig$C(untrustedConfig, updateContextNodes_ConfigPropertyNames);
+        const config = validateAdapterConfig$D(untrustedConfig, updateContextNodes_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "updateContextNodes"');
         }
-        return buildNetworkSnapshot$C(luvio, config);
+        return buildNetworkSnapshot$D(luvio, config);
     };
 };
-function select$F(luvio, params) {
-    return select$H();
+function select$G(luvio, params) {
+    return select$I();
 }
-function getResponseCacheKeys$B(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$C(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$a(storeKeyMap, luvio, response);
 }
-function ingestSuccess$t(luvio, resourceParams, response) {
+function ingestSuccess$u(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$7(luvio, body);
     luvio.storeIngest(key, ingest$a, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$F(),
+        node: select$G(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -6241,7 +6241,7 @@ function ingestSuccess$t(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$B(config) {
+function createResourceRequest$C(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -6255,47 +6255,47 @@ function createResourceRequest$B(config) {
     };
 }
-const adapterName$B = 'createContextNodes';
+const adapterName$C = 'createContextNodes';
 const createContextNodes_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextNodeInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextNodes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$B, createContextNodes_ConfigPropertyMetadata);
-const createResourceParams$B = /*#__PURE__*/ createResourceParams$Q(createContextNodes_ConfigPropertyMetadata);
-function typeCheckConfig$B(untrustedConfig) {
+const createContextNodes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$C, createContextNodes_ConfigPropertyMetadata);
+const createResourceParams$C = /*#__PURE__*/ createResourceParams$R(createContextNodes_ConfigPropertyMetadata);
+function typeCheckConfig$C(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, createContextNodes_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, createContextNodes_ConfigPropertyMetadata);
     const untrustedConfig_contextNodeInput = untrustedConfig.contextNodeInput;
-    const referenceContextNodeListInputRepresentationValidationError = validate$m(untrustedConfig_contextNodeInput);
+    const referenceContextNodeListInputRepresentationValidationError = validate$o(untrustedConfig_contextNodeInput);
     if (referenceContextNodeListInputRepresentationValidationError === null) {
         config.contextNodeInput = untrustedConfig_contextNodeInput;
     }
     return config;
 }
-function validateAdapterConfig$B(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$C(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$B(untrustedConfig);
+    const config = typeCheckConfig$C(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$B(luvio, config, options) {
-    const resourceParams = createResourceParams$B(config);
-    const request = createResourceRequest$B(resourceParams);
+function buildNetworkSnapshot$C(luvio, config, options) {
+    const resourceParams = createResourceParams$C(config);
+    const request = createResourceRequest$C(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$t(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$u(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$B(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$C(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -6305,18 +6305,18 @@ function buildNetworkSnapshot$B(luvio, config, options) {
 }
 const createContextNodesAdapterFactory = (luvio) => {
     return function createContextNodes(untrustedConfig) {
-        const config = validateAdapterConfig$B(untrustedConfig, createContextNodes_ConfigPropertyNames);
+        const config = validateAdapterConfig$C(untrustedConfig, createContextNodes_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextNodes"');
         }
-        return buildNetworkSnapshot$B(luvio, config);
+        return buildNetworkSnapshot$C(luvio, config);
     };
 };
 const TTL$7 = 1000;
 const VERSION$b = "7c2b99efe7855de7c9740011ae3df6c9";
-function validate$k(obj, path = 'ContextTagListRepresentation') {
+function validate$m(obj, path = 'ContextTagListRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -6381,7 +6381,7 @@ function normalize$9(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$E = function ContextTagListRepresentationSelect() {
+const select$F = function ContextTagListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$b,
@@ -6396,7 +6396,7 @@ const select$E = function ContextTagListRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$S()
+                fragment: select$T()
             },
             {
                 name: 'isSuccess',
@@ -6447,7 +6447,7 @@ function equals$b(existing, incoming) {
 }
 const ingest$9 = function ContextTagListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$k(input);
+        const validateError = validate$m(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -6473,24 +6473,24 @@ function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$D(luvio, params) {
-    return select$E();
+function select$E(luvio, params) {
+    return select$F();
 }
 function keyBuilder$D(luvio, params) {
     return keyBuilder$E(luvio, {
         id: params.urlParams.contextDefinitionId
     });
 }
-function getResponseCacheKeys$A(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$B(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$9(storeKeyMap, luvio, response);
 }
-function ingestSuccess$s(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$t(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$D(luvio, resourceParams);
     luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$D(),
+        node: select$E(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -6513,7 +6513,7 @@ function ingestError$c(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$A(config) {
+function createResourceRequest$B(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -6527,60 +6527,60 @@ function createResourceRequest$A(config) {
     };
 }
-const adapterName$A = 'getContextTags';
+const adapterName$B = 'getContextTags';
 const getContextTags_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getContextTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$A, getContextTags_ConfigPropertyMetadata);
-const createResourceParams$A = /*#__PURE__*/ createResourceParams$Q(getContextTags_ConfigPropertyMetadata);
+const getContextTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$B, getContextTags_ConfigPropertyMetadata);
+const createResourceParams$B = /*#__PURE__*/ createResourceParams$R(getContextTags_ConfigPropertyMetadata);
 function keyBuilder$C(luvio, config) {
-    const resourceParams = createResourceParams$A(config);
+    const resourceParams = createResourceParams$B(config);
     return keyBuilder$D(luvio, resourceParams);
 }
-function typeCheckConfig$A(untrustedConfig) {
+function typeCheckConfig$B(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextTags_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextTags_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$A(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$B(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$A(untrustedConfig);
+    const config = typeCheckConfig$B(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$c(luvio, config) {
-    createResourceParams$A(config);
-    return select$D();
+    createResourceParams$B(config);
+    return select$E();
 }
 function onFetchResponseSuccess$c(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$s(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$t(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$c(luvio, config, resourceParams, response) {
     const snapshot = ingestError$c(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$A(luvio, config, options) {
-    const resourceParams = createResourceParams$A(config);
-    const request = createResourceRequest$A(resourceParams);
+function buildNetworkSnapshot$B(luvio, config, options) {
+    const resourceParams = createResourceParams$B(config);
+    const request = createResourceRequest$B(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$c(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$A(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$B(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -6588,7 +6588,7 @@ function buildNetworkSnapshot$A(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$c(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$A, undefined, false);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$B, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$c(context, storeLookup) {
     const { luvio, config } = context;
@@ -6599,12 +6599,12 @@ function buildCachedSnapshotCachePolicy$c(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getContextTagsAdapterFactory = (luvio) => function IndustriesContext__getContextTags(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$A(untrustedConfig, getContextTags_ConfigPropertyNames);
+    const config = validateAdapterConfig$B(untrustedConfig, getContextTags_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -6613,7 +6613,7 @@ const getContextTagsAdapterFactory = (luvio) => function IndustriesContext__getC
     buildCachedSnapshotCachePolicy$c, buildNetworkSnapshotCachePolicy$c);
 };
-function validate$j(obj, path = 'ContextTagListInputRepresentation') {
+function validate$l(obj, path = 'ContextTagListInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -6634,19 +6634,19 @@ function validate$j(obj, path = 'ContextTagListInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
-function select$C(luvio, params) {
-    return select$E();
+function select$D(luvio, params) {
+    return select$F();
 }
-function getResponseCacheKeys$z(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$A(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$9(storeKeyMap, luvio, response);
 }
-function ingestSuccess$r(luvio, resourceParams, response) {
+function ingestSuccess$s(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$6(luvio, body);
     luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$C(),
+        node: select$D(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -6657,7 +6657,7 @@ function ingestSuccess$r(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$z(config) {
+function createResourceRequest$A(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -6671,47 +6671,47 @@ function createResourceRequest$z(config) {
     };
 }
-const adapterName$z = 'updateContextTags';
+const adapterName$A = 'updateContextTags';
 const updateContextTags_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextTagInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const updateContextTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$z, updateContextTags_ConfigPropertyMetadata);
-const createResourceParams$z = /*#__PURE__*/ createResourceParams$Q(updateContextTags_ConfigPropertyMetadata);
-function typeCheckConfig$z(untrustedConfig) {
+const updateContextTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$A, updateContextTags_ConfigPropertyMetadata);
+const createResourceParams$A = /*#__PURE__*/ createResourceParams$R(updateContextTags_ConfigPropertyMetadata);
+function typeCheckConfig$A(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, updateContextTags_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, updateContextTags_ConfigPropertyMetadata);
     const untrustedConfig_contextTagInput = untrustedConfig.contextTagInput;
-    const referenceContextTagListInputRepresentationValidationError = validate$j(untrustedConfig_contextTagInput);
+    const referenceContextTagListInputRepresentationValidationError = validate$l(untrustedConfig_contextTagInput);
     if (referenceContextTagListInputRepresentationValidationError === null) {
         config.contextTagInput = untrustedConfig_contextTagInput;
     }
     return config;
 }
-function validateAdapterConfig$z(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$A(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$z(untrustedConfig);
+    const config = typeCheckConfig$A(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$A(luvio, config, options) {
+    const resourceParams = createResourceParams$A(config);
+    const request = createResourceRequest$A(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$r(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$s(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$z(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$A(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -6721,28 +6721,28 @@ function buildNetworkSnapshot$z(luvio, config, options) {
 }
 const updateContextTagsAdapterFactory = (luvio) => {
     return function updateContextTags(untrustedConfig) {
-        const config = validateAdapterConfig$z(untrustedConfig, updateContextTags_ConfigPropertyNames);
+        const config = validateAdapterConfig$A(untrustedConfig, updateContextTags_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "updateContextTags"');
         }
-        return buildNetworkSnapshot$z(luvio, config);
+        return buildNetworkSnapshot$A(luvio, config);
     };
 };
-function select$B(luvio, params) {
-    return select$E();
+function select$C(luvio, params) {
+    return select$F();
 }
-function getResponseCacheKeys$y(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$z(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$9(storeKeyMap, luvio, response);
 }
-function ingestSuccess$q(luvio, resourceParams, response) {
+function ingestSuccess$r(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$6(luvio, body);
     luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$B(),
+        node: select$C(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -6753,7 +6753,7 @@ function ingestSuccess$q(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$y(config) {
+function createResourceRequest$z(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -6767,47 +6767,47 @@ function createResourceRequest$y(config) {
     };
 }
-const adapterName$y = 'createContextTags';
+const adapterName$z = 'createContextTags';
 const createContextTags_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextTagInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createContextTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$y, createContextTags_ConfigPropertyMetadata);
-const createResourceParams$y = /*#__PURE__*/ createResourceParams$Q(createContextTags_ConfigPropertyMetadata);
-function typeCheckConfig$y(untrustedConfig) {
+const createContextTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$z, createContextTags_ConfigPropertyMetadata);
+const createResourceParams$z = /*#__PURE__*/ createResourceParams$R(createContextTags_ConfigPropertyMetadata);
+function typeCheckConfig$z(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, createContextTags_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, createContextTags_ConfigPropertyMetadata);
     const untrustedConfig_contextTagInput = untrustedConfig.contextTagInput;
-    const referenceContextTagListInputRepresentationValidationError = validate$j(untrustedConfig_contextTagInput);
+    const referenceContextTagListInputRepresentationValidationError = validate$l(untrustedConfig_contextTagInput);
     if (referenceContextTagListInputRepresentationValidationError === null) {
         config.contextTagInput = untrustedConfig_contextTagInput;
     }
     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$q(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$r(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) => {
@@ -6817,12 +6817,12 @@ function buildNetworkSnapshot$y(luvio, config, options) {
 }
 const createContextTagsAdapterFactory = (luvio) => {
     return function createContextTags(untrustedConfig) {
-        const config = validateAdapterConfig$y(untrustedConfig, createContextTags_ConfigPropertyNames);
+        const config = validateAdapterConfig$z(untrustedConfig, createContextTags_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContextTags"');
         }
-        return buildNetworkSnapshot$y(luvio, config);
+        return buildNetworkSnapshot$z(luvio, config);
     };
 };
@@ -6831,7 +6831,7 @@ function keyBuilder$B(luvio, params) {
         id: params.urlParams.contextNodeId
     });
 }
-function getResponseCacheKeys$x(cacheKeyMap, luvio, resourceParams) {
+function getResponseCacheKeys$y(cacheKeyMap, luvio, resourceParams) {
     const key = keyBuilder$B(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
@@ -6843,7 +6843,7 @@ function evictSuccess$7(luvio, resourceParams) {
     const key = keyBuilder$B(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$x(config) {
+function createResourceRequest$y(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -6857,34 +6857,34 @@ function createResourceRequest$x(config) {
     };
 }
-const adapterName$x = 'deleteContextServiceNode';
+const adapterName$y = 'deleteContextServiceNode';
 const deleteContextServiceNode_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextNodeId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteContextServiceNode_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$x, deleteContextServiceNode_ConfigPropertyMetadata);
-const createResourceParams$x = /*#__PURE__*/ createResourceParams$Q(deleteContextServiceNode_ConfigPropertyMetadata);
-function typeCheckConfig$x(untrustedConfig) {
+const deleteContextServiceNode_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$y, deleteContextServiceNode_ConfigPropertyMetadata);
+const createResourceParams$y = /*#__PURE__*/ createResourceParams$R(deleteContextServiceNode_ConfigPropertyMetadata);
+function typeCheckConfig$y(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, deleteContextServiceNode_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, deleteContextServiceNode_ConfigPropertyMetadata);
     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(() => {
         return luvio.handleSuccessResponse(() => {
@@ -6892,7 +6892,7 @@ function buildNetworkSnapshot$x(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$x(cache, luvio, resourceParams);
+            getResponseCacheKeys$y(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -6902,33 +6902,33 @@ function buildNetworkSnapshot$x(luvio, config, options) {
 }
 const deleteContextServiceNodeAdapterFactory = (luvio) => {
     return function IndustriesContextdeleteContextServiceNode(untrustedConfig) {
-        const config = validateAdapterConfig$x(untrustedConfig, deleteContextServiceNode_ConfigPropertyNames);
+        const config = validateAdapterConfig$y(untrustedConfig, deleteContextServiceNode_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$x}"`);
+            throw new Error(`Invalid config for "${adapterName$y}"`);
         }
-        return buildNetworkSnapshot$x(luvio, config);
+        return buildNetworkSnapshot$y(luvio, config);
     };
 };
-function select$A(luvio, params) {
-    return select$Q();
+function select$B(luvio, params) {
+    return select$R();
 }
 function keyBuilder$A(luvio, params) {
     return keyBuilder$P(luvio, {
         id: params.urlParams.contextNodeId
     });
 }
-function getResponseCacheKeys$w(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$x(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$e(storeKeyMap, luvio, response);
 }
-function ingestSuccess$p(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$q(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$A(luvio, resourceParams);
     luvio.storeIngest(key, ingest$e, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$A(),
+        node: select$B(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -6951,7 +6951,7 @@ function ingestError$b(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$w(config) {
+function createResourceRequest$x(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -6965,61 +6965,61 @@ function createResourceRequest$w(config) {
     };
 }
-const adapterName$w = 'getContextServiceNode';
+const adapterName$x = 'getContextServiceNode';
 const getContextServiceNode_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextNodeId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getContextServiceNode_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$w, getContextServiceNode_ConfigPropertyMetadata);
-const createResourceParams$w = /*#__PURE__*/ createResourceParams$Q(getContextServiceNode_ConfigPropertyMetadata);
+const getContextServiceNode_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$x, getContextServiceNode_ConfigPropertyMetadata);
+const createResourceParams$x = /*#__PURE__*/ createResourceParams$R(getContextServiceNode_ConfigPropertyMetadata);
 function keyBuilder$z(luvio, config) {
-    const resourceParams = createResourceParams$w(config);
+    const resourceParams = createResourceParams$x(config);
     return keyBuilder$A(luvio, resourceParams);
 }
-function typeCheckConfig$w(untrustedConfig) {
+function typeCheckConfig$x(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextServiceNode_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextServiceNode_ConfigPropertyMetadata);
     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 adapterFragment$b(luvio, config) {
-    createResourceParams$w(config);
-    return select$A();
+    createResourceParams$x(config);
+    return select$B();
 }
 function onFetchResponseSuccess$b(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$p(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$q(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$b(luvio, config, resourceParams, response) {
     const snapshot = ingestError$b(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-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(() => onFetchResponseSuccess$b(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$w(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$x(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -7027,7 +7027,7 @@ function buildNetworkSnapshot$w(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$b(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$w, undefined, false);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$x, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$b(context, storeLookup) {
     const { luvio, config } = context;
@@ -7038,12 +7038,12 @@ function buildCachedSnapshotCachePolicy$b(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getContextServiceNodeAdapterFactory = (luvio) => function IndustriesContext__getContextServiceNode(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$w(untrustedConfig, getContextServiceNode_ConfigPropertyNames);
+    const config = validateAdapterConfig$x(untrustedConfig, getContextServiceNode_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -7057,7 +7057,7 @@ function keyBuilder$y(luvio, params) {
         id: params.urlParams.contextTagId
     });
 }
-function getResponseCacheKeys$v(cacheKeyMap, luvio, resourceParams) {
+function getResponseCacheKeys$w(cacheKeyMap, luvio, resourceParams) {
     const key = keyBuilder$y(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
@@ -7069,7 +7069,7 @@ function evictSuccess$6(luvio, resourceParams) {
     const key = keyBuilder$y(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$v(config) {
+function createResourceRequest$w(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -7083,34 +7083,34 @@ function createResourceRequest$v(config) {
     };
 }
-const adapterName$v = 'deleteContextServiceTag';
+const adapterName$w = 'deleteContextServiceTag';
 const deleteContextServiceTag_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextTagId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteContextServiceTag_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$v, deleteContextServiceTag_ConfigPropertyMetadata);
-const createResourceParams$v = /*#__PURE__*/ createResourceParams$Q(deleteContextServiceTag_ConfigPropertyMetadata);
-function typeCheckConfig$v(untrustedConfig) {
+const deleteContextServiceTag_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$w, deleteContextServiceTag_ConfigPropertyMetadata);
+const createResourceParams$w = /*#__PURE__*/ createResourceParams$R(deleteContextServiceTag_ConfigPropertyMetadata);
+function typeCheckConfig$w(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, deleteContextServiceTag_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, deleteContextServiceTag_ConfigPropertyMetadata);
     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(() => {
         return luvio.handleSuccessResponse(() => {
@@ -7118,7 +7118,7 @@ function buildNetworkSnapshot$v(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$v(cache, luvio, resourceParams);
+            getResponseCacheKeys$w(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -7128,33 +7128,33 @@ function buildNetworkSnapshot$v(luvio, config, options) {
 }
 const deleteContextServiceTagAdapterFactory = (luvio) => {
     return function IndustriesContextdeleteContextServiceTag(untrustedConfig) {
-        const config = validateAdapterConfig$v(untrustedConfig, deleteContextServiceTag_ConfigPropertyNames);
+        const config = validateAdapterConfig$w(untrustedConfig, deleteContextServiceTag_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$v}"`);
+            throw new Error(`Invalid config for "${adapterName$w}"`);
         }
-        return buildNetworkSnapshot$v(luvio, config);
+        return buildNetworkSnapshot$w(luvio, config);
     };
 };
-function select$z(luvio, params) {
-    return select$S();
+function select$A(luvio, params) {
+    return select$T();
 }
 function keyBuilder$x(luvio, params) {
     return keyBuilder$R(luvio, {
         id: params.urlParams.contextTagId
     });
 }
-function getResponseCacheKeys$u(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$v(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$g(storeKeyMap, luvio, response);
 }
-function ingestSuccess$o(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$p(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$x(luvio, resourceParams);
     luvio.storeIngest(key, ingest$g, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$z(),
+        node: select$A(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -7177,7 +7177,7 @@ function ingestError$a(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$u(config) {
+function createResourceRequest$v(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -7191,61 +7191,61 @@ function createResourceRequest$u(config) {
     };
 }
-const adapterName$u = 'getContextServiceTag';
+const adapterName$v = 'getContextServiceTag';
 const getContextServiceTag_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contextTagId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getContextServiceTag_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$u, getContextServiceTag_ConfigPropertyMetadata);
-const createResourceParams$u = /*#__PURE__*/ createResourceParams$Q(getContextServiceTag_ConfigPropertyMetadata);
+const getContextServiceTag_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$v, getContextServiceTag_ConfigPropertyMetadata);
+const createResourceParams$v = /*#__PURE__*/ createResourceParams$R(getContextServiceTag_ConfigPropertyMetadata);
 function keyBuilder$w(luvio, config) {
-    const resourceParams = createResourceParams$u(config);
+    const resourceParams = createResourceParams$v(config);
     return keyBuilder$x(luvio, resourceParams);
 }
-function typeCheckConfig$u(untrustedConfig) {
+function typeCheckConfig$v(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextServiceTag_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextServiceTag_ConfigPropertyMetadata);
     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 adapterFragment$a(luvio, config) {
-    createResourceParams$u(config);
-    return select$z();
+    createResourceParams$v(config);
+    return select$A();
 }
 function onFetchResponseSuccess$a(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$o(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$p(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$a(luvio, config, resourceParams, response) {
     const snapshot = ingestError$a(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-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(() => onFetchResponseSuccess$a(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$u(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$v(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -7253,7 +7253,7 @@ function buildNetworkSnapshot$u(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$u, undefined, false);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$v, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     const { luvio, config } = context;
@@ -7264,12 +7264,12 @@ function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getContextServiceTagAdapterFactory = (luvio) => function IndustriesContext__getContextServiceTag(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$u(untrustedConfig, getContextServiceTag_ConfigPropertyNames);
+    const config = validateAdapterConfig$v(untrustedConfig, getContextServiceTag_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -7279,7 +7279,7 @@ const getContextServiceTagAdapterFactory = (luvio) => function IndustriesContext
 };
 const VERSION$a = "6b02738fb793fef48f1ebf9412aba59c";
-function validate$i(obj, path = 'DynamicAttributeByNodeSearchResultRepresentation') {
+function validate$k(obj, path = 'DynamicAttributeByNodeSearchResultRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -7324,7 +7324,7 @@ function normalize$8(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$y = function DynamicAttributeByNodeSearchResultRepresentationSelect() {
+const select$z = function DynamicAttributeByNodeSearchResultRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$a,
@@ -7334,7 +7334,7 @@ const select$y = function DynamicAttributeByNodeSearchResultRepresentationSelect
                 name: 'dynamicContextAttributes',
                 kind: 'Link',
                 plural: true,
-                fragment: select$R()
+                fragment: select$S()
             },
             {
                 name: 'nodeName',
@@ -7363,7 +7363,7 @@ function equals$a(existing, incoming) {
 }
 const ingest$8 = function DynamicAttributeByNodeSearchResultRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$i(input);
+        const validateError = validate$k(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -7388,7 +7388,7 @@ function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
 }
 const VERSION$9 = "f481df563d73ee379020a8f181180b5b";
-function validate$h(obj, path = 'DynamicAttributeByMappingSearchResultRepresentation') {
+function validate$j(obj, path = 'DynamicAttributeByMappingSearchResultRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -7433,7 +7433,7 @@ function normalize$7(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$x = function DynamicAttributeByMappingSearchResultRepresentationSelect() {
+const select$y = function DynamicAttributeByMappingSearchResultRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$9,
@@ -7443,7 +7443,7 @@ const select$x = function DynamicAttributeByMappingSearchResultRepresentationSel
                 name: 'dynamicAttributeByNodeSearchResults',
                 kind: 'Link',
                 plural: true,
-                fragment: select$y()
+                fragment: select$z()
             },
             {
                 name: 'mappingIdOrName',
@@ -7472,7 +7472,7 @@ function equals$9(existing, incoming) {
 }
 const ingest$7 = function DynamicAttributeByMappingSearchResultRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$h(input);
+        const validateError = validate$j(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -7498,7 +7498,7 @@ function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
 const TTL$6 = 100;
 const VERSION$8 = "e51ab88fcee2a0fe63212268fc4ce730";
-function validate$g(obj, path = 'DynamicAttributeSearchResultRepresentation') {
+function validate$i(obj, path = 'DynamicAttributeSearchResultRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -7562,7 +7562,7 @@ function normalize$6(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$w = function DynamicAttributeSearchResultRepresentationSelect() {
+const select$x = function DynamicAttributeSearchResultRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$8,
@@ -7572,7 +7572,7 @@ const select$w = function DynamicAttributeSearchResultRepresentationSelect() {
                 name: 'dynAttributeByMappingSearchResults',
                 kind: 'Link',
                 plural: true,
-                fragment: select$x()
+                fragment: select$y()
             },
             {
                 name: 'dynamicAttributeSearchResultId',
@@ -7619,7 +7619,7 @@ function equals$8(existing, incoming) {
 }
 const ingest$6 = function DynamicAttributeSearchResultRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$g(input);
+        const validateError = validate$i(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -7643,24 +7643,24 @@ function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$v(luvio, params) {
-    return select$w();
+function select$w(luvio, params) {
+    return select$x();
 }
 function keyBuilder$u(luvio, params) {
     return keyBuilder$v(luvio, {
         id: params.urlParams.contextDefinitionId
     });
 }
-function getResponseCacheKeys$t(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$u(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$6(storeKeyMap, luvio, response);
 }
-function ingestSuccess$n(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$o(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$u(luvio, resourceParams);
     luvio.storeIngest(key, ingest$6, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$v(),
+        node: select$w(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -7683,7 +7683,7 @@ function ingestError$9(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$t(config) {
+function createResourceRequest$u(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -7697,7 +7697,7 @@ function createResourceRequest$t(config) {
     };
 }
-const adapterName$t = 'getDynamicAttributes';
+const adapterName$u = 'getDynamicAttributes';
 const getDynamicAttributes_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextDefinitionId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('keyword', false, 1 /* QueryParameter */, 0 /* String */),
@@ -7705,56 +7705,56 @@ const getDynamicAttributes_ConfigPropertyMetadata = [
     generateParamConfigMetadata('mappingIdOrName', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('nodeName', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getDynamicAttributes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$t, getDynamicAttributes_ConfigPropertyMetadata);
-const createResourceParams$t = /*#__PURE__*/ createResourceParams$Q(getDynamicAttributes_ConfigPropertyMetadata);
+const getDynamicAttributes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$u, getDynamicAttributes_ConfigPropertyMetadata);
+const createResourceParams$u = /*#__PURE__*/ createResourceParams$R(getDynamicAttributes_ConfigPropertyMetadata);
 function keyBuilder$t(luvio, config) {
-    const resourceParams = createResourceParams$t(config);
+    const resourceParams = createResourceParams$u(config);
     return keyBuilder$u(luvio, resourceParams);
 }
-function typeCheckConfig$t(untrustedConfig) {
+function typeCheckConfig$u(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getDynamicAttributes_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getDynamicAttributes_ConfigPropertyMetadata);
     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 adapterFragment$9(luvio, config) {
-    createResourceParams$t(config);
-    return select$v();
+    createResourceParams$u(config);
+    return select$w();
 }
 function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$n(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$o(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$t(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$9(luvio, config, resourceParams, response) {
     const snapshot = ingestError$9(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$t(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-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(() => onFetchResponseSuccess$9(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$t(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$u(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -7762,7 +7762,7 @@ function buildNetworkSnapshot$t(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$t, undefined, false);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$u, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
     const { luvio, config } = context;
@@ -7773,12 +7773,12 @@ function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$t(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getDynamicAttributesAdapterFactory = (luvio) => function IndustriesContext__getDynamicAttributes(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$t(untrustedConfig, getDynamicAttributes_ConfigPropertyNames);
+    const config = validateAdapterConfig$u(untrustedConfig, getDynamicAttributes_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -7787,6 +7787,143 @@ const getDynamicAttributesAdapterFactory = (luvio) => function IndustriesContext
     buildCachedSnapshotCachePolicy$9, buildNetworkSnapshotCachePolicy$9);
 };
+function validate$h(obj, path = 'ContextMappingCloneInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contextMappingName = obj.contextMappingName;
+        const path_contextMappingName = path + '.contextMappingName';
+        if (typeof obj_contextMappingName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextMappingName + '" (at "' + path_contextMappingName + '")');
+        }
+        const obj_originalContextMappingId = obj.originalContextMappingId;
+        const path_originalContextMappingId = path + '.originalContextMappingId';
+        if (typeof obj_originalContextMappingId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_originalContextMappingId + '" (at "' + path_originalContextMappingId + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+function validate$g(obj, path = 'ContextMappingCloneListInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contextMappingClones = obj.contextMappingClones;
+        const path_contextMappingClones = path + '.contextMappingClones';
+        if (!ArrayIsArray(obj_contextMappingClones)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_contextMappingClones + '" (at "' + path_contextMappingClones + '")');
+        }
+        for (let i = 0; i < obj_contextMappingClones.length; i++) {
+            const obj_contextMappingClones_item = obj_contextMappingClones[i];
+            const path_contextMappingClones_item = path_contextMappingClones + '[' + i + ']';
+            const referencepath_contextMappingClones_itemValidationError = validate$h(obj_contextMappingClones_item, path_contextMappingClones_item);
+            if (referencepath_contextMappingClones_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ContextMappingCloneInputRepresentation (at "' + path_contextMappingClones_item + '")\n';
+                message += referencepath_contextMappingClones_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+function select$v(luvio, params) {
+    return select$M();
+}
+function getResponseCacheKeys$t(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$b(storeKeyMap, luvio, response);
+}
+function ingestSuccess$n(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$8(luvio, body);
+    luvio.storeIngest(key, ingest$b, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$v(),
+        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$t(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v63.0',
+        basePath: '/connect/context-mappings/clone',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+const adapterName$t = 'cloneContextMappings';
+const cloneContextMappings_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contextMappingCloneInput', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const cloneContextMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$t, cloneContextMappings_ConfigPropertyMetadata);
+const createResourceParams$t = /*#__PURE__*/ createResourceParams$R(cloneContextMappings_ConfigPropertyMetadata);
+function typeCheckConfig$t(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextMappingCloneInput = untrustedConfig.contextMappingCloneInput;
+    const referenceContextMappingCloneListInputRepresentationValidationError = validate$g(untrustedConfig_contextMappingCloneInput);
+    if (referenceContextMappingCloneListInputRepresentationValidationError === null) {
+        config.contextMappingCloneInput = untrustedConfig_contextMappingCloneInput;
+    }
+    return config;
+}
+function validateAdapterConfig$t(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$t(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);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$n(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$t(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const cloneContextMappingsAdapterFactory = (luvio) => {
+    return function cloneContextMappings(untrustedConfig) {
+        const config = validateAdapterConfig$t(untrustedConfig, cloneContextMappings_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "cloneContextMappings"');
+        }
+        return buildNetworkSnapshot$t(luvio, config);
+    };
+};
 function validate$f(obj, path = 'ContextNodeMappingListInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -7890,7 +8027,7 @@ const select$u = function ContextNodeMappingListRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$U()
+                fragment: select$V()
             },
             {
                 name: 'isSuccess',
@@ -8010,10 +8147,10 @@ const updateContextNodeMappings_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextNodeMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$s, updateContextNodeMappings_ConfigPropertyMetadata);
-const createResourceParams$s = /*#__PURE__*/ createResourceParams$Q(updateContextNodeMappings_ConfigPropertyMetadata);
+const createResourceParams$s = /*#__PURE__*/ createResourceParams$R(updateContextNodeMappings_ConfigPropertyMetadata);
 function typeCheckConfig$s(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, updateContextNodeMappings_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, updateContextNodeMappings_ConfigPropertyMetadata);
     const untrustedConfig_contextNodeMappingInput = untrustedConfig.contextNodeMappingInput;
     const referenceContextNodeMappingListInputRepresentationValidationError = validate$f(untrustedConfig_contextNodeMappingInput);
     if (referenceContextNodeMappingListInputRepresentationValidationError === null) {
@@ -8106,10 +8243,10 @@ const createContextNodeMappings_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createContextNodeMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$r, createContextNodeMappings_ConfigPropertyMetadata);
-const createResourceParams$r = /*#__PURE__*/ createResourceParams$Q(createContextNodeMappings_ConfigPropertyMetadata);
+const createResourceParams$r = /*#__PURE__*/ createResourceParams$R(createContextNodeMappings_ConfigPropertyMetadata);
 function typeCheckConfig$r(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, createContextNodeMappings_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, createContextNodeMappings_ConfigPropertyMetadata);
     const untrustedConfig_contextNodeMappingInput = untrustedConfig.contextNodeMappingInput;
     const referenceContextNodeMappingListInputRepresentationValidationError = validate$f(untrustedConfig_contextNodeMappingInput);
     if (referenceContextNodeMappingListInputRepresentationValidationError === null) {
@@ -8196,10 +8333,10 @@ const deleteContextServiceNodeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteContextServiceNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$q, deleteContextServiceNodeMapping_ConfigPropertyMetadata);
-const createResourceParams$q = /*#__PURE__*/ createResourceParams$Q(deleteContextServiceNodeMapping_ConfigPropertyMetadata);
+const createResourceParams$q = /*#__PURE__*/ createResourceParams$R(deleteContextServiceNodeMapping_ConfigPropertyMetadata);
 function typeCheckConfig$q(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, deleteContextServiceNodeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, deleteContextServiceNodeMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$q(untrustedConfig, configPropertyNames) {
@@ -8245,7 +8382,7 @@ const deleteContextServiceNodeMappingAdapterFactory = (luvio) => {
 };
 function select$r(luvio, params) {
-    return select$U();
+    return select$V();
 }
 function keyBuilder$q(luvio, params) {
     return keyBuilder$T(luvio, {
@@ -8304,14 +8441,14 @@ const getContextServiceNodeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextServiceNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$p, getContextServiceNodeMapping_ConfigPropertyMetadata);
-const createResourceParams$p = /*#__PURE__*/ createResourceParams$Q(getContextServiceNodeMapping_ConfigPropertyMetadata);
+const createResourceParams$p = /*#__PURE__*/ createResourceParams$R(getContextServiceNodeMapping_ConfigPropertyMetadata);
 function keyBuilder$p(luvio, config) {
     const resourceParams = createResourceParams$p(config);
     return keyBuilder$q(luvio, resourceParams);
 }
 function typeCheckConfig$p(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextServiceNodeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextServiceNodeMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$p(untrustedConfig, configPropertyNames) {
@@ -8497,7 +8634,7 @@ const select$q = function ContextAttributeMappingListRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$V()
+                fragment: select$W()
             },
             {
                 name: 'isSuccess',
@@ -8617,10 +8754,10 @@ const updateContextAttributeMappings_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextAttributeMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$o, updateContextAttributeMappings_ConfigPropertyMetadata);
-const createResourceParams$o = /*#__PURE__*/ createResourceParams$Q(updateContextAttributeMappings_ConfigPropertyMetadata);
+const createResourceParams$o = /*#__PURE__*/ createResourceParams$R(updateContextAttributeMappings_ConfigPropertyMetadata);
 function typeCheckConfig$o(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, updateContextAttributeMappings_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, updateContextAttributeMappings_ConfigPropertyMetadata);
     const untrustedConfig_contextAttributeMappingInput = untrustedConfig.contextAttributeMappingInput;
     const referenceContextAttributeMappingListInputRepresentationValidationError = validate$d(untrustedConfig_contextAttributeMappingInput);
     if (referenceContextAttributeMappingListInputRepresentationValidationError === null) {
@@ -8713,10 +8850,10 @@ const createContextAttributeMappings_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createContextAttributeMappings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$n, createContextAttributeMappings_ConfigPropertyMetadata);
-const createResourceParams$n = /*#__PURE__*/ createResourceParams$Q(createContextAttributeMappings_ConfigPropertyMetadata);
+const createResourceParams$n = /*#__PURE__*/ createResourceParams$R(createContextAttributeMappings_ConfigPropertyMetadata);
 function typeCheckConfig$n(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, createContextAttributeMappings_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, createContextAttributeMappings_ConfigPropertyMetadata);
     const untrustedConfig_contextAttributeMappingInput = untrustedConfig.contextAttributeMappingInput;
     const referenceContextAttributeMappingListInputRepresentationValidationError = validate$d(untrustedConfig_contextAttributeMappingInput);
     if (referenceContextAttributeMappingListInputRepresentationValidationError === null) {
@@ -8803,10 +8940,10 @@ const deleteContextServiceAttributeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteContextServiceAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$m, deleteContextServiceAttributeMapping_ConfigPropertyMetadata);
-const createResourceParams$m = /*#__PURE__*/ createResourceParams$Q(deleteContextServiceAttributeMapping_ConfigPropertyMetadata);
+const createResourceParams$m = /*#__PURE__*/ createResourceParams$R(deleteContextServiceAttributeMapping_ConfigPropertyMetadata);
 function typeCheckConfig$m(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, deleteContextServiceAttributeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, deleteContextServiceAttributeMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$m(untrustedConfig, configPropertyNames) {
@@ -8852,7 +8989,7 @@ const deleteContextServiceAttributeMappingAdapterFactory = (luvio) => {
 };
 function select$n(luvio, params) {
-    return select$V();
+    return select$W();
 }
 function keyBuilder$m(luvio, params) {
     return keyBuilder$U(luvio, {
@@ -8911,14 +9048,14 @@ const getContextServiceAttributeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextServiceAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$l, getContextServiceAttributeMapping_ConfigPropertyMetadata);
-const createResourceParams$l = /*#__PURE__*/ createResourceParams$Q(getContextServiceAttributeMapping_ConfigPropertyMetadata);
+const createResourceParams$l = /*#__PURE__*/ createResourceParams$R(getContextServiceAttributeMapping_ConfigPropertyMetadata);
 function keyBuilder$l(luvio, config) {
     const resourceParams = createResourceParams$l(config);
     return keyBuilder$m(luvio, resourceParams);
 }
 function typeCheckConfig$l(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextServiceAttributeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextServiceAttributeMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$l(untrustedConfig, configPropertyNames) {
@@ -9096,7 +9233,7 @@ const select$m = function ContextAttributeListRepresentationSelect() {
                 kind: 'Link',
                 plural: true,
                 required: false,
-                fragment: select$R()
+                fragment: select$S()
             },
             {
                 name: 'contextAttributeListId',
@@ -9229,10 +9366,10 @@ const updateContextAttributes_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeListInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextAttributes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$k, updateContextAttributes_ConfigPropertyMetadata);
-const createResourceParams$k = /*#__PURE__*/ createResourceParams$Q(updateContextAttributes_ConfigPropertyMetadata);
+const createResourceParams$k = /*#__PURE__*/ createResourceParams$R(updateContextAttributes_ConfigPropertyMetadata);
 function typeCheckConfig$k(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, updateContextAttributes_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, updateContextAttributes_ConfigPropertyMetadata);
     const untrustedConfig_contextAttributeListInput = untrustedConfig.contextAttributeListInput;
     const referenceContextAttributesListInputRepresentationValidationError = validate$b(untrustedConfig_contextAttributeListInput);
     if (referenceContextAttributesListInputRepresentationValidationError === null) {
@@ -9325,10 +9462,10 @@ const createContextAttributes_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeListInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createContextAttributes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$j, createContextAttributes_ConfigPropertyMetadata);
-const createResourceParams$j = /*#__PURE__*/ createResourceParams$Q(createContextAttributes_ConfigPropertyMetadata);
+const createResourceParams$j = /*#__PURE__*/ createResourceParams$R(createContextAttributes_ConfigPropertyMetadata);
 function typeCheckConfig$j(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, createContextAttributes_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, createContextAttributes_ConfigPropertyMetadata);
     const untrustedConfig_contextAttributeListInput = untrustedConfig.contextAttributeListInput;
     const referenceContextAttributesListInputRepresentationValidationError = validate$b(untrustedConfig_contextAttributeListInput);
     if (referenceContextAttributesListInputRepresentationValidationError === null) {
@@ -9415,10 +9552,10 @@ const deleteContextServiceAttribute_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteContextServiceAttribute_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$i, deleteContextServiceAttribute_ConfigPropertyMetadata);
-const createResourceParams$i = /*#__PURE__*/ createResourceParams$Q(deleteContextServiceAttribute_ConfigPropertyMetadata);
+const createResourceParams$i = /*#__PURE__*/ createResourceParams$R(deleteContextServiceAttribute_ConfigPropertyMetadata);
 function typeCheckConfig$i(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, deleteContextServiceAttribute_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, deleteContextServiceAttribute_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$i(untrustedConfig, configPropertyNames) {
@@ -9464,7 +9601,7 @@ const deleteContextServiceAttributeAdapterFactory = (luvio) => {
 };
 function select$j(luvio, params) {
-    return select$R();
+    return select$S();
 }
 function keyBuilder$i(luvio, params) {
     return keyBuilder$Q(luvio, {
@@ -9523,14 +9660,14 @@ const getContextServiceAttribute_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextServiceAttribute_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$h, getContextServiceAttribute_ConfigPropertyMetadata);
-const createResourceParams$h = /*#__PURE__*/ createResourceParams$Q(getContextServiceAttribute_ConfigPropertyMetadata);
+const createResourceParams$h = /*#__PURE__*/ createResourceParams$R(getContextServiceAttribute_ConfigPropertyMetadata);
 function keyBuilder$h(luvio, config) {
     const resourceParams = createResourceParams$h(config);
     return keyBuilder$i(luvio, resourceParams);
 }
 function typeCheckConfig$h(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextServiceAttribute_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextServiceAttribute_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$h(untrustedConfig, configPropertyNames) {
@@ -9666,7 +9803,7 @@ function validate$9(obj, path = 'ContextMappingInputRepresentation') {
 }
 function select$i(luvio, params) {
-    return select$T();
+    return select$U();
 }
 function getResponseCacheKeys$g(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$h(storeKeyMap, luvio, response);
@@ -9707,7 +9844,7 @@ const createContextMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createContextMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$g, createContextMapping_ConfigPropertyMetadata);
-const createResourceParams$g = /*#__PURE__*/ createResourceParams$Q(createContextMapping_ConfigPropertyMetadata);
+const createResourceParams$g = /*#__PURE__*/ createResourceParams$R(createContextMapping_ConfigPropertyMetadata);
 function typeCheckConfig$g(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextMappingInput = untrustedConfig.contextMappingInput;
@@ -9809,7 +9946,7 @@ function validate$8(obj, path = 'ContextAttributeMappingInputRepresentation') {
 }
 function select$h(luvio, params) {
-    return select$V();
+    return select$W();
 }
 function getResponseCacheKeys$f(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$j(storeKeyMap, luvio, response);
@@ -9850,7 +9987,7 @@ const createContextAttributeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createContextAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, createContextAttributeMapping_ConfigPropertyMetadata);
-const createResourceParams$f = /*#__PURE__*/ createResourceParams$Q(createContextAttributeMapping_ConfigPropertyMetadata);
+const createResourceParams$f = /*#__PURE__*/ createResourceParams$R(createContextAttributeMapping_ConfigPropertyMetadata);
 function typeCheckConfig$f(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextAttributeMappingInput = untrustedConfig.contextAttributeMappingInput;
@@ -9938,10 +10075,10 @@ const deleteContextAttributeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteContextAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, deleteContextAttributeMapping_ConfigPropertyMetadata);
-const createResourceParams$e = /*#__PURE__*/ createResourceParams$Q(deleteContextAttributeMapping_ConfigPropertyMetadata);
+const createResourceParams$e = /*#__PURE__*/ createResourceParams$R(deleteContextAttributeMapping_ConfigPropertyMetadata);
 function typeCheckConfig$e(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, deleteContextAttributeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, deleteContextAttributeMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
@@ -9987,7 +10124,7 @@ const deleteContextAttributeMappingAdapterFactory = (luvio) => {
 };
 function select$g(luvio, params) {
-    return select$V();
+    return select$W();
 }
 function keyBuilder$f(luvio, params) {
     return keyBuilder$U(luvio, {
@@ -10045,14 +10182,14 @@ const getContextAttributeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, getContextAttributeMapping_ConfigPropertyMetadata);
-const createResourceParams$d = /*#__PURE__*/ createResourceParams$Q(getContextAttributeMapping_ConfigPropertyMetadata);
+const createResourceParams$d = /*#__PURE__*/ createResourceParams$R(getContextAttributeMapping_ConfigPropertyMetadata);
 function keyBuilder$e(luvio, config) {
     const resourceParams = createResourceParams$d(config);
     return keyBuilder$f(luvio, resourceParams);
 }
 function typeCheckConfig$d(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextAttributeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextAttributeMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
@@ -10127,7 +10264,7 @@ const getContextAttributeMappingAdapterFactory = (luvio) => function IndustriesC
 };
 function select$f(luvio, params) {
-    return select$V();
+    return select$W();
 }
 function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$j(storeKeyMap, luvio, response);
@@ -10169,10 +10306,10 @@ const updateContextAttributeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextAttributeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextAttributeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, updateContextAttributeMapping_ConfigPropertyMetadata);
-const createResourceParams$c = /*#__PURE__*/ createResourceParams$Q(updateContextAttributeMapping_ConfigPropertyMetadata);
+const createResourceParams$c = /*#__PURE__*/ createResourceParams$R(updateContextAttributeMapping_ConfigPropertyMetadata);
 function typeCheckConfig$c(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, updateContextAttributeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, updateContextAttributeMapping_ConfigPropertyMetadata);
     const untrustedConfig_contextAttributeMappingInput = untrustedConfig.contextAttributeMappingInput;
     const referenceContextAttributeMappingInputRepresentationValidationError = validate$8(untrustedConfig_contextAttributeMappingInput);
     if (referenceContextAttributeMappingInputRepresentationValidationError === null) {
@@ -10259,7 +10396,7 @@ function validate$7(obj, path = 'ContextNodeMappingInputRepresentation') {
 }
 function select$e(luvio, params) {
-    return select$U();
+    return select$V();
 }
 function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$i(storeKeyMap, luvio, response);
@@ -10300,7 +10437,7 @@ const createContextNodeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createContextNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, createContextNodeMapping_ConfigPropertyMetadata);
-const createResourceParams$b = /*#__PURE__*/ createResourceParams$Q(createContextNodeMapping_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$R(createContextNodeMapping_ConfigPropertyMetadata);
 function typeCheckConfig$b(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextNodeMappingInput = untrustedConfig.contextNodeMappingInput;
@@ -10388,10 +10525,10 @@ const deleteContextNodeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteContextNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, deleteContextNodeMapping_ConfigPropertyMetadata);
-const createResourceParams$a = /*#__PURE__*/ createResourceParams$Q(deleteContextNodeMapping_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$R(deleteContextNodeMapping_ConfigPropertyMetadata);
 function typeCheckConfig$a(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, deleteContextNodeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, deleteContextNodeMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
@@ -10437,7 +10574,7 @@ const deleteContextNodeMappingAdapterFactory = (luvio) => {
 };
 function select$d(luvio, params) {
-    return select$U();
+    return select$V();
 }
 function keyBuilder$c(luvio, params) {
     return keyBuilder$T(luvio, {
@@ -10495,14 +10632,14 @@ const getContextNodeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getContextNodeMapping_ConfigPropertyMetadata);
-const createResourceParams$9 = /*#__PURE__*/ createResourceParams$Q(getContextNodeMapping_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$R(getContextNodeMapping_ConfigPropertyMetadata);
 function keyBuilder$b(luvio, config) {
     const resourceParams = createResourceParams$9(config);
     return keyBuilder$c(luvio, resourceParams);
 }
 function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextNodeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextNodeMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
@@ -10577,7 +10714,7 @@ const getContextNodeMappingAdapterFactory = (luvio) => function IndustriesContex
 };
 function select$c(luvio, params) {
-    return select$U();
+    return select$V();
 }
 function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$i(storeKeyMap, luvio, response);
@@ -10619,10 +10756,10 @@ const updateContextNodeMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextNodeMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextNodeMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, updateContextNodeMapping_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$Q(updateContextNodeMapping_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$R(updateContextNodeMapping_ConfigPropertyMetadata);
 function typeCheckConfig$8(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, updateContextNodeMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, updateContextNodeMapping_ConfigPropertyMetadata);
     const untrustedConfig_contextNodeMappingInput = untrustedConfig.contextNodeMappingInput;
     const referenceContextNodeMappingInputRepresentationValidationError = validate$7(untrustedConfig_contextNodeMappingInput);
     if (referenceContextNodeMappingInputRepresentationValidationError === null) {
@@ -10708,10 +10845,10 @@ const deleteContextMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteContextMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, deleteContextMapping_ConfigPropertyMetadata);
-const createResourceParams$7 = /*#__PURE__*/ createResourceParams$Q(deleteContextMapping_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$R(deleteContextMapping_ConfigPropertyMetadata);
 function typeCheckConfig$7(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, deleteContextMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, deleteContextMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
@@ -10757,7 +10894,7 @@ const deleteContextMappingAdapterFactory = (luvio) => {
 };
 function select$b(luvio, params) {
-    return select$T();
+    return select$U();
 }
 function keyBuilder$9(luvio, params) {
     return keyBuilder$S(luvio, {
@@ -10815,14 +10952,14 @@ const getContextMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getContextMapping_ConfigPropertyMetadata);
-const createResourceParams$6 = /*#__PURE__*/ createResourceParams$Q(getContextMapping_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$R(getContextMapping_ConfigPropertyMetadata);
 function keyBuilder$8(luvio, config) {
     const resourceParams = createResourceParams$6(config);
     return keyBuilder$9(luvio, resourceParams);
 }
 function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextMapping_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
@@ -10897,7 +11034,7 @@ const getContextMappingAdapterFactory = (luvio) => function IndustriesContext__g
 };
 function select$a(luvio, params) {
-    return select$T();
+    return select$U();
 }
 function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$h(storeKeyMap, luvio, response);
@@ -10939,10 +11076,10 @@ const updateContextMapping_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextMappingInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const updateContextMapping_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, updateContextMapping_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$Q(updateContextMapping_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$R(updateContextMapping_ConfigPropertyMetadata);
 function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, updateContextMapping_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, updateContextMapping_ConfigPropertyMetadata);
     const untrustedConfig_contextMappingInput = untrustedConfig.contextMappingInput;
     const referenceContextMappingInputRepresentationValidationError = validate$9(untrustedConfig_contextMappingInput);
     if (referenceContextMappingInputRepresentationValidationError === null) {
@@ -11295,7 +11432,7 @@ const createContextQueryRecords_ConfigPropertyMetadata = [
     generateParamConfigMetadata('queryRecordsInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createContextQueryRecords_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, createContextQueryRecords_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$Q(createContextQueryRecords_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$R(createContextQueryRecords_ConfigPropertyMetadata);
 function typeCheckConfig$4(untrustedConfig) {
     const config = {};
     const untrustedConfig_queryRecordsInput = untrustedConfig.queryRecordsInput;
@@ -11348,7 +11485,7 @@ const createContextQueryRecordsAdapterFactory = (luvio) => {
 };
 function select$6(luvio, params) {
-    return select$14();
+    return select$15();
 }
 function keyBuilder$6(luvio, params) {
     return keyBuilder$12(luvio, {
@@ -11406,14 +11543,14 @@ const getContextInfo_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextInfo_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getContextInfo_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$Q(getContextInfo_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$R(getContextInfo_ConfigPropertyMetadata);
 function keyBuilder$5(luvio, config) {
     const resourceParams = createResourceParams$3(config);
     return keyBuilder$6(luvio, resourceParams);
 }
 function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextInfo_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextInfo_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
@@ -11692,14 +11829,14 @@ const getContextTranslation_ConfigPropertyMetadata = [
     generateParamConfigMetadata('removeRestrictedFields', false, 1 /* QueryParameter */, 1 /* Boolean */),
 ];
 const getContextTranslation_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getContextTranslation_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$Q(getContextTranslation_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$R(getContextTranslation_ConfigPropertyMetadata);
 function keyBuilder$3(luvio, config) {
     const resourceParams = createResourceParams$2(config);
     return keyBuilder$4(luvio, resourceParams);
 }
 function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextTranslation_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextTranslation_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
@@ -11929,14 +12066,14 @@ const getContextServiceAccess_ConfigPropertyMetadata = [
     generateParamConfigMetadata('uniqueIdentifier', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getContextServiceAccess_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getContextServiceAccess_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$Q(getContextServiceAccess_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$R(getContextServiceAccess_ConfigPropertyMetadata);
 function keyBuilder(luvio, config) {
     const resourceParams = createResourceParams$1(config);
     return keyBuilder$1(luvio, resourceParams);
 }
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, getContextServiceAccess_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, getContextServiceAccess_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
@@ -12068,10 +12205,10 @@ const putContextServiceAccess_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contextServiceAccessInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const putContextServiceAccess_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, putContextServiceAccess_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$Q(putContextServiceAccess_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$R(putContextServiceAccess_ConfigPropertyMetadata);
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$Q(untrustedConfig, config, putContextServiceAccess_ConfigPropertyMetadata);
+    typeCheckConfig$R(untrustedConfig, config, putContextServiceAccess_ConfigPropertyMetadata);
     const untrustedConfig_contextServiceAccessInput = untrustedConfig.contextServiceAccessInput;
     const referenceContextServiceAccessInputRepresentationValidationError = validate(untrustedConfig_contextServiceAccessInput);
     if (referenceContextServiceAccessInputRepresentationValidationError === null) {
@@ -12121,4 +12258,4 @@ const putContextServiceAccessAdapterFactory = (luvio) => {
     };
 };
-export { createContextAttributeMappingAdapterFactory, createContextAttributeMappingsAdapterFactory, createContextAttributesAdapterFactory, createContextMappingAdapterFactory, createContextMappingsAdapterFactory, createContextNodeMappingAdapterFactory, createContextNodeMappingsAdapterFactory, createContextNodesAdapterFactory, createContextQueryRecordsAdapterFactory, createContextServiceDefinitionAdapterFactory, createContextTagsAdapterFactory, deleteContextAttributeMappingAdapterFactory, deleteContextMappingAdapterFactory, deleteContextNodeMappingAdapterFactory, deleteContextServiceAttributeAdapterFactory, deleteContextServiceAttributeMappingAdapterFactory, deleteContextServiceDefinitionAdapterFactory, deleteContextServiceMappingAdapterFactory, deleteContextServiceNodeAdapterFactory, deleteContextServiceNodeMappingAdapterFactory, deleteContextServiceTagAdapterFactory, getContextAdapterFactory, getContextAttributeMappingAdapterFactory, getContextDefinitionsAdapterFactory, getContextInfoAdapterFactory, getContextMappingAdapterFactory, getContextNodeMappingAdapterFactory, getContextServiceAccessAdapterFactory, getContextServiceAttributeAdapterFactory, getContextServiceAttributeMappingAdapterFactory, getContextServiceDefinitionAdapterFactory, getContextServiceDefinitionInfoAdapterFactory, getContextServiceMappingAdapterFactory, getContextServiceNodeAdapterFactory, getContextServiceNodeMappingAdapterFactory, getContextServiceTagAdapterFactory, getContextTagsAdapterFactory, getContextTranslationAdapterFactory, getDynamicAttributesAdapterFactory, putContextServiceAccessAdapterFactory, queryContextRecordAndChildrenAdapterFactory, updateContextAttributeMappingAdapterFactory, updateContextAttributeMappingsAdapterFactory, updateContextAttributesAdapterFactory, updateContextMappingAdapterFactory, updateContextMappingsAdapterFactory, updateContextNodeMappingAdapterFactory, updateContextNodeMappingsAdapterFactory, updateContextNodesAdapterFactory, updateContextServiceDefinitionAdapterFactory, updateContextTagsAdapterFactory, upgradeContextServiceDefinitionAdapterFactory };
+export { cloneContextMappingsAdapterFactory, createContextAttributeMappingAdapterFactory, createContextAttributeMappingsAdapterFactory, createContextAttributesAdapterFactory, createContextMappingAdapterFactory, createContextMappingsAdapterFactory, createContextNodeMappingAdapterFactory, createContextNodeMappingsAdapterFactory, createContextNodesAdapterFactory, createContextQueryRecordsAdapterFactory, createContextServiceDefinitionAdapterFactory, createContextTagsAdapterFactory, deleteContextAttributeMappingAdapterFactory, deleteContextMappingAdapterFactory, deleteContextNodeMappingAdapterFactory, deleteContextServiceAttributeAdapterFactory, deleteContextServiceAttributeMappingAdapterFactory, deleteContextServiceDefinitionAdapterFactory, deleteContextServiceMappingAdapterFactory, deleteContextServiceNodeAdapterFactory, deleteContextServiceNodeMappingAdapterFactory, deleteContextServiceTagAdapterFactory, getContextAdapterFactory, getContextAttributeMappingAdapterFactory, getContextDefinitionsAdapterFactory, getContextInfoAdapterFactory, getContextMappingAdapterFactory, getContextNodeMappingAdapterFactory, getContextServiceAccessAdapterFactory, getContextServiceAttributeAdapterFactory, getContextServiceAttributeMappingAdapterFactory, getContextServiceDefinitionAdapterFactory, getContextServiceDefinitionInfoAdapterFactory, getContextServiceMappingAdapterFactory, getContextServiceNodeAdapterFactory, getContextServiceNodeMappingAdapterFactory, getContextServiceTagAdapterFactory, getContextTagsAdapterFactory, getContextTranslationAdapterFactory, getDynamicAttributesAdapterFactory, putContextServiceAccessAdapterFactory, queryContextRecordAndChildrenAdapterFactory, updateContextAttributeMappingAdapterFactory, updateContextAttributeMappingsAdapterFactory, updateContextAttributesAdapterFactory, updateContextMappingAdapterFactory, updateContextMappingsAdapterFactory, updateContextNodeMappingAdapterFactory, updateContextNodeMappingsAdapterFactory, updateContextNodesAdapterFactory, updateContextServiceDefinitionAdapterFactory, updateContextTagsAdapterFactory, upgradeContextServiceDefinitionAdapterFactory };