@salesforce/lds-adapters-industries-context 1.134.1 → 1.134.3

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

@@ -90,7 +90,7 @@ function createLink(ref) {
     };
 }
 
-const TTL$c = 30000;
+const TTL$d = 30000;
 const VERSION$d = "05ab63159c5733f63fae9f5eb081ee89";
 function validate$n(obj, path = 'ContextDefinitionInfoRepresentation') {
     const v_error = (() => {
@@ -189,17 +189,17 @@ function validate$n(obj, path = 'ContextDefinitionInfoRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$c = 'ContextDefinitionInfoRepresentation';
-function keyBuilder$G(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$c + ':' + config.id;
+const RepresentationType$d = 'ContextDefinitionInfoRepresentation';
+function keyBuilder$H(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$d + ':' + config.id;
 }
-function keyBuilderFromType$a(luvio, object) {
+function keyBuilderFromType$b(luvio, object) {
     const keyParams = {
         id: object.contextDefinitionId
     };
-    return keyBuilder$G(luvio, keyParams);
+    return keyBuilder$H(luvio, keyParams);
 }
-function normalize$c(input, existing, path, luvio, store, timestamp) {
+function normalize$d(input, existing, path, luvio, store, timestamp) {
     return input;
 }
 const select$H = function ContextDefinitionInfoRepresentationSelect() {
@@ -439,17 +439,17 @@ function equals$d(existing, incoming) {
     }
     return true;
 }
-const ingest$c = function ContextDefinitionInfoRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$d = function ContextDefinitionInfoRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$n(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$a(luvio, input);
+    const key = keyBuilderFromType$b(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$c;
-    let incomingRecord = normalize$c(input, store.readEntry(key), {
+    const ttlToUse = TTL$d;
+    let incomingRecord = normalize$d(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
@@ -463,25 +463,25 @@ const ingest$c = function ContextDefinitionInfoRepresentationIngest(input, path,
             ttl: ttlToUse,
             namespace: "IndustriesContext",
             version: VERSION$d,
-            representationName: RepresentationType$c,
+            representationName: RepresentationType$d,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$c(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$d(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$a(luvio, input);
+    const rootKey = keyBuilderFromType$b(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$c,
+        representationName: RepresentationType$d,
         mergeable: false
     });
     return rootKeySet;
 }
 
-const TTL$b = 10000;
+const TTL$c = 10000;
 const VERSION$c = "847680af81af4497e1c8078978aa7a7e";
 function validate$m(obj, path = 'ContextDefinitionListRepresentation') {
     const v_error = (() => {
@@ -510,14 +510,14 @@ function validate$m(obj, path = 'ContextDefinitionListRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$b = 'ContextDefinitionListRepresentation';
-function normalize$b(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$c = 'ContextDefinitionListRepresentation';
+function normalize$c(input, existing, path, luvio, store, timestamp) {
     const input_contextDefinitionList = input.contextDefinitionList;
     const input_contextDefinitionList_id = path.fullPath + '__contextDefinitionList';
     for (let i = 0; i < input_contextDefinitionList.length; i++) {
         const input_contextDefinitionList_item = input_contextDefinitionList[i];
         let input_contextDefinitionList_item_id = input_contextDefinitionList_id + '__' + i;
-        input_contextDefinitionList[i] = ingest$c(input_contextDefinitionList_item, {
+        input_contextDefinitionList[i] = ingest$d(input_contextDefinitionList_item, {
             fullPath: input_contextDefinitionList_item_id,
             propertyName: i,
             parent: {
@@ -576,7 +576,7 @@ function equals$c(existing, incoming) {
     }
     return true;
 }
-const ingest$b = function ContextDefinitionListRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$c = function ContextDefinitionListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$m(input);
         if (validateError !== null) {
@@ -585,8 +585,8 @@ const ingest$b = function ContextDefinitionListRepresentationIngest(input, path,
     }
     const key = path.fullPath;
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$b;
-    let incomingRecord = normalize$b(input, store.readEntry(key), {
+    const ttlToUse = TTL$c;
+    let incomingRecord = normalize$c(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
@@ -600,24 +600,24 @@ const ingest$b = function ContextDefinitionListRepresentationIngest(input, path,
             ttl: ttlToUse,
             namespace: "IndustriesContext",
             version: VERSION$c,
-            representationName: RepresentationType$b,
+            representationName: RepresentationType$c,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$b(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$c(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$b,
+        representationName: RepresentationType$c,
         mergeable: false
     });
     const input_contextDefinitionList_length = input.contextDefinitionList.length;
     for (let i = 0; i < input_contextDefinitionList_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$c(luvio, input.contextDefinitionList[i]));
+        rootKeySet.merge(getTypeCacheKeys$d(luvio, input.contextDefinitionList[i]));
     }
     return rootKeySet;
 }
@@ -625,16 +625,16 @@ function getTypeCacheKeys$b(luvio, input, fullPathFactory) {
 function select$F(luvio, params) {
     return select$G();
 }
-function keyBuilder$F(luvio, params) {
+function keyBuilder$G(luvio, params) {
     return keyPrefix + '::ContextDefinitionListRepresentation:(' + 'includeInactive:' + params.queryParams.includeInactive + ')';
 }
 function getResponseCacheKeys$B(luvio, resourceParams, response) {
-    return getTypeCacheKeys$b(luvio, response, () => keyBuilder$F(luvio, resourceParams));
+    return getTypeCacheKeys$c(luvio, response, () => keyBuilder$G(luvio, resourceParams));
 }
 function ingestSuccess$t(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$F(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$b, body);
+    const key = keyBuilder$G(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$c, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$F(),
@@ -648,13 +648,13 @@ function ingestSuccess$t(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$b(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$F(luvio, params);
+    const key = keyBuilder$G(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$b,
+        ttl: TTL$c,
         namespace: keyPrefix,
         version: VERSION$c,
-        representationName: RepresentationType$b
+        representationName: RepresentationType$c
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
@@ -688,9 +688,9 @@ function createResourceParams$B(config) {
     };
     return resourceParams;
 }
-function keyBuilder$E(luvio, config) {
+function keyBuilder$F(luvio, config) {
     const resourceParams = createResourceParams$B(config);
-    return keyBuilder$F(luvio, resourceParams);
+    return keyBuilder$G(luvio, resourceParams);
 }
 function typeCheckConfig$B(untrustedConfig) {
     const config = {};
@@ -761,7 +761,7 @@ function buildNetworkSnapshotCachePolicy$b(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$b(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$E(luvio, config),
+        recordId: keyBuilder$F(luvio, config),
         node: adapterFragment$b(luvio, config),
         variables: {},
     };
@@ -836,12 +836,12 @@ function select$E(luvio, params) {
     return select$H();
 }
 function getResponseCacheKeys$A(luvio, resourceParams, response) {
-    return getTypeCacheKeys$c(luvio, response);
+    return getTypeCacheKeys$d(luvio, response);
 }
 function ingestSuccess$s(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$a(luvio, body);
-    luvio.storeIngest(key, ingest$c, body);
+    const key = keyBuilderFromType$b(luvio, body);
+    luvio.storeIngest(key, ingest$d, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$E(),
@@ -995,7 +995,7 @@ function validate$k(obj, path = 'ContextAttributeInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$a = 30000;
+const TTL$b = 30000;
 const VERSION$b = "6cc8b3ef582709be7344b57cb6370543";
 function validate$j(obj, path = 'ContextAttributeTagRepresentation') {
     const v_error = (() => {
@@ -1036,17 +1036,17 @@ function validate$j(obj, path = 'ContextAttributeTagRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$a = 'ContextAttributeTagRepresentation';
-function keyBuilder$D(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$a + ':' + config.id;
+const RepresentationType$b = 'ContextAttributeTagRepresentation';
+function keyBuilder$E(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$b + ':' + config.id;
 }
-function keyBuilderFromType$9(luvio, object) {
+function keyBuilderFromType$a(luvio, object) {
     const keyParams = {
         id: object.contextAttributeTagId
     };
-    return keyBuilder$D(luvio, keyParams);
+    return keyBuilder$E(luvio, keyParams);
 }
-function normalize$a(input, existing, path, luvio, store, timestamp) {
+function normalize$b(input, existing, path, luvio, store, timestamp) {
     return input;
 }
 const select$D = function ContextAttributeTagRepresentationSelect() {
@@ -1136,17 +1136,17 @@ function equals$b(existing, incoming) {
 function deepFreeze$8(input) {
     ObjectFreeze(input);
 }
-const ingest$a = function ContextAttributeTagRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$b = function ContextAttributeTagRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$j(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$9(luvio, input);
+    const key = keyBuilderFromType$a(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$a;
-    let incomingRecord = normalize$a(input, store.readEntry(key), {
+    const ttlToUse = TTL$b;
+    let incomingRecord = normalize$b(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
@@ -1160,25 +1160,25 @@ const ingest$a = function ContextAttributeTagRepresentationIngest(input, path, l
             ttl: ttlToUse,
             namespace: "IndustriesContext",
             version: VERSION$b,
-            representationName: RepresentationType$a,
+            representationName: RepresentationType$b,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$a(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$b(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$9(luvio, input);
+    const rootKey = keyBuilderFromType$a(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$a,
+        representationName: RepresentationType$b,
         mergeable: false
     });
     return rootKeySet;
 }
 
-const TTL$9 = 30000;
+const TTL$a = 30000;
 const VERSION$a = "6b4da990bdb17903fdbabc1d342a8acb";
 function validate$i(obj, path = 'ContextAttributeRepresentation') {
     const v_error = (() => {
@@ -1246,23 +1246,23 @@ function validate$i(obj, path = 'ContextAttributeRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$9 = 'ContextAttributeRepresentation';
-function keyBuilder$C(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$9 + ':' + config.id;
+const RepresentationType$a = 'ContextAttributeRepresentation';
+function keyBuilder$D(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$a + ':' + config.id;
 }
-function keyBuilderFromType$8(luvio, object) {
+function keyBuilderFromType$9(luvio, object) {
     const keyParams = {
         id: object.contextAttributeId
     };
-    return keyBuilder$C(luvio, keyParams);
+    return keyBuilder$D(luvio, keyParams);
 }
-function normalize$9(input, existing, path, luvio, store, timestamp) {
+function normalize$a(input, existing, path, luvio, store, timestamp) {
     const input_attributeTags = input.attributeTags;
     const input_attributeTags_id = path.fullPath + '__attributeTags';
     for (let i = 0; i < input_attributeTags.length; i++) {
         const input_attributeTags_item = input_attributeTags[i];
         let input_attributeTags_item_id = input_attributeTags_id + '__' + i;
-        input_attributeTags[i] = ingest$a(input_attributeTags_item, {
+        input_attributeTags[i] = ingest$b(input_attributeTags_item, {
             fullPath: input_attributeTags_item_id,
             propertyName: i,
             parent: {
@@ -1411,17 +1411,17 @@ function deepFreeze$7(input) {
     ObjectFreeze(input_attributeTags);
     ObjectFreeze(input);
 }
-const ingest$9 = function ContextAttributeRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$a = function ContextAttributeRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$i(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$8(luvio, input);
+    const key = keyBuilderFromType$9(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$9;
-    let incomingRecord = normalize$9(input, store.readEntry(key), {
+    const ttlToUse = TTL$a;
+    let incomingRecord = normalize$a(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
@@ -1435,24 +1435,24 @@ const ingest$9 = function ContextAttributeRepresentationIngest(input, path, luvi
             ttl: ttlToUse,
             namespace: "IndustriesContext",
             version: VERSION$a,
-            representationName: RepresentationType$9,
+            representationName: RepresentationType$a,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$9(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$a(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$8(luvio, input);
+    const rootKey = keyBuilderFromType$9(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$9,
+        representationName: RepresentationType$a,
         mergeable: false
     });
     const input_attributeTags_length = input.attributeTags.length;
     for (let i = 0; i < input_attributeTags_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$a(luvio, input.attributeTags[i]));
+        rootKeySet.merge(getTypeCacheKeys$b(luvio, input.attributeTags[i]));
     }
     return rootKeySet;
 }
@@ -1461,12 +1461,12 @@ function select$B(luvio, params) {
     return select$C();
 }
 function getResponseCacheKeys$z(luvio, resourceParams, response) {
-    return getTypeCacheKeys$9(luvio, response);
+    return getTypeCacheKeys$a(luvio, response);
 }
 function ingestSuccess$r(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$8(luvio, body);
-    luvio.storeIngest(key, ingest$9, body);
+    const key = keyBuilderFromType$9(luvio, body);
+    luvio.storeIngest(key, ingest$a, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$B(),
@@ -1555,23 +1555,23 @@ const createContextAttributeAdapterFactory = (luvio) => {
     };
 };
 
-function keyBuilder$B(luvio, params) {
-    return keyBuilder$C(luvio, {
+function keyBuilder$C(luvio, params) {
+    return keyBuilder$D(luvio, {
         id: params.urlParams.contextAttributeId
     });
 }
 function getResponseCacheKeys$y(luvio, resourceParams) {
-    const key = keyBuilder$B(luvio, resourceParams);
+    const key = keyBuilder$C(luvio, resourceParams);
     const cacheKeyMap = new StoreKeyMap();
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
-        representationName: RepresentationType$9,
+        representationName: RepresentationType$a,
         mergeable: false
     });
     return cacheKeyMap;
 }
 function evictSuccess$7(luvio, resourceParams) {
-    const key = keyBuilder$B(luvio, resourceParams);
+    const key = keyBuilder$C(luvio, resourceParams);
     luvio.storeEvict(key);
 }
 function createResourceRequest$y(config) {
@@ -1653,18 +1653,18 @@ const deleteContextAttributeAdapterFactory = (luvio) => {
 function select$A(luvio, params) {
     return select$C();
 }
-function keyBuilder$A(luvio, params) {
-    return keyBuilder$C(luvio, {
+function keyBuilder$B(luvio, params) {
+    return keyBuilder$D(luvio, {
         id: params.urlParams.contextAttributeId
     });
 }
 function getResponseCacheKeys$x(luvio, resourceParams, response) {
-    return getTypeCacheKeys$9(luvio, response);
+    return getTypeCacheKeys$a(luvio, response);
 }
 function ingestSuccess$q(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$A(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$9, body);
+    const key = keyBuilder$B(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$a, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$A(),
@@ -1678,13 +1678,13 @@ function ingestSuccess$q(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$a(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$A(luvio, params);
+    const key = keyBuilder$B(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$9,
+        ttl: TTL$a,
         namespace: keyPrefix,
         version: VERSION$a,
-        representationName: RepresentationType$9
+        representationName: RepresentationType$a
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
@@ -1718,9 +1718,9 @@ function createResourceParams$x(config) {
     };
     return resourceParams;
 }
-function keyBuilder$z(luvio, config) {
+function keyBuilder$A(luvio, config) {
     const resourceParams = createResourceParams$x(config);
-    return keyBuilder$A(luvio, resourceParams);
+    return keyBuilder$B(luvio, resourceParams);
 }
 function typeCheckConfig$x(untrustedConfig) {
     const config = {};
@@ -1791,7 +1791,7 @@ function buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$z(luvio, config),
+        recordId: keyBuilder$A(luvio, config),
         node: adapterFragment$a(luvio, config),
         variables: {},
     };
@@ -1815,12 +1815,12 @@ function select$z(luvio, params) {
     return select$C();
 }
 function getResponseCacheKeys$w(luvio, resourceParams, response) {
-    return getTypeCacheKeys$9(luvio, response);
+    return getTypeCacheKeys$a(luvio, response);
 }
 function ingestSuccess$p(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$8(luvio, body);
-    luvio.storeIngest(key, ingest$9, body);
+    const key = keyBuilderFromType$9(luvio, body);
+    luvio.storeIngest(key, ingest$a, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$z(),
@@ -1916,7 +1916,7 @@ const updateContextAttributeAdapterFactory = (luvio) => {
     };
 };
 
-const TTL$8 = 10000;
+const TTL$9 = 10000;
 const VERSION$9 = "5d7bd042347d78b8c394239649db8f46";
 function validate$h(obj, path = 'ContextAttributeTagListRepresentation') {
     const v_error = (() => {
@@ -1950,8 +1950,8 @@ function validate$h(obj, path = 'ContextAttributeTagListRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$8 = 'ContextAttributeTagListRepresentation';
-function normalize$8(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$9 = 'ContextAttributeTagListRepresentation';
+function normalize$9(input, existing, path, luvio, store, timestamp) {
     return input;
 }
 const select$y = function ContextAttributeTagListRepresentationSelect() {
@@ -1979,7 +1979,7 @@ function deepFreeze$6(input) {
     }
     ObjectFreeze(input);
 }
-const ingest$8 = function ContextAttributeTagListRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$9 = function ContextAttributeTagListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$h(input);
         if (validateError !== null) {
@@ -1988,8 +1988,8 @@ const ingest$8 = function ContextAttributeTagListRepresentationIngest(input, pat
     }
     const key = path.fullPath;
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$8;
-    let incomingRecord = normalize$8(input, store.readEntry(key), {
+    const ttlToUse = TTL$9;
+    let incomingRecord = normalize$9(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
@@ -2004,19 +2004,19 @@ const ingest$8 = function ContextAttributeTagListRepresentationIngest(input, pat
             ttl: ttlToUse,
             namespace: "IndustriesContext",
             version: VERSION$9,
-            representationName: RepresentationType$8,
+            representationName: RepresentationType$9,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$8(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$9(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$8,
+        representationName: RepresentationType$9,
         mergeable: false
     });
     return rootKeySet;
@@ -2025,16 +2025,16 @@ function getTypeCacheKeys$8(luvio, input, fullPathFactory) {
 function select$x(luvio, params) {
     return select$y();
 }
-function keyBuilder$y(luvio, params) {
+function keyBuilder$z(luvio, params) {
     return keyPrefix + '::ContextAttributeTagListRepresentation:(' + 'contextAttributeId:' + params.urlParams.contextAttributeId + ')';
 }
 function getResponseCacheKeys$v(luvio, resourceParams, response) {
-    return getTypeCacheKeys$8(luvio, response, () => keyBuilder$y(luvio, resourceParams));
+    return getTypeCacheKeys$9(luvio, response, () => keyBuilder$z(luvio, resourceParams));
 }
 function ingestSuccess$o(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$y(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$8, body);
+    const key = keyBuilder$z(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$x(),
@@ -2048,13 +2048,13 @@ function ingestSuccess$o(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$9(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$y(luvio, params);
+    const key = keyBuilder$z(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$8,
+        ttl: TTL$9,
         namespace: keyPrefix,
         version: VERSION$9,
-        representationName: RepresentationType$8
+        representationName: RepresentationType$9
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
@@ -2088,9 +2088,9 @@ function createResourceParams$v(config) {
     };
     return resourceParams;
 }
-function keyBuilder$x(luvio, config) {
+function keyBuilder$y(luvio, config) {
     const resourceParams = createResourceParams$v(config);
-    return keyBuilder$y(luvio, resourceParams);
+    return keyBuilder$z(luvio, resourceParams);
 }
 function typeCheckConfig$v(untrustedConfig) {
     const config = {};
@@ -2161,7 +2161,7 @@ function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$x(luvio, config),
+        recordId: keyBuilder$y(luvio, config),
         node: adapterFragment$9(luvio, config),
         variables: {},
     };
@@ -2213,12 +2213,12 @@ function select$w(luvio, params) {
     return select$D();
 }
 function getResponseCacheKeys$u(luvio, resourceParams, response) {
-    return getTypeCacheKeys$a(luvio, response);
+    return getTypeCacheKeys$b(luvio, response);
 }
 function ingestSuccess$n(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$9(luvio, body);
-    luvio.storeIngest(key, ingest$a, body);
+    const key = keyBuilderFromType$a(luvio, body);
+    luvio.storeIngest(key, ingest$b, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$w(),
@@ -2307,23 +2307,23 @@ const createContextAttributeTagAdapterFactory = (luvio) => {
     };
 };
 
-function keyBuilder$w(luvio, params) {
-    return keyBuilder$D(luvio, {
+function keyBuilder$x(luvio, params) {
+    return keyBuilder$E(luvio, {
         id: params.urlParams.contextAttributeTagId
     });
 }
 function getResponseCacheKeys$t(luvio, resourceParams) {
-    const key = keyBuilder$w(luvio, resourceParams);
+    const key = keyBuilder$x(luvio, resourceParams);
     const cacheKeyMap = new StoreKeyMap();
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
-        representationName: RepresentationType$a,
+        representationName: RepresentationType$b,
         mergeable: false
     });
     return cacheKeyMap;
 }
 function evictSuccess$6(luvio, resourceParams) {
-    const key = keyBuilder$w(luvio, resourceParams);
+    const key = keyBuilder$x(luvio, resourceParams);
     luvio.storeEvict(key);
 }
 function createResourceRequest$t(config) {
@@ -2405,18 +2405,18 @@ const deleteContextAttributeTagAdapterFactory = (luvio) => {
 function select$v(luvio, params) {
     return select$D();
 }
-function keyBuilder$v(luvio, params) {
-    return keyBuilder$D(luvio, {
+function keyBuilder$w(luvio, params) {
+    return keyBuilder$E(luvio, {
         id: params.urlParams.contextAttributeTagId
     });
 }
 function getResponseCacheKeys$s(luvio, resourceParams, response) {
-    return getTypeCacheKeys$a(luvio, response);
+    return getTypeCacheKeys$b(luvio, response);
 }
 function ingestSuccess$m(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$v(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$a, body);
+    const key = keyBuilder$w(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$b, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$v(),
@@ -2430,13 +2430,13 @@ function ingestSuccess$m(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$8(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$v(luvio, params);
+    const key = keyBuilder$w(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$a,
+        ttl: TTL$b,
         namespace: keyPrefix,
         version: VERSION$b,
-        representationName: RepresentationType$a
+        representationName: RepresentationType$b
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
@@ -2470,9 +2470,9 @@ function createResourceParams$s(config) {
     };
     return resourceParams;
 }
-function keyBuilder$u(luvio, config) {
+function keyBuilder$v(luvio, config) {
     const resourceParams = createResourceParams$s(config);
-    return keyBuilder$v(luvio, resourceParams);
+    return keyBuilder$w(luvio, resourceParams);
 }
 function typeCheckConfig$s(untrustedConfig) {
     const config = {};
@@ -2543,7 +2543,7 @@ function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$u(luvio, config),
+        recordId: keyBuilder$v(luvio, config),
         node: adapterFragment$8(luvio, config),
         variables: {},
     };
@@ -2567,12 +2567,12 @@ function select$u(luvio, params) {
     return select$D();
 }
 function getResponseCacheKeys$r(luvio, resourceParams, response) {
-    return getTypeCacheKeys$a(luvio, response);
+    return getTypeCacheKeys$b(luvio, response);
 }
 function ingestSuccess$l(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$9(luvio, body);
-    luvio.storeIngest(key, ingest$a, body);
+    const key = keyBuilderFromType$a(luvio, body);
+    luvio.storeIngest(key, ingest$b, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$u(),
@@ -2671,18 +2671,18 @@ const updateContextAttributeTagAdapterFactory = (luvio) => {
 function select$t(luvio, params) {
     return select$H();
 }
-function keyBuilder$t(luvio, params) {
-    return keyBuilder$G(luvio, {
+function keyBuilder$u(luvio, params) {
+    return keyBuilder$H(luvio, {
         id: params.urlParams.contextDefinitionId
     });
 }
 function getResponseCacheKeys$q(luvio, resourceParams, response) {
-    return getTypeCacheKeys$c(luvio, response);
+    return getTypeCacheKeys$d(luvio, response);
 }
 function ingestSuccess$k(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$t(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$c, body);
+    const key = keyBuilder$u(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$d, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$t(),
@@ -2696,13 +2696,13 @@ function ingestSuccess$k(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$7(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$t(luvio, params);
+    const key = keyBuilder$u(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$c,
+        ttl: TTL$d,
         namespace: keyPrefix,
         version: VERSION$d,
-        representationName: RepresentationType$c
+        representationName: RepresentationType$d
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
@@ -2736,9 +2736,9 @@ function createResourceParams$q(config) {
     };
     return resourceParams;
 }
-function keyBuilder$s(luvio, config) {
+function keyBuilder$t(luvio, config) {
     const resourceParams = createResourceParams$q(config);
-    return keyBuilder$t(luvio, resourceParams);
+    return keyBuilder$u(luvio, resourceParams);
 }
 function typeCheckConfig$q(untrustedConfig) {
     const config = {};
@@ -2809,7 +2809,7 @@ function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$s(luvio, config),
+        recordId: keyBuilder$t(luvio, config),
         node: adapterFragment$7(luvio, config),
         variables: {},
     };
@@ -2904,7 +2904,7 @@ function validate$f(obj, path = 'ContextNodeInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$7 = 30000;
+const TTL$8 = 30000;
 const VERSION$8 = "cf75cb95b2ed381500c696acf0bf903a";
 function validate$e(obj, path = 'ContextNodeRepresentation') {
     const v_error = (() => {
@@ -3001,17 +3001,17 @@ function validate$e(obj, path = 'ContextNodeRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$7 = 'ContextNodeRepresentation';
-function keyBuilder$r(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$7 + ':' + config.id;
+const RepresentationType$8 = 'ContextNodeRepresentation';
+function keyBuilder$s(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$8 + ':' + config.id;
 }
-function keyBuilderFromType$7(luvio, object) {
+function keyBuilderFromType$8(luvio, object) {
     const keyParams = {
         id: object.contextNodeId
     };
-    return keyBuilder$r(luvio, keyParams);
+    return keyBuilder$s(luvio, keyParams);
 }
-function normalize$7(input, existing, path, luvio, store, timestamp) {
+function normalize$8(input, existing, path, luvio, store, timestamp) {
     return input;
 }
 const select$s = function ContextNodeRepresentationSelect() {
@@ -3055,17 +3055,17 @@ function deepFreeze$5(input) {
     }
     ObjectFreeze(input);
 }
-const ingest$7 = function ContextNodeRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$8 = function ContextNodeRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$e(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$7(luvio, input);
+    const key = keyBuilderFromType$8(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$7;
-    let incomingRecord = normalize$7(input, store.readEntry(key), {
+    const ttlToUse = TTL$8;
+    let incomingRecord = normalize$8(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
@@ -3080,19 +3080,19 @@ const ingest$7 = function ContextNodeRepresentationIngest(input, path, luvio, st
             ttl: ttlToUse,
             namespace: "IndustriesContext",
             version: VERSION$8,
-            representationName: RepresentationType$7,
+            representationName: RepresentationType$8,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$7(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$8(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$7(luvio, input);
+    const rootKey = keyBuilderFromType$8(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$7,
+        representationName: RepresentationType$8,
         mergeable: false
     });
     return rootKeySet;
@@ -3102,12 +3102,12 @@ function select$r(luvio, params) {
     return select$s();
 }
 function getResponseCacheKeys$p(luvio, resourceParams, response) {
-    return getTypeCacheKeys$7(luvio, response);
+    return getTypeCacheKeys$8(luvio, response);
 }
 function ingestSuccess$j(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$7(luvio, body);
-    luvio.storeIngest(key, ingest$7, body);
+    const key = keyBuilderFromType$8(luvio, body);
+    luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$r(),
@@ -3196,23 +3196,23 @@ const createContextNodeAdapterFactory = (luvio) => {
     };
 };
 
-function keyBuilder$q(luvio, params) {
-    return keyBuilder$r(luvio, {
+function keyBuilder$r(luvio, params) {
+    return keyBuilder$s(luvio, {
         id: params.urlParams.contextNodeId
     });
 }
 function getResponseCacheKeys$o(luvio, resourceParams) {
-    const key = keyBuilder$q(luvio, resourceParams);
+    const key = keyBuilder$r(luvio, resourceParams);
     const cacheKeyMap = new StoreKeyMap();
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
-        representationName: RepresentationType$7,
+        representationName: RepresentationType$8,
         mergeable: false
     });
     return cacheKeyMap;
 }
 function evictSuccess$5(luvio, resourceParams) {
-    const key = keyBuilder$q(luvio, resourceParams);
+    const key = keyBuilder$r(luvio, resourceParams);
     luvio.storeEvict(key);
 }
 function createResourceRequest$o(config) {
@@ -3294,18 +3294,18 @@ const deleteContextNodeAdapterFactory = (luvio) => {
 function select$q(luvio, params) {
     return select$s();
 }
-function keyBuilder$p(luvio, params) {
-    return keyBuilder$r(luvio, {
+function keyBuilder$q(luvio, params) {
+    return keyBuilder$s(luvio, {
         id: params.urlParams.contextNodeId
     });
 }
 function getResponseCacheKeys$n(luvio, resourceParams, response) {
-    return getTypeCacheKeys$7(luvio, response);
+    return getTypeCacheKeys$8(luvio, response);
 }
 function ingestSuccess$i(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$p(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$7, body);
+    const key = keyBuilder$q(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$q(),
@@ -3319,13 +3319,13 @@ function ingestSuccess$i(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$6(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$p(luvio, params);
+    const key = keyBuilder$q(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$7,
+        ttl: TTL$8,
         namespace: keyPrefix,
         version: VERSION$8,
-        representationName: RepresentationType$7
+        representationName: RepresentationType$8
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
@@ -3359,9 +3359,9 @@ function createResourceParams$n(config) {
     };
     return resourceParams;
 }
-function keyBuilder$o(luvio, config) {
+function keyBuilder$p(luvio, config) {
     const resourceParams = createResourceParams$n(config);
-    return keyBuilder$p(luvio, resourceParams);
+    return keyBuilder$q(luvio, resourceParams);
 }
 function typeCheckConfig$n(untrustedConfig) {
     const config = {};
@@ -3432,7 +3432,7 @@ function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$o(luvio, config),
+        recordId: keyBuilder$p(luvio, config),
         node: adapterFragment$6(luvio, config),
         variables: {},
     };
@@ -3456,12 +3456,12 @@ function select$p(luvio, params) {
     return select$s();
 }
 function getResponseCacheKeys$m(luvio, resourceParams, response) {
-    return getTypeCacheKeys$7(luvio, response);
+    return getTypeCacheKeys$8(luvio, response);
 }
 function ingestSuccess$h(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$7(luvio, body);
-    luvio.storeIngest(key, ingest$7, body);
+    const key = keyBuilderFromType$8(luvio, body);
+    luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$p(),
@@ -3578,7 +3578,7 @@ function validate$d(obj, path = 'ContextAttributeListInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$6 = 10000;
+const TTL$7 = 10000;
 const VERSION$7 = "6bbfbaed88b7bd009de04a1002ab7022";
 function validate$c(obj, path = 'ContextAttributeListRepresentation') {
     const v_error = (() => {
@@ -3612,23 +3612,23 @@ function validate$c(obj, path = 'ContextAttributeListRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$6 = 'ContextAttributeListRepresentation';
-function keyBuilder$n(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$6 + ':' + config.id;
+const RepresentationType$7 = 'ContextAttributeListRepresentation';
+function keyBuilder$o(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$7 + ':' + config.id;
 }
-function keyBuilderFromType$6(luvio, object) {
+function keyBuilderFromType$7(luvio, object) {
     const keyParams = {
         id: object.contextNodeId
     };
-    return keyBuilder$n(luvio, keyParams);
+    return keyBuilder$o(luvio, keyParams);
 }
-function normalize$6(input, existing, path, luvio, store, timestamp) {
+function normalize$7(input, existing, path, luvio, store, timestamp) {
     const input_attributes = input.attributes;
     const input_attributes_id = path.fullPath + '__attributes';
     for (let i = 0; i < input_attributes.length; i++) {
         const input_attributes_item = input_attributes[i];
         let input_attributes_item_id = input_attributes_id + '__' + i;
-        input_attributes[i] = ingest$9(input_attributes_item, {
+        input_attributes[i] = ingest$a(input_attributes_item, {
             fullPath: input_attributes_item_id,
             propertyName: i,
             parent: {
@@ -3696,17 +3696,17 @@ function equals$7(existing, incoming) {
     }
     return true;
 }
-const ingest$6 = function ContextAttributeListRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$7 = function ContextAttributeListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$c(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$6(luvio, input);
+    const key = keyBuilderFromType$7(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$6;
-    let incomingRecord = normalize$6(input, store.readEntry(key), {
+    const ttlToUse = TTL$7;
+    let incomingRecord = normalize$7(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
@@ -3720,24 +3720,24 @@ const ingest$6 = function ContextAttributeListRepresentationIngest(input, path,
             ttl: ttlToUse,
             namespace: "IndustriesContext",
             version: VERSION$7,
-            representationName: RepresentationType$6,
+            representationName: RepresentationType$7,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$6(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$7(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$6(luvio, input);
+    const rootKey = keyBuilderFromType$7(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$6,
+        representationName: RepresentationType$7,
         mergeable: false
     });
     const input_attributes_length = input.attributes.length;
     for (let i = 0; i < input_attributes_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$9(luvio, input.attributes[i]));
+        rootKeySet.merge(getTypeCacheKeys$a(luvio, input.attributes[i]));
     }
     return rootKeySet;
 }
@@ -3746,12 +3746,12 @@ function select$n(luvio, params) {
     return select$o();
 }
 function getResponseCacheKeys$l(luvio, resourceParams, response) {
-    return getTypeCacheKeys$6(luvio, response);
+    return getTypeCacheKeys$7(luvio, response);
 }
 function ingestSuccess$g(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$6(luvio, body);
-    luvio.storeIngest(key, ingest$6, body);
+    const key = keyBuilderFromType$7(luvio, body);
+    luvio.storeIngest(key, ingest$7, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$n(),
@@ -3910,7 +3910,8 @@ function validate$b(obj, path = 'ContextDefinitionVersionInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const VERSION$6 = "0198779900530411087eeae93310fd16";
+const TTL$6 = 30000;
+const VERSION$6 = "02db6b8f5f8aa0607d9f784e68a6d867";
 function validate$a(obj, path = 'ContextAttrHydrationDetailRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -3966,120 +3967,31 @@ function validate$a(obj, path = 'ContextAttrHydrationDetailRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
+const RepresentationType$6 = 'ContextAttrHydrationDetailRepresentation';
+function keyBuilder$n(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$6 + ':' + config.id;
+}
+function keyBuilderFromType$6(luvio, object) {
+    const keyParams = {
+        id: object.contextAttrHydrationDetailId
+    };
+    return keyBuilder$n(luvio, keyParams);
+}
+function normalize$6(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
 const select$m = function ContextAttrHydrationDetailRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$6,
         private: [],
-        selections: [
-            {
-                name: 'childDetails',
-                kind: 'Object',
-                // any
-            },
-            {
-                name: 'contextAttrHydrationDetailId',
-                kind: 'Scalar'
-            },
-            {
-                name: 'isSuccess',
-                kind: 'Scalar',
-                required: false
-            },
-            {
-                name: 'parentMappingAttributeId',
-                kind: 'Scalar',
-                required: false
-            },
-            {
-                name: 'queryAttribute',
-                kind: 'Scalar',
-                required: false
-            },
-            {
-                name: 'sObjectDomain',
-                kind: 'Scalar',
-                required: false
-            }
-        ]
+        opaque: true
     };
 };
 function equals$6(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_contextAttrHydrationDetailId = existing.contextAttrHydrationDetailId;
-    const incoming_contextAttrHydrationDetailId = incoming.contextAttrHydrationDetailId;
-    if (!(existing_contextAttrHydrationDetailId === incoming_contextAttrHydrationDetailId)) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
-    const existing_parentMappingAttributeId = existing.parentMappingAttributeId;
-    const incoming_parentMappingAttributeId = incoming.parentMappingAttributeId;
-    // if at least one of these optionals is defined
-    if (existing_parentMappingAttributeId !== undefined || incoming_parentMappingAttributeId !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_parentMappingAttributeId === undefined || incoming_parentMappingAttributeId === undefined) {
-            return false;
-        }
-        if (!(existing_parentMappingAttributeId === incoming_parentMappingAttributeId)) {
-            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;
-        }
-    }
-    const existing_sObjectDomain = existing.sObjectDomain;
-    const incoming_sObjectDomain = incoming.sObjectDomain;
-    // if at least one of these optionals is defined
-    if (existing_sObjectDomain !== undefined || incoming_sObjectDomain !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_sObjectDomain === undefined || incoming_sObjectDomain === undefined) {
-            return false;
-        }
-        if (!(existing_sObjectDomain === incoming_sObjectDomain)) {
-            return false;
-        }
-    }
-    const existing_childDetails = existing.childDetails;
-    const incoming_childDetails = incoming.childDetails;
-    // if at least one of these optionals is defined
-    if (existing_childDetails !== undefined || incoming_childDetails !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_childDetails === undefined || incoming_childDetails === undefined) {
-            return false;
-        }
-        const equals_childDetails_items = equalsArray(existing_childDetails, incoming_childDetails, (existing_childDetails_item, incoming_childDetails_item) => {
-            if (JSONStringify(incoming_childDetails_item) !== JSONStringify(existing_childDetails_item)) {
-                return false;
-            }
-        });
-        if (equals_childDetails_items === false) {
-            return false;
-        }
-    }
     return true;
 }
 function deepFreeze$4(input) {
@@ -4093,29 +4005,66 @@ function deepFreeze$4(input) {
     }
     ObjectFreeze(input);
 }
+const ingest$6 = function ContextAttrHydrationDetailRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$a(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$6(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$6;
+    let incomingRecord = normalize$6(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    deepFreeze$4(input);
+    if (existingRecord === undefined || equals$6(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "IndustriesContext",
+            version: VERSION$6,
+            representationName: RepresentationType$6,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$6(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$6(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$6,
+        mergeable: false
+    });
+    return rootKeySet;
+}
 
 const TTL$5 = 30000;
-const VERSION$5 = "9b6f863445ba97e3cf74be37379582e1";
+const VERSION$5 = "91b3e2f0127810505fdabe203d64bdbc";
 function validate$9(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 + '")');
         }
-        if (obj.contextAttrHydrationDetailList !== undefined) {
-            const obj_contextAttrHydrationDetailList = obj.contextAttrHydrationDetailList;
-            const path_contextAttrHydrationDetailList = path + '.contextAttrHydrationDetailList';
-            if (!ArrayIsArray(obj_contextAttrHydrationDetailList)) {
-                return new TypeError('Expected "array" but received "' + typeof obj_contextAttrHydrationDetailList + '" (at "' + path_contextAttrHydrationDetailList + '")');
-            }
-            for (let i = 0; i < obj_contextAttrHydrationDetailList.length; i++) {
-                const obj_contextAttrHydrationDetailList_item = obj_contextAttrHydrationDetailList[i];
-                const path_contextAttrHydrationDetailList_item = path_contextAttrHydrationDetailList + '[' + i + ']';
-                const referencepath_contextAttrHydrationDetailList_itemValidationError = validate$a(obj_contextAttrHydrationDetailList_item, path_contextAttrHydrationDetailList_item);
-                if (referencepath_contextAttrHydrationDetailList_itemValidationError !== null) {
-                    let message = 'Object doesn\'t match ContextAttrHydrationDetailRepresentation (at "' + path_contextAttrHydrationDetailList_item + '")\n';
-                    message += referencepath_contextAttrHydrationDetailList_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)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_contextAttrHydrationDetailList + '" (at "' + path_contextAttrHydrationDetailList + '")');
+        }
+        for (let i = 0; i < obj_contextAttrHydrationDetailList.length; i++) {
+            const obj_contextAttrHydrationDetailList_item = obj_contextAttrHydrationDetailList[i];
+            const path_contextAttrHydrationDetailList_item = path_contextAttrHydrationDetailList + '[' + i + ']';
+            if (typeof obj_contextAttrHydrationDetailList_item !== 'object') {
+                return new TypeError('Expected "object" but received "' + typeof obj_contextAttrHydrationDetailList_item + '" (at "' + path_contextAttrHydrationDetailList_item + '")');
             }
         }
         const obj_contextAttributeId = obj.contextAttributeId;
@@ -4159,10 +4108,25 @@ function keyBuilderFromType$5(luvio, object) {
     return keyBuilder$m(luvio, keyParams);
 }
 function normalize$5(input, existing, path, luvio, store, timestamp) {
+    const input_contextAttrHydrationDetailList = input.contextAttrHydrationDetailList;
+    const input_contextAttrHydrationDetailList_id = path.fullPath + '__contextAttrHydrationDetailList';
+    for (let i = 0; i < input_contextAttrHydrationDetailList.length; i++) {
+        const input_contextAttrHydrationDetailList_item = input_contextAttrHydrationDetailList[i];
+        let input_contextAttrHydrationDetailList_item_id = input_contextAttrHydrationDetailList_id + '__' + i;
+        input_contextAttrHydrationDetailList[i] = ingest$6(input_contextAttrHydrationDetailList_item, {
+            fullPath: input_contextAttrHydrationDetailList_item_id,
+            propertyName: i,
+            parent: {
+                data: input,
+                key: path.fullPath,
+                existing: existing,
+            },
+            ttl: path.ttl
+        }, luvio, store);
+    }
     return input;
 }
 const select$l = function ContextAttributeMappingRepresentationSelect() {
-    const { selections: ContextAttrHydrationDetailRepresentation__selections, opaque: ContextAttrHydrationDetailRepresentation__opaque, } = select$m();
     return {
         kind: 'Fragment',
         version: VERSION$5,
@@ -4170,10 +4134,9 @@ const select$l = function ContextAttributeMappingRepresentationSelect() {
         selections: [
             {
                 name: 'contextAttrHydrationDetailList',
-                kind: 'Object',
+                kind: 'Link',
                 plural: true,
-                selections: ContextAttrHydrationDetailRepresentation__selections,
-                required: false
+                fragment: select$m()
             },
             {
                 name: 'contextAttributeId',
@@ -4235,33 +4198,23 @@ function equals$5(existing, incoming) {
     }
     const existing_contextAttrHydrationDetailList = existing.contextAttrHydrationDetailList;
     const incoming_contextAttrHydrationDetailList = incoming.contextAttrHydrationDetailList;
-    // if at least one of these optionals is defined
-    if (existing_contextAttrHydrationDetailList !== undefined || incoming_contextAttrHydrationDetailList !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_contextAttrHydrationDetailList === undefined || incoming_contextAttrHydrationDetailList === undefined) {
-            return false;
-        }
-        const equals_contextAttrHydrationDetailList_items = equalsArray(existing_contextAttrHydrationDetailList, incoming_contextAttrHydrationDetailList, (existing_contextAttrHydrationDetailList_item, incoming_contextAttrHydrationDetailList_item) => {
-            if (!(equals$6(existing_contextAttrHydrationDetailList_item, incoming_contextAttrHydrationDetailList_item))) {
-                return false;
-            }
-        });
-        if (equals_contextAttrHydrationDetailList_items === false) {
+    const equals_contextAttrHydrationDetailList_items = equalsArray(existing_contextAttrHydrationDetailList, incoming_contextAttrHydrationDetailList, (existing_contextAttrHydrationDetailList_item, incoming_contextAttrHydrationDetailList_item) => {
+        if (!(existing_contextAttrHydrationDetailList_item.__ref === incoming_contextAttrHydrationDetailList_item.__ref)) {
             return false;
         }
+    });
+    if (equals_contextAttrHydrationDetailList_items === false) {
+        return false;
     }
     return true;
 }
 function deepFreeze$3(input) {
     const input_contextAttrHydrationDetailList = input.contextAttrHydrationDetailList;
-    if (input_contextAttrHydrationDetailList !== undefined) {
-        for (let i = 0; i < input_contextAttrHydrationDetailList.length; i++) {
-            const input_contextAttrHydrationDetailList_item = input_contextAttrHydrationDetailList[i];
-            deepFreeze$4(input_contextAttrHydrationDetailList_item);
-        }
-        ObjectFreeze(input_contextAttrHydrationDetailList);
+    for (let i = 0; i < input_contextAttrHydrationDetailList.length; i++) {
+        const input_contextAttrHydrationDetailList_item = input_contextAttrHydrationDetailList[i];
+        deepFreeze$4(input_contextAttrHydrationDetailList_item);
     }
+    ObjectFreeze(input_contextAttrHydrationDetailList);
     ObjectFreeze(input);
 }
 const ingest$5 = function ContextAttributeMappingRepresentationIngest(input, path, luvio, store, timestamp) {
@@ -4279,7 +4232,7 @@ const ingest$5 = function ContextAttributeMappingRepresentationIngest(input, pat
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
-    });
+    }, luvio, store);
     if (existingRecord === undefined || equals$5(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
@@ -4303,6 +4256,10 @@ function getTypeCacheKeys$5(luvio, input, fullPathFactory) {
         representationName: RepresentationType$5,
         mergeable: false
     });
+    const input_contextAttrHydrationDetailList_length = input.contextAttrHydrationDetailList.length;
+    for (let i = 0; i < input_contextAttrHydrationDetailList_length; i++) {
+        rootKeySet.merge(getTypeCacheKeys$6(luvio, input.contextAttrHydrationDetailList[i]));
+    }
     return rootKeySet;
 }
 
@@ -5914,12 +5871,12 @@ function select$c(luvio, params) {
     return select$H();
 }
 function getResponseCacheKeys$e(luvio, resourceParams, response) {
-    return getTypeCacheKeys$c(luvio, response);
+    return getTypeCacheKeys$d(luvio, response);
 }
 function ingestSuccess$b(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$a(luvio, body);
-    luvio.storeIngest(key, ingest$c, body);
+    const key = keyBuilderFromType$b(luvio, body);
+    luvio.storeIngest(key, ingest$d, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$c(),