@salesforce/lds-adapters-industries-context 1.282.0 → 1.284.0

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

@@ -112,7 +112,7 @@ function createLink(ref) {
     };
 }
 
-function validate$F(obj, path = 'QueryContextRecordInputRepresentation') {
+function validate$G(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 + '")');
@@ -161,8 +161,8 @@ function validate$F(obj, path = 'QueryContextRecordInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const VERSION$q = "6fc1ed5f9fdcaa261c69ec3614505566";
-function validate$E(obj, path = 'ContextDataRecordRepresentation') {
+const VERSION$r = "6fc1ed5f9fdcaa261c69ec3614505566";
+function validate$F(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,10 +270,10 @@ function validate$E(obj, path = 'ContextDataRecordRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$13 = function ContextDataRecordRepresentationSelect() {
+const select$14 = function ContextDataRecordRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$q,
+        version: VERSION$r,
         private: [],
         selections: [
             {
@@ -336,7 +336,7 @@ const select$13 = function ContextDataRecordRepresentationSelect() {
         ]
     };
 };
-function equals$q(existing, incoming) {
+function equals$r(existing, incoming) {
     const existing_contextDataRecordId = existing.contextDataRecordId;
     const incoming_contextDataRecordId = incoming.contextDataRecordId;
     // if at least one of these optionals is defined
@@ -498,8 +498,8 @@ function equals$q(existing, incoming) {
     return true;
 }
 
-const VERSION$p = "49d8c0b4cc8734f68ac1bc90a4614c4a";
-function validate$D(obj, path = 'ContextQueryRecordRepresentation') {
+const VERSION$q = "49d8c0b4cc8734f68ac1bc90a4614c4a";
+function validate$E(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$D(obj, path = 'ContextQueryRecordRepresentation') {
         if (obj.record !== undefined) {
             const obj_record = obj.record;
             const path_record = path + '.record';
-            const referencepath_recordValidationError = validate$E(obj_record, path_record);
+            const referencepath_recordValidationError = validate$F(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,11 +531,11 @@ function validate$D(obj, path = 'ContextQueryRecordRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$12 = function ContextQueryRecordRepresentationSelect() {
-    const { selections: ContextDataRecordRepresentation__selections, opaque: ContextDataRecordRepresentation__opaque, } = select$13();
+const select$13 = function ContextQueryRecordRepresentationSelect() {
+    const { selections: ContextDataRecordRepresentation__selections, opaque: ContextDataRecordRepresentation__opaque, } = select$14();
     return {
         kind: 'Fragment',
-        version: VERSION$p,
+        version: VERSION$q,
         private: [],
         selections: [
             {
@@ -552,7 +552,7 @@ const select$12 = function ContextQueryRecordRepresentationSelect() {
         ]
     };
 };
-function equals$p(existing, incoming) {
+function equals$q(existing, incoming) {
     const existing_childQueryRecords = existing.childQueryRecords;
     const incoming_childQueryRecords = incoming.childQueryRecords;
     // if at least one of these optionals is defined
@@ -580,7 +580,7 @@ function equals$p(existing, incoming) {
         if (existing_record === undefined || incoming_record === undefined) {
             return false;
         }
-        if (!(equals$q(existing_record, incoming_record))) {
+        if (!(equals$r(existing_record, incoming_record))) {
             return false;
         }
     }
@@ -588,8 +588,8 @@ function equals$p(existing, incoming) {
 }
 
 const TTL$m = 1000;
-const VERSION$o = "d6e0481a792086c09a70a174a9232ada";
-function validate$C(obj, path = 'QueryContextRecordResultRepresentation') {
+const VERSION$p = "d6e0481a792086c09a70a174a9232ada";
+function validate$D(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$C(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$D(obj_queryRecords_item, path_queryRecords_item);
+                const referencepath_queryRecords_itemValidationError = validate$E(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,11 +646,11 @@ function keyBuilderFromType$k(luvio, object) {
 function normalize$m(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$11 = function QueryContextRecordResultRepresentationSelect() {
-    const { selections: ContextQueryRecordRepresentation__selections, opaque: ContextQueryRecordRepresentation__opaque, } = select$12();
+const select$12 = function QueryContextRecordResultRepresentationSelect() {
+    const { selections: ContextQueryRecordRepresentation__selections, opaque: ContextQueryRecordRepresentation__opaque, } = select$13();
     return {
         kind: 'Fragment',
-        version: VERSION$o,
+        version: VERSION$p,
         private: [],
         selections: [
             {
@@ -677,7 +677,7 @@ const select$11 = function QueryContextRecordResultRepresentationSelect() {
         ]
     };
 };
-function equals$o(existing, incoming) {
+function equals$p(existing, incoming) {
     const existing_isDone = existing.isDone;
     const incoming_isDone = incoming.isDone;
     // if at least one of these optionals is defined
@@ -719,7 +719,7 @@ function equals$o(existing, incoming) {
             return false;
         }
         const equals_queryRecords_items = equalsArray(existing_queryRecords, incoming_queryRecords, (existing_queryRecords_item, incoming_queryRecords_item) => {
-            if (!(equals$p(existing_queryRecords_item, incoming_queryRecords_item))) {
+            if (!(equals$q(existing_queryRecords_item, incoming_queryRecords_item))) {
                 return false;
             }
         });
@@ -731,14 +731,14 @@ function equals$o(existing, incoming) {
 }
 const ingest$m = function QueryContextRecordResultRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$C(input);
+        const validateError = validate$D(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$k(luvio, input);
     const ttlToUse = TTL$m;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$m, "IndustriesContext", VERSION$o, RepresentationType$m, equals$o);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$m, "IndustriesContext", VERSION$p, RepresentationType$m, equals$p);
     return createLink(key);
 };
 function getTypeCacheKeys$m(rootKeySet, luvio, input, fullPathFactory) {
@@ -751,8 +751,8 @@ function getTypeCacheKeys$m(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-function select$10(luvio, params) {
-    return select$11();
+function select$11(luvio, params) {
+    return select$12();
 }
 function getResponseCacheKeys$O(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$m(storeKeyMap, luvio, response);
@@ -763,7 +763,7 @@ function ingestSuccess$E(luvio, resourceParams, response) {
     luvio.storeIngest(key, ingest$m, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$10(),
+        node: select$11(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -799,7 +799,7 @@ function typeCheckConfig$O(untrustedConfig) {
     const config = {};
     typeCheckConfig$P(untrustedConfig, config, queryContextRecordAndChildren_ConfigPropertyMetadata);
     const untrustedConfig_queryContextRecordInput = untrustedConfig.queryContextRecordInput;
-    const referenceQueryContextRecordInputRepresentationValidationError = validate$F(untrustedConfig_queryContextRecordInput);
+    const referenceQueryContextRecordInputRepresentationValidationError = validate$G(untrustedConfig_queryContextRecordInput);
     if (referenceQueryContextRecordInputRepresentationValidationError === null) {
         config.queryContextRecordInput = untrustedConfig_queryContextRecordInput;
     }
@@ -848,8 +848,8 @@ const queryContextRecordAndChildrenAdapterFactory = (luvio) => {
 };
 
 const TTL$l = 1000;
-const VERSION$n = "f4529c1d2c50b9cc056022fbea50b225";
-function validate$B(obj, path = 'ContextInfoRepresentation') {
+const VERSION$o = "f4529c1d2c50b9cc056022fbea50b225";
+function validate$C(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,15 +910,15 @@ function keyBuilderFromType$j(luvio, object) {
 function normalize$l(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$$ = function ContextInfoRepresentationSelect() {
+const select$10 = function ContextInfoRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$n,
+        version: VERSION$o,
         private: [],
         opaque: true
     };
 };
-function equals$n(existing, incoming) {
+function equals$o(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -926,14 +926,14 @@ function equals$n(existing, incoming) {
 }
 const ingest$l = function ContextInfoRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$B(input);
+        const validateError = validate$C(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$j(luvio, input);
     const ttlToUse = TTL$l;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$l, "IndustriesContext", VERSION$n, RepresentationType$l, equals$n);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$l, "IndustriesContext", VERSION$o, RepresentationType$l, equals$o);
     return createLink(key);
 };
 function getTypeCacheKeys$l(rootKeySet, luvio, input, fullPathFactory) {
@@ -946,8 +946,8 @@ function getTypeCacheKeys$l(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-function select$_(luvio, params) {
-    return select$$();
+function select$$(luvio, params) {
+    return select$10();
 }
 function keyBuilder$_(luvio, params) {
     return keyBuilder$$(luvio, {
@@ -963,7 +963,7 @@ function ingestSuccess$D(luvio, resourceParams, response, snapshotRefresh) {
     luvio.storeIngest(key, ingest$l, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$_(),
+        node: select$$(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -980,7 +980,7 @@ function ingestError$g(luvio, params, error, snapshotRefresh) {
     const storeMetadataParams = {
         ttl: TTL$l,
         namespace: keyPrefix,
-        version: VERSION$n,
+        version: VERSION$o,
         representationName: RepresentationType$l
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
@@ -1030,7 +1030,7 @@ function validateAdapterConfig$N(untrustedConfig, configPropertyNames) {
 }
 function adapterFragment$g(luvio, config) {
     createResourceParams$N(config);
-    return select$_();
+    return select$$();
 }
 function onFetchResponseSuccess$g(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$D(luvio, resourceParams, response, {
@@ -1087,8 +1087,8 @@ const getContextAdapterFactory = (luvio) => function IndustriesContext__getConte
 };
 
 const TTL$k = 1000;
-const VERSION$m = "ad70f246fe62dc8126e558799bc7a155";
-function validate$A(obj, path = 'ContextDefinitionInfoRepresentation') {
+const VERSION$n = "ad70f246fe62dc8126e558799bc7a155";
+function validate$B(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,10 +1233,10 @@ function keyBuilderFromType$i(luvio, object) {
 function normalize$k(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$Z = function ContextDefinitionInfoRepresentationSelect() {
+const select$_ = function ContextDefinitionInfoRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$m,
+        version: VERSION$n,
         private: [],
         selections: [
             {
@@ -1331,7 +1331,7 @@ const select$Z = function ContextDefinitionInfoRepresentationSelect() {
         ]
     };
 };
-function equals$m(existing, incoming) {
+function equals$n(existing, incoming) {
     const existing_isActive = existing.isActive;
     const incoming_isActive = incoming.isActive;
     // if at least one of these optionals is defined
@@ -1562,14 +1562,14 @@ function equals$m(existing, incoming) {
 }
 const ingest$k = function ContextDefinitionInfoRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$A(input);
+        const validateError = validate$B(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$i(luvio, input);
     const ttlToUse = TTL$k;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$k, "IndustriesContext", VERSION$m, RepresentationType$k, equals$m);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$k, "IndustriesContext", VERSION$n, RepresentationType$k, equals$n);
     return createLink(key);
 };
 function getTypeCacheKeys$k(rootKeySet, luvio, input, fullPathFactory) {
@@ -1583,8 +1583,8 @@ function getTypeCacheKeys$k(rootKeySet, luvio, input, fullPathFactory) {
 }
 
 const TTL$j = 1000;
-const VERSION$l = "9fd2c86ba3bfc49bd6b1b41332fbad4e";
-function validate$z(obj, path = 'ContextDefinitionListRepresentation') {
+const VERSION$m = "9fd2c86ba3bfc49bd6b1b41332fbad4e";
+function validate$A(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,17 +1636,17 @@ function normalize$j(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$Y = function ContextDefinitionListRepresentationSelect() {
+const select$Z = function ContextDefinitionListRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$l,
+        version: VERSION$m,
         private: [],
         selections: [
             {
                 name: 'contextDefinitionList',
                 kind: 'Link',
                 plural: true,
-                fragment: select$Z()
+                fragment: select$_()
             },
             {
                 name: 'contextDefinitionListId',
@@ -1660,7 +1660,7 @@ const select$Y = function ContextDefinitionListRepresentationSelect() {
         ]
     };
 };
-function equals$l(existing, incoming) {
+function equals$m(existing, incoming) {
     const existing_isSuccess = existing.isSuccess;
     const incoming_isSuccess = incoming.isSuccess;
     // if at least one of these optionals is defined
@@ -1693,14 +1693,14 @@ function equals$l(existing, incoming) {
 }
 const ingest$j = function ContextDefinitionListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$z(input);
+        const validateError = validate$A(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
     const ttlToUse = TTL$j;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$j, "IndustriesContext", VERSION$l, RepresentationType$j, equals$l);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$j, "IndustriesContext", VERSION$m, RepresentationType$j, equals$m);
     return createLink(key);
 };
 function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
@@ -1717,8 +1717,8 @@ function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
 
-function select$X(luvio, params) {
-    return select$Y();
+function select$Y(luvio, params) {
+    return select$Z();
 }
 function keyBuilder$X(luvio, params) {
     return keyPrefix + '::ContextDefinitionListRepresentation:(' + 'includeInactive:' + params.queryParams.includeInactive + ',' + 'includeUpgrade:' + params.queryParams.includeUpgrade + ')';
@@ -1732,7 +1732,7 @@ function ingestSuccess$C(luvio, resourceParams, response, snapshotRefresh) {
     luvio.storeIngest(key, ingest$j, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$X(),
+        node: select$Y(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1749,7 +1749,7 @@ function ingestError$f(luvio, params, error, snapshotRefresh) {
     const storeMetadataParams = {
         ttl: TTL$j,
         namespace: keyPrefix,
-        version: VERSION$l,
+        version: VERSION$m,
         representationName: RepresentationType$j
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
@@ -1800,7 +1800,7 @@ function validateAdapterConfig$M(untrustedConfig, configPropertyNames) {
 }
 function adapterFragment$f(luvio, config) {
     createResourceParams$M(config);
-    return select$X();
+    return select$Y();
 }
 function onFetchResponseSuccess$f(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$C(luvio, resourceParams, response, {
@@ -1856,7 +1856,7 @@ const getContextDefinitionsAdapterFactory = (luvio) => function IndustriesContex
     buildCachedSnapshotCachePolicy$f, buildNetworkSnapshotCachePolicy$f);
 };
 
-function validate$y(obj, path = 'ContextDefinitionsInputRepresentation') {
+function validate$z(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,8 +1935,8 @@ function validate$y(obj, path = 'ContextDefinitionsInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function select$W(luvio, params) {
-    return select$Z();
+function select$X(luvio, params) {
+    return select$_();
 }
 function getResponseCacheKeys$L(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$k(storeKeyMap, luvio, response);
@@ -1947,7 +1947,7 @@ function ingestSuccess$B(luvio, resourceParams, response) {
     luvio.storeIngest(key, ingest$k, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$W(),
+        node: select$X(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1981,7 +1981,7 @@ const createResourceParams$L = /*#__PURE__*/ createResourceParams$P(createContex
 function typeCheckConfig$L(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextDefinitionInput = untrustedConfig.contextDefinitionInput;
-    const referenceContextDefinitionsInputRepresentationValidationError = validate$y(untrustedConfig_contextDefinitionInput);
+    const referenceContextDefinitionsInputRepresentationValidationError = validate$z(untrustedConfig_contextDefinitionInput);
     if (referenceContextDefinitionsInputRepresentationValidationError === null) {
         config.contextDefinitionInput = untrustedConfig_contextDefinitionInput;
     }
@@ -2029,8 +2029,8 @@ const createContextServiceDefinitionAdapterFactory = (luvio) => {
     };
 };
 
-function select$V(luvio, params) {
-    return select$Z();
+function select$W(luvio, params) {
+    return select$_();
 }
 function keyBuilder$V(luvio, params) {
     return keyBuilder$Y(luvio, {
@@ -2046,7 +2046,7 @@ function ingestSuccess$A(luvio, resourceParams, response, snapshotRefresh) {
     luvio.storeIngest(key, ingest$k, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$V(),
+        node: select$W(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2063,7 +2063,7 @@ function ingestError$e(luvio, params, error, snapshotRefresh) {
     const storeMetadataParams = {
         ttl: TTL$k,
         namespace: keyPrefix,
-        version: VERSION$m,
+        version: VERSION$n,
         representationName: RepresentationType$k
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
@@ -2113,7 +2113,7 @@ function validateAdapterConfig$K(untrustedConfig, configPropertyNames) {
 }
 function adapterFragment$e(luvio, config) {
     createResourceParams$K(config);
-    return select$V();
+    return select$W();
 }
 function onFetchResponseSuccess$e(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$A(luvio, resourceParams, response, {
@@ -2169,7 +2169,7 @@ const getContextServiceDefinitionInfoAdapterFactory = (luvio) => function Indust
     buildCachedSnapshotCachePolicy$e, buildNetworkSnapshotCachePolicy$e);
 };
 
-function validate$x(obj, path = 'ContextDefinitionUpgradeListInputRepresentation') {
+function validate$y(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 + '")');
@@ -2193,8 +2193,8 @@ function validate$x(obj, path = 'ContextDefinitionUpgradeListInputRepresentation
 }
 
 const TTL$i = 1000;
-const VERSION$k = "0f55f143dba32bcf6d4a3ba8ced13b41";
-function validate$w(obj, path = 'ContextDefinitionUpgradeListRepresentation') {
+const VERSION$l = "0f55f143dba32bcf6d4a3ba8ced13b41";
+function validate$x(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,17 +2255,17 @@ function normalize$i(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$U = function ContextDefinitionUpgradeListRepresentationSelect() {
+const select$V = function ContextDefinitionUpgradeListRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$k,
+        version: VERSION$l,
         private: [],
         selections: [
             {
                 name: 'contextDefinitionList',
                 kind: 'Link',
                 plural: true,
-                fragment: select$Z()
+                fragment: select$_()
             },
             {
                 name: 'contextDefinitionListId',
@@ -2279,7 +2279,7 @@ const select$U = function ContextDefinitionUpgradeListRepresentationSelect() {
         ]
     };
 };
-function equals$k(existing, incoming) {
+function equals$l(existing, incoming) {
     const existing_isSuccess = existing.isSuccess;
     const incoming_isSuccess = incoming.isSuccess;
     // if at least one of these optionals is defined
@@ -2312,14 +2312,14 @@ function equals$k(existing, incoming) {
 }
 const ingest$i = function ContextDefinitionUpgradeListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$w(input);
+        const validateError = validate$x(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$h(luvio, input);
     const ttlToUse = TTL$i;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$i, "IndustriesContext", VERSION$k, RepresentationType$i, equals$k);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$i, "IndustriesContext", VERSION$l, RepresentationType$i, equals$l);
     return createLink(key);
 };
 function getTypeCacheKeys$i(rootKeySet, luvio, input, fullPathFactory) {
@@ -2336,8 +2336,8 @@ function getTypeCacheKeys$i(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
 
-function select$T(luvio, params) {
-    return select$U();
+function select$U(luvio, params) {
+    return select$V();
 }
 function getResponseCacheKeys$J(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$i(storeKeyMap, luvio, response);
@@ -2348,7 +2348,7 @@ function ingestSuccess$z(luvio, resourceParams, response) {
     luvio.storeIngest(key, ingest$i, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$T(),
+        node: select$U(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -2382,7 +2382,7 @@ const createResourceParams$J = /*#__PURE__*/ createResourceParams$P(upgradeConte
 function typeCheckConfig$J(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextDefinitionUpgradesInput = untrustedConfig.contextDefinitionUpgradesInput;
-    const referenceContextDefinitionUpgradeListInputRepresentationValidationError = validate$x(untrustedConfig_contextDefinitionUpgradesInput);
+    const referenceContextDefinitionUpgradeListInputRepresentationValidationError = validate$y(untrustedConfig_contextDefinitionUpgradesInput);
     if (referenceContextDefinitionUpgradeListInputRepresentationValidationError === null) {
         config.contextDefinitionUpgradesInput = untrustedConfig_contextDefinitionUpgradesInput;
     }
@@ -2430,6 +2430,128 @@ const upgradeContextServiceDefinitionAdapterFactory = (luvio) => {
     };
 };
 
+const VERSION$k = "40b52866e6f56ae5b7cfb279bcfae6ce";
+function validate$w(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 + '")');
+        }
+        if (obj.baseReference !== undefined) {
+            const obj_baseReference = obj.baseReference;
+            const path_baseReference = path + '.baseReference';
+            if (typeof obj_baseReference !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_baseReference + '" (at "' + path_baseReference + '")');
+            }
+        }
+        if (obj.contextAttrContextHydrationDetailId !== undefined) {
+            const obj_contextAttrContextHydrationDetailId = obj.contextAttrContextHydrationDetailId;
+            const path_contextAttrContextHydrationDetailId = path + '.contextAttrContextHydrationDetailId';
+            if (typeof obj_contextAttrContextHydrationDetailId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_contextAttrContextHydrationDetailId + '" (at "' + path_contextAttrContextHydrationDetailId + '")');
+            }
+        }
+        if (obj.isSuccess !== undefined) {
+            const obj_isSuccess = obj.isSuccess;
+            const path_isSuccess = path + '.isSuccess';
+            if (typeof obj_isSuccess !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isSuccess + '" (at "' + path_isSuccess + '")');
+            }
+        }
+        if (obj.queryAttribute !== undefined) {
+            const obj_queryAttribute = obj.queryAttribute;
+            const path_queryAttribute = path + '.queryAttribute';
+            if (typeof obj_queryAttribute !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_queryAttribute + '" (at "' + path_queryAttribute + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$T = function ContextAttrContextHydrationDetailRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$k,
+        private: [],
+        selections: [
+            {
+                name: 'baseReference',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'contextAttrContextHydrationDetailId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'isSuccess',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'queryAttribute',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$k(existing, incoming) {
+    const existing_isSuccess = existing.isSuccess;
+    const incoming_isSuccess = incoming.isSuccess;
+    // if at least one of these optionals is defined
+    if (existing_isSuccess !== undefined || incoming_isSuccess !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isSuccess === undefined || incoming_isSuccess === undefined) {
+            return false;
+        }
+        if (!(existing_isSuccess === incoming_isSuccess)) {
+            return false;
+        }
+    }
+    const existing_baseReference = existing.baseReference;
+    const incoming_baseReference = incoming.baseReference;
+    // if at least one of these optionals is defined
+    if (existing_baseReference !== undefined || incoming_baseReference !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_baseReference === undefined || incoming_baseReference === undefined) {
+            return false;
+        }
+        if (!(existing_baseReference === incoming_baseReference)) {
+            return false;
+        }
+    }
+    const existing_contextAttrContextHydrationDetailId = existing.contextAttrContextHydrationDetailId;
+    const incoming_contextAttrContextHydrationDetailId = incoming.contextAttrContextHydrationDetailId;
+    // if at least one of these optionals is defined
+    if (existing_contextAttrContextHydrationDetailId !== undefined || incoming_contextAttrContextHydrationDetailId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_contextAttrContextHydrationDetailId === undefined || incoming_contextAttrContextHydrationDetailId === undefined) {
+            return false;
+        }
+        if (!(existing_contextAttrContextHydrationDetailId === incoming_contextAttrContextHydrationDetailId)) {
+            return false;
+        }
+    }
+    const existing_queryAttribute = existing.queryAttribute;
+    const incoming_queryAttribute = incoming.queryAttribute;
+    // if at least one of these optionals is defined
+    if (existing_queryAttribute !== undefined || incoming_queryAttribute !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_queryAttribute === undefined || incoming_queryAttribute === undefined) {
+            return false;
+        }
+        if (!(existing_queryAttribute === incoming_queryAttribute)) {
+            return false;
+        }
+    }
+    return true;
+}
+
 function validate$v(obj, path = 'MappedAttributeDataTypeInfoRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -2584,7 +2706,7 @@ function getTypeCacheKeys$h(rootKeySet, luvio, input, fullPathFactory) {
 }
 
 const TTL$g = 1000;
-const VERSION$i = "9c844c38d358bc66d470df64952c4caa";
+const VERSION$i = "539359f9069e5a51a579221aeaef8234";
 function validate$t(obj, path = 'ContextAttributeMappingRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -2597,6 +2719,23 @@ function validate$t(obj, path = 'ContextAttributeMappingRepresentation') {
                 return new TypeError('Expected "string" but received "' + typeof obj_baseReference + '" (at "' + path_baseReference + '")');
             }
         }
+        if (obj.contextAttrContextHydrationDetailList !== undefined) {
+            const obj_contextAttrContextHydrationDetailList = obj.contextAttrContextHydrationDetailList;
+            const path_contextAttrContextHydrationDetailList = path + '.contextAttrContextHydrationDetailList';
+            if (!ArrayIsArray(obj_contextAttrContextHydrationDetailList)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_contextAttrContextHydrationDetailList + '" (at "' + path_contextAttrContextHydrationDetailList + '")');
+            }
+            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$w(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');
+                    return new TypeError(message);
+                }
+            }
+        }
         const obj_contextAttrHydrationDetailList = obj.contextAttrHydrationDetailList;
         const path_contextAttrHydrationDetailList = path + '.contextAttrHydrationDetailList';
         if (!ArrayIsArray(obj_contextAttrHydrationDetailList)) {
@@ -2621,6 +2760,13 @@ function validate$t(obj, path = 'ContextAttributeMappingRepresentation') {
         if (typeof obj_contextAttributeMappingId !== 'string') {
             return new TypeError('Expected "string" but received "' + typeof obj_contextAttributeMappingId + '" (at "' + path_contextAttributeMappingId + '")');
         }
+        if (obj.contextAttributeName !== undefined) {
+            const obj_contextAttributeName = obj.contextAttributeName;
+            const path_contextAttributeName = path + '.contextAttributeName';
+            if (typeof obj_contextAttributeName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_contextAttributeName + '" (at "' + path_contextAttributeName + '")');
+            }
+        }
         if (obj.contextInputAttributeName !== undefined) {
             const obj_contextInputAttributeName = obj.contextInputAttributeName;
             const path_contextInputAttributeName = path + '.contextInputAttributeName';
@@ -2682,6 +2828,7 @@ function normalize$g(input, existing, path, luvio, store, timestamp) {
     return input;
 }
 const select$R = function ContextAttributeMappingRepresentationSelect() {
+    const { selections: ContextAttrContextHydrationDetailRepresentation__selections, opaque: ContextAttrContextHydrationDetailRepresentation__opaque, } = select$T();
     return {
         kind: 'Fragment',
         version: VERSION$i,
@@ -2692,6 +2839,13 @@ const select$R = function ContextAttributeMappingRepresentationSelect() {
                 kind: 'Scalar',
                 required: false
             },
+            {
+                name: 'contextAttrContextHydrationDetailList',
+                kind: 'Object',
+                plural: true,
+                selections: ContextAttrContextHydrationDetailRepresentation__selections,
+                required: false
+            },
             {
                 name: 'contextAttrHydrationDetailList',
                 kind: 'Link',
@@ -2707,6 +2861,11 @@ const select$R = function ContextAttributeMappingRepresentationSelect() {
                 name: 'contextAttributeMappingId',
                 kind: 'Scalar'
             },
+            {
+                name: 'contextAttributeName',
+                kind: 'Scalar',
+                required: false
+            },
             {
                 name: 'contextInputAttributeName',
                 kind: 'Scalar',
@@ -2775,6 +2934,19 @@ function equals$i(existing, incoming) {
     if (!(existing_contextAttributeMappingId === incoming_contextAttributeMappingId)) {
         return false;
     }
+    const existing_contextAttributeName = existing.contextAttributeName;
+    const incoming_contextAttributeName = incoming.contextAttributeName;
+    // if at least one of these optionals is defined
+    if (existing_contextAttributeName !== undefined || incoming_contextAttributeName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_contextAttributeName === undefined || incoming_contextAttributeName === undefined) {
+            return false;
+        }
+        if (!(existing_contextAttributeName === incoming_contextAttributeName)) {
+            return false;
+        }
+    }
     const existing_contextInputAttributeName = existing.contextInputAttributeName;
     const incoming_contextInputAttributeName = incoming.contextInputAttributeName;
     // if at least one of these optionals is defined
@@ -2814,6 +2986,24 @@ function equals$i(existing, incoming) {
             return false;
         }
     }
+    const existing_contextAttrContextHydrationDetailList = existing.contextAttrContextHydrationDetailList;
+    const incoming_contextAttrContextHydrationDetailList = incoming.contextAttrContextHydrationDetailList;
+    // if at least one of these optionals is defined
+    if (existing_contextAttrContextHydrationDetailList !== undefined || incoming_contextAttrContextHydrationDetailList !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_contextAttrContextHydrationDetailList === undefined || incoming_contextAttrContextHydrationDetailList === undefined) {
+            return false;
+        }
+        const equals_contextAttrContextHydrationDetailList_items = equalsArray(existing_contextAttrContextHydrationDetailList, incoming_contextAttrContextHydrationDetailList, (existing_contextAttrContextHydrationDetailList_item, incoming_contextAttrContextHydrationDetailList_item) => {
+            if (!(equals$k(existing_contextAttrContextHydrationDetailList_item, incoming_contextAttrContextHydrationDetailList_item))) {
+                return false;
+            }
+        });
+        if (equals_contextAttrContextHydrationDetailList_items === false) {
+            return false;
+        }
+    }
     const existing_contextAttrHydrationDetailList = existing.contextAttrHydrationDetailList;
     const incoming_contextAttrHydrationDetailList = incoming.contextAttrHydrationDetailList;
     const equals_contextAttrHydrationDetailList_items = equalsArray(existing_contextAttrHydrationDetailList, incoming_contextAttrHydrationDetailList, (existing_contextAttrHydrationDetailList_item, incoming_contextAttrHydrationDetailList_item) => {
@@ -2853,7 +3043,7 @@ function getTypeCacheKeys$g(rootKeySet, luvio, input, fullPathFactory) {
 }
 
 const TTL$f = 1000;
-const VERSION$h = "ab9980cfd3a0d5bbf761326211a36d4a";
+const VERSION$h = "0f7420d3c8dbe149876b673d81e43341";
 function validate$s(obj, path = 'ContextNodeMappingRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -2904,6 +3094,13 @@ function validate$s(obj, path = 'ContextNodeMappingRepresentation') {
                 return new TypeError('Expected "boolean" but received "' + typeof obj_isSuccess + '" (at "' + path_isSuccess + '")');
             }
         }
+        if (obj.mappedContextNodeId !== undefined) {
+            const obj_mappedContextNodeId = obj.mappedContextNodeId;
+            const path_mappedContextNodeId = path + '.mappedContextNodeId';
+            if (typeof obj_mappedContextNodeId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_mappedContextNodeId + '" (at "' + path_mappedContextNodeId + '")');
+            }
+        }
         if (obj.sObjectName !== undefined) {
             const obj_sObjectName = obj.sObjectName;
             const path_sObjectName = path + '.sObjectName';
@@ -2979,6 +3176,11 @@ const select$Q = function ContextNodeMappingRepresentationSelect() {
                 kind: 'Scalar',
                 required: false
             },
+            {
+                name: 'mappedContextNodeId',
+                kind: 'Scalar',
+                required: false
+            },
             {
                 name: 'sObjectName',
                 kind: 'Scalar',
@@ -3045,6 +3247,19 @@ function equals$h(existing, incoming) {
     if (!(existing_contextNodeMappingId === incoming_contextNodeMappingId)) {
         return false;
     }
+    const existing_mappedContextNodeId = existing.mappedContextNodeId;
+    const incoming_mappedContextNodeId = incoming.mappedContextNodeId;
+    // if at least one of these optionals is defined
+    if (existing_mappedContextNodeId !== undefined || incoming_mappedContextNodeId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_mappedContextNodeId === undefined || incoming_mappedContextNodeId === undefined) {
+            return false;
+        }
+        if (!(existing_mappedContextNodeId === incoming_mappedContextNodeId)) {
+            return false;
+        }
+    }
     const existing_sObjectName = existing.sObjectName;
     const incoming_sObjectName = incoming.sObjectName;
     // if at least one of these optionals is defined
@@ -3097,7 +3312,7 @@ function getTypeCacheKeys$f(rootKeySet, luvio, input, fullPathFactory) {
 }
 
 const TTL$e = 1000;
-const VERSION$g = "9238a5d36570897d86032d14954a90c4";
+const VERSION$g = "6625536779234428522beec438ddd863";
 function validate$r(obj, path = 'ContextMappingRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -3141,6 +3356,20 @@ function validate$r(obj, path = 'ContextMappingRepresentation') {
                 return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
             }
         }
+        if (obj.intents !== undefined) {
+            const obj_intents = obj.intents;
+            const path_intents = path + '.intents';
+            if (!ArrayIsArray(obj_intents)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_intents + '" (at "' + path_intents + '")');
+            }
+            for (let i = 0; i < obj_intents.length; i++) {
+                const obj_intents_item = obj_intents[i];
+                const path_intents_item = path_intents + '[' + i + ']';
+                if (typeof obj_intents_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_intents_item + '" (at "' + path_intents_item + '")');
+                }
+            }
+        }
         if (obj.isDefault !== undefined) {
             const obj_isDefault = obj.isDefault;
             const path_isDefault = path + '.isDefault';
@@ -3148,6 +3377,13 @@ function validate$r(obj, path = 'ContextMappingRepresentation') {
                 return new TypeError('Expected "boolean" but received "' + typeof obj_isDefault + '" (at "' + path_isDefault + '")');
             }
         }
+        if (obj.isInputMapped !== undefined) {
+            const obj_isInputMapped = obj.isInputMapped;
+            const path_isInputMapped = path + '.isInputMapped';
+            if (typeof obj_isInputMapped !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isInputMapped + '" (at "' + path_isInputMapped + '")');
+            }
+        }
         if (obj.isSuccess !== undefined) {
             const obj_isSuccess = obj.isSuccess;
             const path_isSuccess = path + '.isSuccess';
@@ -3155,6 +3391,13 @@ function validate$r(obj, path = 'ContextMappingRepresentation') {
                 return new TypeError('Expected "boolean" but received "' + typeof obj_isSuccess + '" (at "' + path_isSuccess + '")');
             }
         }
+        if (obj.mappedContextDefinitionName !== undefined) {
+            const obj_mappedContextDefinitionName = obj.mappedContextDefinitionName;
+            const path_mappedContextDefinitionName = path + '.mappedContextDefinitionName';
+            if (typeof obj_mappedContextDefinitionName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_mappedContextDefinitionName + '" (at "' + path_mappedContextDefinitionName + '")');
+            }
+        }
         if (obj.name !== undefined) {
             const obj_name = obj.name;
             const path_name = path + '.name';
@@ -3225,16 +3468,32 @@ const select$P = function ContextMappingRepresentationSelect() {
                 kind: 'Scalar',
                 required: false
             },
+            {
+                name: 'intents',
+                kind: 'Scalar',
+                plural: true,
+                required: false
+            },
             {
                 name: 'isDefault',
                 kind: 'Scalar',
                 required: false
             },
+            {
+                name: 'isInputMapped',
+                kind: 'Scalar',
+                required: false
+            },
             {
                 name: 'isSuccess',
                 kind: 'Scalar',
                 required: false
             },
+            {
+                name: 'mappedContextDefinitionName',
+                kind: 'Scalar',
+                required: false
+            },
             {
                 name: 'name',
                 kind: 'Scalar',
@@ -3257,6 +3516,19 @@ function equals$g(existing, incoming) {
             return false;
         }
     }
+    const existing_isInputMapped = existing.isInputMapped;
+    const incoming_isInputMapped = incoming.isInputMapped;
+    // if at least one of these optionals is defined
+    if (existing_isInputMapped !== undefined || incoming_isInputMapped !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isInputMapped === undefined || incoming_isInputMapped === undefined) {
+            return false;
+        }
+        if (!(existing_isInputMapped === incoming_isInputMapped)) {
+            return false;
+        }
+    }
     const existing_isSuccess = existing.isSuccess;
     const incoming_isSuccess = incoming.isSuccess;
     // if at least one of these optionals is defined
@@ -3314,6 +3586,19 @@ function equals$g(existing, incoming) {
             return false;
         }
     }
+    const existing_mappedContextDefinitionName = existing.mappedContextDefinitionName;
+    const incoming_mappedContextDefinitionName = incoming.mappedContextDefinitionName;
+    // if at least one of these optionals is defined
+    if (existing_mappedContextDefinitionName !== undefined || incoming_mappedContextDefinitionName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_mappedContextDefinitionName === undefined || incoming_mappedContextDefinitionName === undefined) {
+            return false;
+        }
+        if (!(existing_mappedContextDefinitionName === incoming_mappedContextDefinitionName)) {
+            return false;
+        }
+    }
     const existing_name = existing.name;
     const incoming_name = incoming.name;
     // if at least one of these optionals is defined
@@ -3337,6 +3622,24 @@ function equals$g(existing, incoming) {
     if (equals_contextNodeMappings_items === false) {
         return false;
     }
+    const existing_intents = existing.intents;
+    const incoming_intents = incoming.intents;
+    // if at least one of these optionals is defined
+    if (existing_intents !== undefined || incoming_intents !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_intents === undefined || incoming_intents === undefined) {
+            return false;
+        }
+        const equals_intents_items = equalsArray(existing_intents, incoming_intents, (existing_intents_item, incoming_intents_item) => {
+            if (!(existing_intents_item === incoming_intents_item)) {
+                return false;
+            }
+        });
+        if (equals_intents_items === false) {
+            return false;
+        }
+    }
     return true;
 }
 const ingest$e = function ContextMappingRepresentationIngest(input, path, luvio, store, timestamp) {
@@ -4785,7 +5088,7 @@ function createResourceRequest$H(config) {
         method: 'get',
         body: null,
         urlParams: config.urlParams,
-        queryParams: {},
+        queryParams: config.queryParams,
         headers,
         priority: 'normal',
     };
@@ -4794,6 +5097,8 @@ function createResourceRequest$H(config) {
 const adapterName$H = '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$H, getContextServiceDefinition_ConfigPropertyMetadata);
 const createResourceParams$H = /*#__PURE__*/ createResourceParams$P(getContextServiceDefinition_ConfigPropertyMetadata);
@@ -4878,7 +5183,7 @@ const getContextServiceDefinitionAdapterFactory = (luvio) => function Industries
 };
 
 function select$I(luvio, params) {
-    return select$Z();
+    return select$_();
 }
 function getResponseCacheKeys$G(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$k(storeKeyMap, luvio, response);
@@ -4925,7 +5230,7 @@ function typeCheckConfig$G(untrustedConfig) {
     const config = {};
     typeCheckConfig$P(untrustedConfig, config, updateContextServiceDefinition_ConfigPropertyMetadata);
     const untrustedConfig_contextDefinitionInput = untrustedConfig.contextDefinitionInput;
-    const referenceContextDefinitionsInputRepresentationValidationError = validate$y(untrustedConfig_contextDefinitionInput);
+    const referenceContextDefinitionsInputRepresentationValidationError = validate$z(untrustedConfig_contextDefinitionInput);
     if (referenceContextDefinitionsInputRepresentationValidationError === null) {
         config.contextDefinitionInput = untrustedConfig_contextDefinitionInput;
     }
@@ -10484,7 +10789,7 @@ const createContextQueryRecordsAdapterFactory = (luvio) => {
 };
 
 function select$6(luvio, params) {
-    return select$$();
+    return select$10();
 }
 function keyBuilder$6(luvio, params) {
     return keyBuilder$$(luvio, {
@@ -10517,7 +10822,7 @@ function ingestError$2(luvio, params, error, snapshotRefresh) {
     const storeMetadataParams = {
         ttl: TTL$l,
         namespace: keyPrefix,
-        version: VERSION$n,
+        version: VERSION$o,
         representationName: RepresentationType$l
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);