@salesforce/lds-adapters-industries-cpq 1.280.0 → 1.282.0

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

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$b, typeCheckConfig as typeCheckConfig$b, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$1 } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$d, typeCheckConfig as typeCheckConfig$d, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$1 } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -93,7 +93,7 @@ function createLink(ref) {
     };
 }
 
-function validate$L(obj, path = 'PreviewInputRepresentation') {
+function validate$M(obj, path = 'PreviewInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -153,8 +153,8 @@ function validate$L(obj, path = 'PreviewInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const VERSION$h = "16ee7e6452adaa7a1a8e36a1238a4b85";
-function validate$K(obj, path = 'CpqMessageOutputRepresentation') {
+const VERSION$i = "16ee7e6452adaa7a1a8e36a1238a4b85";
+function validate$L(obj, path = 'CpqMessageOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -190,10 +190,10 @@ function validate$K(obj, path = 'CpqMessageOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$s = function CpqMessageOutputRepresentationSelect() {
+const select$v = function CpqMessageOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$h,
+        version: VERSION$i,
         private: [],
         selections: [
             {
@@ -219,7 +219,7 @@ const select$s = function CpqMessageOutputRepresentationSelect() {
         ]
     };
 };
-function equals$h(existing, incoming) {
+function equals$i(existing, incoming) {
     const existing_code = existing.code;
     const incoming_code = incoming.code;
     // if at least one of these optionals is defined
@@ -275,8 +275,8 @@ function equals$h(existing, incoming) {
     return true;
 }
 
-const VERSION$g = "2927abd89d0e76012000aa604b583b6d";
-function validate$J(obj, path = 'ApiStatusOutputRepresentation') {
+const VERSION$h = "2927abd89d0e76012000aa604b583b6d";
+function validate$K(obj, path = 'ApiStatusOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -290,7 +290,7 @@ function validate$J(obj, path = 'ApiStatusOutputRepresentation') {
             for (let i = 0; i < obj_messages.length; i++) {
                 const obj_messages_item = obj_messages[i];
                 const path_messages_item = path_messages + '[' + i + ']';
-                const referencepath_messages_itemValidationError = validate$K(obj_messages_item, path_messages_item);
+                const referencepath_messages_itemValidationError = validate$L(obj_messages_item, path_messages_item);
                 if (referencepath_messages_itemValidationError !== null) {
                     let message = 'Object doesn\'t match CpqMessageOutputRepresentation (at "' + path_messages_item + '")\n';
                     message += referencepath_messages_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -313,11 +313,11 @@ function validate$J(obj, path = 'ApiStatusOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$r = function ApiStatusOutputRepresentationSelect() {
-    const { selections: CpqMessageOutputRepresentation__selections, opaque: CpqMessageOutputRepresentation__opaque, } = select$s();
+const select$u = function ApiStatusOutputRepresentationSelect() {
+    const { selections: CpqMessageOutputRepresentation__selections, opaque: CpqMessageOutputRepresentation__opaque, } = select$v();
     return {
         kind: 'Fragment',
-        version: VERSION$g,
+        version: VERSION$h,
         private: [],
         selections: [
             {
@@ -339,7 +339,7 @@ const select$r = function ApiStatusOutputRepresentationSelect() {
         ]
     };
 };
-function equals$g(existing, incoming) {
+function equals$h(existing, incoming) {
     const existing_statusCode = existing.statusCode;
     const incoming_statusCode = incoming.statusCode;
     if (!(existing_statusCode === incoming_statusCode)) {
@@ -368,7 +368,7 @@ function equals$g(existing, incoming) {
             return false;
         }
         const equals_messages_items = equalsArray(existing_messages, incoming_messages, (existing_messages_item, incoming_messages_item) => {
-            if (!(equals$h(existing_messages_item, incoming_messages_item))) {
+            if (!(equals$i(existing_messages_item, incoming_messages_item))) {
                 return false;
             }
         });
@@ -379,16 +379,16 @@ function equals$g(existing, incoming) {
     return true;
 }
 
-const TTL$7 = 1000;
-const VERSION$f = "0dec45c09b18523023bddd12cc806a3d";
-function validate$I(obj, path = 'CpqBaseListOutputRepresentation') {
+const TTL$8 = 1000;
+const VERSION$g = "0dec45c09b18523023bddd12cc806a3d";
+function validate$J(obj, path = 'CpqBaseListOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
         const obj_apiStatus = obj.apiStatus;
         const path_apiStatus = path + '.apiStatus';
-        const referencepath_apiStatusValidationError = validate$J(obj_apiStatus, path_apiStatus);
+        const referencepath_apiStatusValidationError = validate$K(obj_apiStatus, path_apiStatus);
         if (referencepath_apiStatusValidationError !== null) {
             let message = 'Object doesn\'t match ApiStatusOutputRepresentation (at "' + path_apiStatus + '")\n';
             message += referencepath_apiStatusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -442,68 +442,68 @@ function validate$I(obj, path = 'CpqBaseListOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$8 = 'CpqBaseListOutputRepresentation';
-function keyBuilder$9(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$8 + ':' + config.message;
+const RepresentationType$9 = 'CpqBaseListOutputRepresentation';
+function keyBuilder$a(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$9 + ':' + config.message;
 }
-function keyBuilderFromType$7(luvio, object) {
+function keyBuilderFromType$8(luvio, object) {
     const keyParams = {
         message: object.apiStatus.statusCode
     };
-    return keyBuilder$9(luvio, keyParams);
+    return keyBuilder$a(luvio, keyParams);
 }
-function normalize$8(input, existing, path, luvio, store, timestamp) {
+function normalize$9(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$q = function CpqBaseListOutputRepresentationSelect() {
+const select$t = function CpqBaseListOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$f,
+        version: VERSION$g,
         private: [],
         opaque: true
     };
 };
-function equals$f(existing, incoming) {
+function equals$g(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$8 = function CpqBaseListOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$9 = function CpqBaseListOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$I(input);
+        const validateError = validate$J(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$7(luvio, input);
-    const ttlToUse = TTL$7;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$8, "cpq", VERSION$f, RepresentationType$8, equals$f);
+    const key = keyBuilderFromType$8(luvio, input);
+    const ttlToUse = TTL$8;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$9, "cpq", VERSION$g, RepresentationType$9, equals$g);
     return createLink(key);
 };
-function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
     // 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$8,
+        representationName: RepresentationType$9,
         mergeable: false
     });
 }
 
-function select$p(luvio, params) {
-    return select$q();
+function select$s(luvio, params) {
+    return select$t();
 }
-function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$8(storeKeyMap, luvio, response);
+function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$9(storeKeyMap, luvio, response);
 }
-function ingestSuccess$a(luvio, resourceParams, response) {
+function ingestSuccess$c(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$7(luvio, body);
-    luvio.storeIngest(key, ingest$8, body);
+    const key = keyBuilderFromType$8(luvio, body);
+    luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$p(),
+        node: select$s(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -514,7 +514,7 @@ function ingestSuccess$a(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$a(config) {
+function createResourceRequest$c(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -528,45 +528,45 @@ function createResourceRequest$a(config) {
     };
 }
 
-const adapterName$a = 'preview';
+const adapterName$c = 'preview';
 const preview_ConfigPropertyMetadata = [
     generateParamConfigMetadata('previewInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const preview_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, preview_ConfigPropertyMetadata);
-const createResourceParams$a = /*#__PURE__*/ createResourceParams$b(preview_ConfigPropertyMetadata);
-function typeCheckConfig$a(untrustedConfig) {
+const preview_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, preview_ConfigPropertyMetadata);
+const createResourceParams$c = /*#__PURE__*/ createResourceParams$d(preview_ConfigPropertyMetadata);
+function typeCheckConfig$c(untrustedConfig) {
     const config = {};
     const untrustedConfig_previewInput = untrustedConfig.previewInput;
-    const referencePreviewInputRepresentationValidationError = validate$L(untrustedConfig_previewInput);
+    const referencePreviewInputRepresentationValidationError = validate$M(untrustedConfig_previewInput);
     if (referencePreviewInputRepresentationValidationError === null) {
         config.previewInput = untrustedConfig_previewInput;
     }
     return config;
 }
-function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$a(untrustedConfig);
+    const config = typeCheckConfig$c(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$a(luvio, config, options) {
-    const resourceParams = createResourceParams$a(config);
-    const request = createResourceRequest$a(resourceParams);
+function buildNetworkSnapshot$c(luvio, config, options) {
+    const resourceParams = createResourceParams$c(config);
+    const request = createResourceRequest$c(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$a(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$c(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -576,16 +576,16 @@ function buildNetworkSnapshot$a(luvio, config, options) {
 }
 const previewAdapterFactory = (luvio) => {
     return function preview(untrustedConfig) {
-        const config = validateAdapterConfig$a(untrustedConfig, preview_ConfigPropertyNames);
+        const config = validateAdapterConfig$c(untrustedConfig, preview_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "preview"');
         }
-        return buildNetworkSnapshot$a(luvio, config);
+        return buildNetworkSnapshot$c(luvio, config);
     };
 };
 
-function validate$H(obj, path = 'ProductListInputRepresentation') {
+function validate$I(obj, path = 'ProductListInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -681,19 +681,19 @@ function validate$H(obj, path = 'ProductListInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function select$o(luvio, params) {
-    return select$q();
+function select$r(luvio, params) {
+    return select$t();
 }
-function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$8(storeKeyMap, luvio, response);
+function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$9(storeKeyMap, luvio, response);
 }
-function ingestSuccess$9(luvio, resourceParams, response) {
+function ingestSuccess$b(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$7(luvio, body);
-    luvio.storeIngest(key, ingest$8, body);
+    const key = keyBuilderFromType$8(luvio, body);
+    luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$o(),
+        node: select$r(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -704,7 +704,7 @@ function ingestSuccess$9(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$9(config) {
+function createResourceRequest$b(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -718,45 +718,45 @@ function createResourceRequest$9(config) {
     };
 }
 
-const adapterName$9 = 'productList';
+const adapterName$b = 'productList';
 const productList_ConfigPropertyMetadata = [
     generateParamConfigMetadata('requestBody', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const productList_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, productList_ConfigPropertyMetadata);
-const createResourceParams$9 = /*#__PURE__*/ createResourceParams$b(productList_ConfigPropertyMetadata);
-function typeCheckConfig$9(untrustedConfig) {
+const productList_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, productList_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$d(productList_ConfigPropertyMetadata);
+function typeCheckConfig$b(untrustedConfig) {
     const config = {};
     const untrustedConfig_requestBody = untrustedConfig.requestBody;
-    const referenceProductListInputRepresentationValidationError = validate$H(untrustedConfig_requestBody);
+    const referenceProductListInputRepresentationValidationError = validate$I(untrustedConfig_requestBody);
     if (referenceProductListInputRepresentationValidationError === null) {
         config.requestBody = untrustedConfig_requestBody;
     }
     return config;
 }
-function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$9(untrustedConfig);
+    const config = typeCheckConfig$b(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$9(luvio, config, options) {
-    const resourceParams = createResourceParams$9(config);
-    const request = createResourceRequest$9(resourceParams);
+function buildNetworkSnapshot$b(luvio, config, options) {
+    const resourceParams = createResourceParams$b(config);
+    const request = createResourceRequest$b(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$9(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$b(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$b(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -766,16 +766,16 @@ function buildNetworkSnapshot$9(luvio, config, options) {
 }
 const productListAdapterFactory = (luvio) => {
     return function productList(untrustedConfig) {
-        const config = validateAdapterConfig$9(untrustedConfig, productList_ConfigPropertyNames);
+        const config = validateAdapterConfig$b(untrustedConfig, productList_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "productList"');
         }
-        return buildNetworkSnapshot$9(luvio, config);
+        return buildNetworkSnapshot$b(luvio, config);
     };
 };
 
-function validate$G(obj, path = 'SearchProductsInputRepresentation') {
+function validate$H(obj, path = 'SearchProductsInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -873,19 +873,19 @@ function validate$G(obj, path = 'SearchProductsInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function select$n(luvio, params) {
-    return select$q();
+function select$q(luvio, params) {
+    return select$t();
 }
-function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$8(storeKeyMap, luvio, response);
+function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$9(storeKeyMap, luvio, response);
 }
-function ingestSuccess$8(luvio, resourceParams, response) {
+function ingestSuccess$a(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$7(luvio, body);
-    luvio.storeIngest(key, ingest$8, body);
+    const key = keyBuilderFromType$8(luvio, body);
+    luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$n(),
+        node: select$q(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -896,7 +896,7 @@ function ingestSuccess$8(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$8(config) {
+function createResourceRequest$a(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -910,45 +910,45 @@ function createResourceRequest$8(config) {
     };
 }
 
-const adapterName$8 = 'searchProductList';
+const adapterName$a = 'searchProductList';
 const searchProductList_ConfigPropertyMetadata = [
     generateParamConfigMetadata('requestBody', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const searchProductList_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, searchProductList_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$b(searchProductList_ConfigPropertyMetadata);
-function typeCheckConfig$8(untrustedConfig) {
+const searchProductList_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, searchProductList_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$d(searchProductList_ConfigPropertyMetadata);
+function typeCheckConfig$a(untrustedConfig) {
     const config = {};
     const untrustedConfig_requestBody = untrustedConfig.requestBody;
-    const referenceSearchProductsInputRepresentationValidationError = validate$G(untrustedConfig_requestBody);
+    const referenceSearchProductsInputRepresentationValidationError = validate$H(untrustedConfig_requestBody);
     if (referenceSearchProductsInputRepresentationValidationError === null) {
         config.requestBody = untrustedConfig_requestBody;
     }
     return config;
 }
-function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$8(untrustedConfig);
+    const config = typeCheckConfig$a(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$8(luvio, config, options) {
-    const resourceParams = createResourceParams$8(config);
-    const request = createResourceRequest$8(resourceParams);
+function buildNetworkSnapshot$a(luvio, config, options) {
+    const resourceParams = createResourceParams$a(config);
+    const request = createResourceRequest$a(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$8(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$a(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -958,16 +958,16 @@ function buildNetworkSnapshot$8(luvio, config, options) {
 }
 const searchProductListAdapterFactory = (luvio) => {
     return function searchProductList(untrustedConfig) {
-        const config = validateAdapterConfig$8(untrustedConfig, searchProductList_ConfigPropertyNames);
+        const config = validateAdapterConfig$a(untrustedConfig, searchProductList_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "searchProductList"');
         }
-        return buildNetworkSnapshot$8(luvio, config);
+        return buildNetworkSnapshot$a(luvio, config);
     };
 };
 
-function validate$F(obj, path = 'ProductDetailsInputRepresentation') {
+function validate$G(obj, path = 'ProductDetailsInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1023,16 +1023,16 @@ function validate$F(obj, path = 'ProductDetailsInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$6 = 1000;
-const VERSION$e = "6e77a7585bc4d094518eb201471d85ea";
-function validate$E(obj, path = 'CpqBaseDetailsOutputRepresentation') {
+const TTL$7 = 1000;
+const VERSION$f = "6e77a7585bc4d094518eb201471d85ea";
+function validate$F(obj, path = 'CpqBaseDetailsOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
         const obj_apiStatus = obj.apiStatus;
         const path_apiStatus = path + '.apiStatus';
-        const referencepath_apiStatusValidationError = validate$J(obj_apiStatus, path_apiStatus);
+        const referencepath_apiStatusValidationError = validate$K(obj_apiStatus, path_apiStatus);
         if (referencepath_apiStatusValidationError !== null) {
             let message = 'Object doesn\'t match ApiStatusOutputRepresentation (at "' + path_apiStatus + '")\n';
             message += referencepath_apiStatusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1051,68 +1051,68 @@ function validate$E(obj, path = 'CpqBaseDetailsOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$7 = 'CpqBaseDetailsOutputRepresentation';
-function keyBuilder$8(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$7 + ':' + config.message;
+const RepresentationType$8 = 'CpqBaseDetailsOutputRepresentation';
+function keyBuilder$9(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$8 + ':' + config.message;
 }
-function keyBuilderFromType$6(luvio, object) {
+function keyBuilderFromType$7(luvio, object) {
     const keyParams = {
         message: object.apiStatus.statusCode
     };
-    return keyBuilder$8(luvio, keyParams);
+    return keyBuilder$9(luvio, keyParams);
 }
-function normalize$7(input, existing, path, luvio, store, timestamp) {
+function normalize$8(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$m = function CpqBaseDetailsOutputRepresentationSelect() {
+const select$p = function CpqBaseDetailsOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$e,
+        version: VERSION$f,
         private: [],
         opaque: true
     };
 };
-function equals$e(existing, incoming) {
+function equals$f(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$7 = function CpqBaseDetailsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$8 = function CpqBaseDetailsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$E(input);
+        const validateError = validate$F(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$6(luvio, input);
-    const ttlToUse = TTL$6;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$7, "cpq", VERSION$e, RepresentationType$7, equals$e);
+    const key = keyBuilderFromType$7(luvio, input);
+    const ttlToUse = TTL$7;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$8, "cpq", VERSION$f, RepresentationType$8, equals$f);
     return createLink(key);
 };
-function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
     // 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$7,
+        representationName: RepresentationType$8,
         mergeable: false
     });
 }
 
-function select$l(luvio, params) {
-    return select$m();
+function select$o(luvio, params) {
+    return select$p();
 }
-function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$7(storeKeyMap, luvio, response);
+function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$8(storeKeyMap, luvio, response);
 }
-function ingestSuccess$7(luvio, resourceParams, response) {
+function ingestSuccess$9(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$6(luvio, body);
-    luvio.storeIngest(key, ingest$7, body);
+    const key = keyBuilderFromType$7(luvio, body);
+    luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$l(),
+        node: select$o(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1123,7 +1123,7 @@ function ingestSuccess$7(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$7(config) {
+function createResourceRequest$9(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -1137,47 +1137,47 @@ function createResourceRequest$7(config) {
     };
 }
 
-const adapterName$7 = 'productDetails';
+const adapterName$9 = 'productDetails';
 const productDetails_ConfigPropertyMetadata = [
     generateParamConfigMetadata('productId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('requestBody', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const productDetails_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, productDetails_ConfigPropertyMetadata);
-const createResourceParams$7 = /*#__PURE__*/ createResourceParams$b(productDetails_ConfigPropertyMetadata);
-function typeCheckConfig$7(untrustedConfig) {
+const productDetails_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, productDetails_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$d(productDetails_ConfigPropertyMetadata);
+function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, productDetails_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, productDetails_ConfigPropertyMetadata);
     const untrustedConfig_requestBody = untrustedConfig.requestBody;
-    const referenceProductDetailsInputRepresentationValidationError = validate$F(untrustedConfig_requestBody);
+    const referenceProductDetailsInputRepresentationValidationError = validate$G(untrustedConfig_requestBody);
     if (referenceProductDetailsInputRepresentationValidationError === null) {
         config.requestBody = untrustedConfig_requestBody;
     }
     return config;
 }
-function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$7(untrustedConfig);
+    const config = typeCheckConfig$9(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$7(luvio, config, options) {
-    const resourceParams = createResourceParams$7(config);
-    const request = createResourceRequest$7(resourceParams);
+function buildNetworkSnapshot$9(luvio, config, options) {
+    const resourceParams = createResourceParams$9(config);
+    const request = createResourceRequest$9(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$7(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$9(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$7(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1187,16 +1187,16 @@ function buildNetworkSnapshot$7(luvio, config, options) {
 }
 const productDetailsAdapterFactory = (luvio) => {
     return function productDetails(untrustedConfig) {
-        const config = validateAdapterConfig$7(untrustedConfig, productDetails_ConfigPropertyNames);
+        const config = validateAdapterConfig$9(untrustedConfig, productDetails_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "productDetails"');
         }
-        return buildNetworkSnapshot$7(luvio, config);
+        return buildNetworkSnapshot$9(luvio, config);
     };
 };
 
-function validate$D(obj, path = 'CreateCartInputRepresentation') {
+function validate$E(obj, path = 'CreateCartInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1265,16 +1265,16 @@ function validate$D(obj, path = 'CreateCartInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$5 = 1000;
-const VERSION$d = "1f730145ab6b9f6b4d070b5eade57b4c";
-function validate$C(obj, path = 'CreateCartOutputRepresentation') {
+const TTL$6 = 1000;
+const VERSION$e = "1f730145ab6b9f6b4d070b5eade57b4c";
+function validate$D(obj, path = 'CreateCartOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
         const obj_apiStatus = obj.apiStatus;
         const path_apiStatus = path + '.apiStatus';
-        const referencepath_apiStatusValidationError = validate$J(obj_apiStatus, path_apiStatus);
+        const referencepath_apiStatusValidationError = validate$K(obj_apiStatus, path_apiStatus);
         if (referencepath_apiStatusValidationError !== null) {
             let message = 'Object doesn\'t match ApiStatusOutputRepresentation (at "' + path_apiStatus + '")\n';
             message += referencepath_apiStatusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1290,68 +1290,68 @@ function validate$C(obj, path = 'CreateCartOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$6 = 'CreateCartOutputRepresentation';
-function keyBuilder$7(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$6 + ':' + config.message;
+const RepresentationType$7 = 'CreateCartOutputRepresentation';
+function keyBuilder$8(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$7 + ':' + config.message;
 }
-function keyBuilderFromType$5(luvio, object) {
+function keyBuilderFromType$6(luvio, object) {
     const keyParams = {
         message: object.apiStatus.statusCode
     };
-    return keyBuilder$7(luvio, keyParams);
+    return keyBuilder$8(luvio, keyParams);
 }
-function normalize$6(input, existing, path, luvio, store, timestamp) {
+function normalize$7(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$k = function CreateCartOutputRepresentationSelect() {
+const select$n = function CreateCartOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$d,
+        version: VERSION$e,
         private: [],
         opaque: true
     };
 };
-function equals$d(existing, incoming) {
+function equals$e(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$6 = function CreateCartOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$7 = function CreateCartOutputRepresentationIngest(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$5(luvio, input);
-    const ttlToUse = TTL$5;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$6, "cpq", VERSION$d, RepresentationType$6, equals$d);
+    const key = keyBuilderFromType$6(luvio, input);
+    const ttlToUse = TTL$6;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$7, "cpq", VERSION$e, RepresentationType$7, equals$e);
     return createLink(key);
 };
-function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$5(luvio, input);
+    const rootKey = keyBuilderFromType$6(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$6,
+        representationName: RepresentationType$7,
         mergeable: false
     });
 }
 
-function select$j(luvio, params) {
-    return select$k();
+function select$m(luvio, params) {
+    return select$n();
 }
-function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$6(storeKeyMap, luvio, response);
+function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$7(storeKeyMap, luvio, response);
 }
-function ingestSuccess$6(luvio, resourceParams, response) {
+function ingestSuccess$8(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$5(luvio, body);
-    luvio.storeIngest(key, ingest$6, body);
+    const key = keyBuilderFromType$6(luvio, body);
+    luvio.storeIngest(key, ingest$7, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$j(),
+        node: select$m(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1362,7 +1362,7 @@ function ingestSuccess$6(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$6(config) {
+function createResourceRequest$8(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -1376,45 +1376,45 @@ function createResourceRequest$6(config) {
     };
 }
 
-const adapterName$6 = 'createCart';
+const adapterName$8 = 'createCart';
 const createCart_ConfigPropertyMetadata = [
     generateParamConfigMetadata('createCartRequestPayload', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createCart_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, createCart_ConfigPropertyMetadata);
-const createResourceParams$6 = /*#__PURE__*/ createResourceParams$b(createCart_ConfigPropertyMetadata);
-function typeCheckConfig$6(untrustedConfig) {
+const createCart_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, createCart_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$d(createCart_ConfigPropertyMetadata);
+function typeCheckConfig$8(untrustedConfig) {
     const config = {};
     const untrustedConfig_createCartRequestPayload = untrustedConfig.createCartRequestPayload;
-    const referenceCreateCartInputRepresentationValidationError = validate$D(untrustedConfig_createCartRequestPayload);
+    const referenceCreateCartInputRepresentationValidationError = validate$E(untrustedConfig_createCartRequestPayload);
     if (referenceCreateCartInputRepresentationValidationError === null) {
         config.createCartRequestPayload = untrustedConfig_createCartRequestPayload;
     }
     return config;
 }
-function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$6(untrustedConfig);
+    const config = typeCheckConfig$8(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$6(luvio, config, options) {
-    const resourceParams = createResourceParams$6(config);
-    const request = createResourceRequest$6(resourceParams);
+function buildNetworkSnapshot$8(luvio, config, options) {
+    const resourceParams = createResourceParams$8(config);
+    const request = createResourceRequest$8(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$6(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$8(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1424,17 +1424,17 @@ function buildNetworkSnapshot$6(luvio, config, options) {
 }
 const createCartAdapterFactory = (luvio) => {
     return function createCart(untrustedConfig) {
-        const config = validateAdapterConfig$6(untrustedConfig, createCart_ConfigPropertyNames);
+        const config = validateAdapterConfig$8(untrustedConfig, createCart_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createCart"');
         }
-        return buildNetworkSnapshot$6(luvio, config);
+        return buildNetworkSnapshot$8(luvio, config);
     };
 };
 
-const VERSION$c = "c49b7c37c117b93f62b9696af8a68cdc";
-function validate$B(obj, path = 'AttributePickListValueOutputRepresentation') {
+const VERSION$d = "c49b7c37c117b93f62b9696af8a68cdc";
+function validate$C(obj, path = 'AttributePickListValueOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1512,10 +1512,10 @@ function validate$B(obj, path = 'AttributePickListValueOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$i = function AttributePickListValueOutputRepresentationSelect() {
+const select$l = function AttributePickListValueOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$c,
+        version: VERSION$d,
         private: [],
         selections: [
             {
@@ -1571,7 +1571,7 @@ const select$i = function AttributePickListValueOutputRepresentationSelect() {
         ]
     };
 };
-function equals$c(existing, incoming) {
+function equals$d(existing, incoming) {
     const existing_isBooleanValue = existing.isBooleanValue;
     const incoming_isBooleanValue = incoming.isBooleanValue;
     // if at least one of these optionals is defined
@@ -1705,8 +1705,8 @@ function equals$c(existing, incoming) {
     return true;
 }
 
-const VERSION$b = "78e748e628eb86e688eec1678db105d8";
-function validate$A(obj, path = 'AttributePickListOutputRepresentation') {
+const VERSION$c = "78e748e628eb86e688eec1678db105d8";
+function validate$B(obj, path = 'AttributePickListOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1755,7 +1755,7 @@ function validate$A(obj, path = 'AttributePickListOutputRepresentation') {
             for (let i = 0; i < obj_values.length; i++) {
                 const obj_values_item = obj_values[i];
                 const path_values_item = path_values + '[' + i + ']';
-                const referencepath_values_itemValidationError = validate$B(obj_values_item, path_values_item);
+                const referencepath_values_itemValidationError = validate$C(obj_values_item, path_values_item);
                 if (referencepath_values_itemValidationError !== null) {
                     let message = 'Object doesn\'t match AttributePickListValueOutputRepresentation (at "' + path_values_item + '")\n';
                     message += referencepath_values_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1766,11 +1766,11 @@ function validate$A(obj, path = 'AttributePickListOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$h = function AttributePickListOutputRepresentationSelect() {
-    const { selections: AttributePickListValueOutputRepresentation__selections, opaque: AttributePickListValueOutputRepresentation__opaque, } = select$i();
+const select$k = function AttributePickListOutputRepresentationSelect() {
+    const { selections: AttributePickListValueOutputRepresentation__selections, opaque: AttributePickListValueOutputRepresentation__opaque, } = select$l();
     return {
         kind: 'Fragment',
-        version: VERSION$b,
+        version: VERSION$c,
         private: [],
         selections: [
             {
@@ -1808,7 +1808,7 @@ const select$h = function AttributePickListOutputRepresentationSelect() {
         ]
     };
 };
-function equals$b(existing, incoming) {
+function equals$c(existing, incoming) {
     const existing_code = existing.code;
     const incoming_code = incoming.code;
     // if at least one of these optionals is defined
@@ -1884,7 +1884,7 @@ function equals$b(existing, incoming) {
             return false;
         }
         const equals_values_items = equalsArray(existing_values, incoming_values, (existing_values_item, incoming_values_item) => {
-            if (!(equals$c(existing_values_item, incoming_values_item))) {
+            if (!(equals$d(existing_values_item, incoming_values_item))) {
                 return false;
             }
         });
@@ -1895,8 +1895,8 @@ function equals$b(existing, incoming) {
     return true;
 }
 
-const VERSION$a = "2c33aa6ac6bc77bf88ac3e6acc944750";
-function validate$z(obj, path = 'ProductAttributeOutputRepresentation') {
+const VERSION$b = "d28c7f18b84bf1e8232287039825a85b";
+function validate$A(obj, path = 'ProductAttributeOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1918,7 +1918,7 @@ function validate$z(obj, path = 'ProductAttributeOutputRepresentation') {
         if (obj.attributePickList !== undefined) {
             const obj_attributePickList = obj.attributePickList;
             const path_attributePickList = path + '.attributePickList';
-            const referencepath_attributePickListValidationError = validate$A(obj_attributePickList, path_attributePickList);
+            const referencepath_attributePickListValidationError = validate$B(obj_attributePickList, path_attributePickList);
             if (referencepath_attributePickListValidationError !== null) {
                 let message = 'Object doesn\'t match AttributePickListOutputRepresentation (at "' + path_attributePickList + '")\n';
                 message += referencepath_attributePickListValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1960,6 +1960,13 @@ function validate$z(obj, path = 'ProductAttributeOutputRepresentation') {
                 return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
             }
         }
+        if (obj.developerName !== undefined) {
+            const obj_developerName = obj.developerName;
+            const path_developerName = path + '.developerName';
+            if (typeof obj_developerName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+            }
+        }
         if (obj.displayType !== undefined) {
             const obj_displayType = obj.displayType;
             const path_displayType = path + '.displayType';
@@ -2096,11 +2103,11 @@ function validate$z(obj, path = 'ProductAttributeOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$g = function ProductAttributeOutputRepresentationSelect() {
-    const { selections: AttributePickListOutputRepresentation__selections, opaque: AttributePickListOutputRepresentation__opaque, } = select$h();
+const select$j = function ProductAttributeOutputRepresentationSelect() {
+    const { selections: AttributePickListOutputRepresentation__selections, opaque: AttributePickListOutputRepresentation__opaque, } = select$k();
     return {
         kind: 'Fragment',
-        version: VERSION$a,
+        version: VERSION$b,
         private: [],
         selections: [
             {
@@ -2144,6 +2151,11 @@ const select$g = function ProductAttributeOutputRepresentationSelect() {
                 kind: 'Scalar',
                 required: false
             },
+            {
+                name: 'developerName',
+                kind: 'Scalar',
+                required: false
+            },
             {
                 name: 'displayType',
                 kind: 'Scalar',
@@ -2242,7 +2254,7 @@ const select$g = function ProductAttributeOutputRepresentationSelect() {
         ]
     };
 };
-function equals$a(existing, incoming) {
+function equals$b(existing, incoming) {
     const existing_hidden = existing.hidden;
     const incoming_hidden = incoming.hidden;
     // if at least one of these optionals is defined
@@ -2438,6 +2450,19 @@ function equals$a(existing, incoming) {
             return false;
         }
     }
+    const existing_developerName = existing.developerName;
+    const incoming_developerName = incoming.developerName;
+    // if at least one of these optionals is defined
+    if (existing_developerName !== undefined || incoming_developerName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_developerName === undefined || incoming_developerName === undefined) {
+            return false;
+        }
+        if (!(existing_developerName === incoming_developerName)) {
+            return false;
+        }
+    }
     const existing_displayType = existing.displayType;
     const incoming_displayType = incoming.displayType;
     // if at least one of these optionals is defined
@@ -2590,15 +2615,15 @@ function equals$a(existing, incoming) {
         if (existing_attributePickList === undefined || incoming_attributePickList === undefined) {
             return false;
         }
-        if (!(equals$b(existing_attributePickList, incoming_attributePickList))) {
+        if (!(equals$c(existing_attributePickList, incoming_attributePickList))) {
             return false;
         }
     }
     return true;
 }
 
-const VERSION$9 = "63ca2614b6879bfb4df068438d7e78ec";
-function validate$y(obj, path = 'AttributeCategoryOutputRepresentation') {
+const VERSION$a = "63ca2614b6879bfb4df068438d7e78ec";
+function validate$z(obj, path = 'AttributeCategoryOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2640,7 +2665,7 @@ function validate$y(obj, path = 'AttributeCategoryOutputRepresentation') {
             for (let i = 0; i < obj_records.length; i++) {
                 const obj_records_item = obj_records[i];
                 const path_records_item = path_records + '[' + i + ']';
-                const referencepath_records_itemValidationError = validate$z(obj_records_item, path_records_item);
+                const referencepath_records_itemValidationError = validate$A(obj_records_item, path_records_item);
                 if (referencepath_records_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ProductAttributeOutputRepresentation (at "' + path_records_item + '")\n';
                     message += referencepath_records_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2672,11 +2697,11 @@ function validate$y(obj, path = 'AttributeCategoryOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$f = function AttributeCategoryOutputRepresentationSelect() {
-    const { selections: ProductAttributeOutputRepresentation__selections, opaque: ProductAttributeOutputRepresentation__opaque, } = select$g();
+const select$i = function AttributeCategoryOutputRepresentationSelect() {
+    const { selections: ProductAttributeOutputRepresentation__selections, opaque: ProductAttributeOutputRepresentation__opaque, } = select$j();
     return {
         kind: 'Fragment',
-        version: VERSION$9,
+        version: VERSION$a,
         private: [],
         selections: [
             {
@@ -2724,7 +2749,7 @@ const select$f = function AttributeCategoryOutputRepresentationSelect() {
         ]
     };
 };
-function equals$9(existing, incoming) {
+function equals$a(existing, incoming) {
     const existing_totalSize = existing.totalSize;
     const incoming_totalSize = incoming.totalSize;
     // if at least one of these optionals is defined
@@ -2826,7 +2851,7 @@ function equals$9(existing, incoming) {
             return false;
         }
         const equals_records_items = equalsArray(existing_records, incoming_records, (existing_records_item, incoming_records_item) => {
-            if (!(equals$a(existing_records_item, incoming_records_item))) {
+            if (!(equals$b(existing_records_item, incoming_records_item))) {
                 return false;
             }
         });
@@ -2837,8 +2862,8 @@ function equals$9(existing, incoming) {
     return true;
 }
 
-const VERSION$8 = "a59ef129f333de8bbfe140f39144b415";
-function validate$x(obj, path = 'CartItemOutputRepresentation') {
+const VERSION$9 = "a59ef129f333de8bbfe140f39144b415";
+function validate$y(obj, path = 'CartItemOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2852,7 +2877,7 @@ function validate$x(obj, path = 'CartItemOutputRepresentation') {
             for (let i = 0; i < obj_attributeCategories.length; i++) {
                 const obj_attributeCategories_item = obj_attributeCategories[i];
                 const path_attributeCategories_item = path_attributeCategories + '[' + i + ']';
-                const referencepath_attributeCategories_itemValidationError = validate$y(obj_attributeCategories_item, path_attributeCategories_item);
+                const referencepath_attributeCategories_itemValidationError = validate$z(obj_attributeCategories_item, path_attributeCategories_item);
                 if (referencepath_attributeCategories_itemValidationError !== null) {
                     let message = 'Object doesn\'t match AttributeCategoryOutputRepresentation (at "' + path_attributeCategories_item + '")\n';
                     message += referencepath_attributeCategories_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2869,7 +2894,7 @@ function validate$x(obj, path = 'CartItemOutputRepresentation') {
             for (let i = 0; i < obj_attributes.length; i++) {
                 const obj_attributes_item = obj_attributes[i];
                 const path_attributes_item = path_attributes + '[' + i + ']';
-                const referencepath_attributes_itemValidationError = validate$z(obj_attributes_item, path_attributes_item);
+                const referencepath_attributes_itemValidationError = validate$A(obj_attributes_item, path_attributes_item);
                 if (referencepath_attributes_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ProductAttributeOutputRepresentation (at "' + path_attributes_item + '")\n';
                     message += referencepath_attributes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2931,12 +2956,12 @@ function validate$x(obj, path = 'CartItemOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$e = function CartItemOutputRepresentationSelect() {
-    const { selections: AttributeCategoryOutputRepresentation__selections, opaque: AttributeCategoryOutputRepresentation__opaque, } = select$f();
-    const { selections: ProductAttributeOutputRepresentation__selections, opaque: ProductAttributeOutputRepresentation__opaque, } = select$g();
+const select$h = function CartItemOutputRepresentationSelect() {
+    const { selections: AttributeCategoryOutputRepresentation__selections, opaque: AttributeCategoryOutputRepresentation__opaque, } = select$i();
+    const { selections: ProductAttributeOutputRepresentation__selections, opaque: ProductAttributeOutputRepresentation__opaque, } = select$j();
     return {
         kind: 'Fragment',
-        version: VERSION$8,
+        version: VERSION$9,
         private: [],
         selections: [
             {
@@ -3001,7 +3026,7 @@ const select$e = function CartItemOutputRepresentationSelect() {
         ]
     };
 };
-function equals$8(existing, incoming) {
+function equals$9(existing, incoming) {
     const existing_cartItemId = existing.cartItemId;
     const incoming_cartItemId = incoming.cartItemId;
     // if at least one of these optionals is defined
@@ -3129,7 +3154,7 @@ function equals$8(existing, incoming) {
             return false;
         }
         const equals_attributeCategories_items = equalsArray(existing_attributeCategories, incoming_attributeCategories, (existing_attributeCategories_item, incoming_attributeCategories_item) => {
-            if (!(equals$9(existing_attributeCategories_item, incoming_attributeCategories_item))) {
+            if (!(equals$a(existing_attributeCategories_item, incoming_attributeCategories_item))) {
                 return false;
             }
         });
@@ -3147,7 +3172,7 @@ function equals$8(existing, incoming) {
             return false;
         }
         const equals_attributes_items = equalsArray(existing_attributes, incoming_attributes, (existing_attributes_item, incoming_attributes_item) => {
-            if (!(equals$a(existing_attributes_item, incoming_attributes_item))) {
+            if (!(equals$b(existing_attributes_item, incoming_attributes_item))) {
                 return false;
             }
         });
@@ -3158,8 +3183,8 @@ function equals$8(existing, incoming) {
     return true;
 }
 
-const VERSION$7 = "dbbe0e43dcf8f1d5334798bb12acca37";
-function validate$w(obj, path = 'CartItemsOutputRepresentation') {
+const VERSION$8 = "dbbe0e43dcf8f1d5334798bb12acca37";
+function validate$x(obj, path = 'CartItemsOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3173,7 +3198,7 @@ function validate$w(obj, path = 'CartItemsOutputRepresentation') {
             for (let i = 0; i < obj_records.length; i++) {
                 const obj_records_item = obj_records[i];
                 const path_records_item = path_records + '[' + i + ']';
-                const referencepath_records_itemValidationError = validate$x(obj_records_item, path_records_item);
+                const referencepath_records_itemValidationError = validate$y(obj_records_item, path_records_item);
                 if (referencepath_records_itemValidationError !== null) {
                     let message = 'Object doesn\'t match CartItemOutputRepresentation (at "' + path_records_item + '")\n';
                     message += referencepath_records_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3191,11 +3216,11 @@ function validate$w(obj, path = 'CartItemsOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$d = function CartItemsOutputRepresentationSelect() {
-    const { selections: CartItemOutputRepresentation__selections, opaque: CartItemOutputRepresentation__opaque, } = select$e();
+const select$g = function CartItemsOutputRepresentationSelect() {
+    const { selections: CartItemOutputRepresentation__selections, opaque: CartItemOutputRepresentation__opaque, } = select$h();
     return {
         kind: 'Fragment',
-        version: VERSION$7,
+        version: VERSION$8,
         private: [],
         selections: [
             {
@@ -3213,7 +3238,7 @@ const select$d = function CartItemsOutputRepresentationSelect() {
         ]
     };
 };
-function equals$7(existing, incoming) {
+function equals$8(existing, incoming) {
     const existing_totalSize = existing.totalSize;
     const incoming_totalSize = incoming.totalSize;
     // if at least one of these optionals is defined
@@ -3237,7 +3262,7 @@ function equals$7(existing, incoming) {
             return false;
         }
         const equals_records_items = equalsArray(existing_records, incoming_records, (existing_records_item, incoming_records_item) => {
-            if (!(equals$8(existing_records_item, incoming_records_item))) {
+            if (!(equals$9(existing_records_item, incoming_records_item))) {
                 return false;
             }
         });
@@ -3248,8 +3273,8 @@ function equals$7(existing, incoming) {
     return true;
 }
 
-const VERSION$6 = "ce1e52694d8508b2f5239ba28287dc1e";
-function validate$v(obj, path = 'PricingTotalOutputRepresentation') {
+const VERSION$7 = "ce1e52694d8508b2f5239ba28287dc1e";
+function validate$w(obj, path = 'PricingTotalOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3281,10 +3306,10 @@ function validate$v(obj, path = 'PricingTotalOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$c = function PricingTotalOutputRepresentationSelect() {
+const select$f = function PricingTotalOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$6,
+        version: VERSION$7,
         private: [],
         selections: [
             {
@@ -3310,7 +3335,7 @@ const select$c = function PricingTotalOutputRepresentationSelect() {
         ]
     };
 };
-function equals$6(existing, incoming) {
+function equals$7(existing, incoming) {
     const existing_occurrence = existing.occurrence;
     const incoming_occurrence = incoming.occurrence;
     // if at least one of these optionals is defined
@@ -3366,15 +3391,15 @@ function equals$6(existing, incoming) {
     return true;
 }
 
-const VERSION$5 = "db83704358e5d7a3f3f3622cdd0a5114";
-function validate$u(obj, path = 'GetCartOutputRepresentation') {
+const VERSION$6 = "db83704358e5d7a3f3f3622cdd0a5114";
+function validate$v(obj, path = 'GetCartOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
         const obj_apiStatus = obj.apiStatus;
         const path_apiStatus = path + '.apiStatus';
-        const referencepath_apiStatusValidationError = validate$J(obj_apiStatus, path_apiStatus);
+        const referencepath_apiStatusValidationError = validate$K(obj_apiStatus, path_apiStatus);
         if (referencepath_apiStatusValidationError !== null) {
             let message = 'Object doesn\'t match ApiStatusOutputRepresentation (at "' + path_apiStatus + '")\n';
             message += referencepath_apiStatusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3390,7 +3415,7 @@ function validate$u(obj, path = 'GetCartOutputRepresentation') {
         if (obj.cartItems !== undefined) {
             const obj_cartItems = obj.cartItems;
             const path_cartItems = path + '.cartItems';
-            const referencepath_cartItemsValidationError = validate$w(obj_cartItems, path_cartItems);
+            const referencepath_cartItemsValidationError = validate$x(obj_cartItems, path_cartItems);
             if (referencepath_cartItemsValidationError !== null) {
                 let message = 'Object doesn\'t match CartItemsOutputRepresentation (at "' + path_cartItems + '")\n';
                 message += referencepath_cartItemsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3406,7 +3431,7 @@ function validate$u(obj, path = 'GetCartOutputRepresentation') {
             for (let i = 0; i < obj_totals.length; i++) {
                 const obj_totals_item = obj_totals[i];
                 const path_totals_item = path_totals + '[' + i + ']';
-                const referencepath_totals_itemValidationError = validate$v(obj_totals_item, path_totals_item);
+                const referencepath_totals_itemValidationError = validate$w(obj_totals_item, path_totals_item);
                 if (referencepath_totals_itemValidationError !== null) {
                     let message = 'Object doesn\'t match PricingTotalOutputRepresentation (at "' + path_totals_item + '")\n';
                     message += referencepath_totals_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3417,17 +3442,17 @@ function validate$u(obj, path = 'GetCartOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$5 = 'GetCartOutputRepresentation';
-function normalize$5(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$6 = 'GetCartOutputRepresentation';
+function normalize$6(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$b = function GetCartOutputRepresentationSelect() {
-    const { selections: ApiStatusOutputRepresentation__selections, opaque: ApiStatusOutputRepresentation__opaque, } = select$r();
-    const { selections: CartItemsOutputRepresentation__selections, opaque: CartItemsOutputRepresentation__opaque, } = select$d();
-    const { selections: PricingTotalOutputRepresentation__selections, opaque: PricingTotalOutputRepresentation__opaque, } = select$c();
+const select$e = function GetCartOutputRepresentationSelect() {
+    const { selections: ApiStatusOutputRepresentation__selections, opaque: ApiStatusOutputRepresentation__opaque, } = select$u();
+    const { selections: CartItemsOutputRepresentation__selections, opaque: CartItemsOutputRepresentation__opaque, } = select$g();
+    const { selections: PricingTotalOutputRepresentation__selections, opaque: PricingTotalOutputRepresentation__opaque, } = select$f();
     return {
         kind: 'Fragment',
-        version: VERSION$5,
+        version: VERSION$6,
         private: [],
         selections: [
             {
@@ -3456,7 +3481,7 @@ const select$b = function GetCartOutputRepresentationSelect() {
         ]
     };
 };
-function equals$5(existing, incoming) {
+function equals$6(existing, incoming) {
     const existing_cartId = existing.cartId;
     const incoming_cartId = incoming.cartId;
     // if at least one of these optionals is defined
@@ -3472,7 +3497,7 @@ function equals$5(existing, incoming) {
     }
     const existing_apiStatus = existing.apiStatus;
     const incoming_apiStatus = incoming.apiStatus;
-    if (!(equals$g(existing_apiStatus, incoming_apiStatus))) {
+    if (!(equals$h(existing_apiStatus, incoming_apiStatus))) {
         return false;
     }
     const existing_cartItems = existing.cartItems;
@@ -3484,7 +3509,7 @@ function equals$5(existing, incoming) {
         if (existing_cartItems === undefined || incoming_cartItems === undefined) {
             return false;
         }
-        if (!(equals$7(existing_cartItems, incoming_cartItems))) {
+        if (!(equals$8(existing_cartItems, incoming_cartItems))) {
             return false;
         }
     }
@@ -3498,7 +3523,7 @@ function equals$5(existing, incoming) {
             return false;
         }
         const equals_totals_items = equalsArray(existing_totals, incoming_totals, (existing_totals_item, incoming_totals_item) => {
-            if (!(equals$6(existing_totals_item, incoming_totals_item))) {
+            if (!(equals$7(existing_totals_item, incoming_totals_item))) {
                 return false;
             }
         });
@@ -3508,44 +3533,44 @@ function equals$5(existing, incoming) {
     }
     return true;
 }
-const ingest$5 = function GetCartOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$6 = function GetCartOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$u(input);
+        const validateError = validate$v(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
     const ttlToUse = path.ttl !== undefined ? path.ttl : 1000;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$5, "cpq", VERSION$5, RepresentationType$5, equals$5);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$6, "cpq", VERSION$6, RepresentationType$6, equals$6);
     return createLink(key);
 };
-function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$5,
+        representationName: RepresentationType$6,
         mergeable: false
     });
 }
 
-function select$a(luvio, params) {
-    return select$b();
+function select$d(luvio, params) {
+    return select$e();
 }
-function keyBuilder$6(luvio, params) {
+function keyBuilder$7(luvio, params) {
     return keyPrefix + '::GetCartOutputRepresentation:(' + 'cartId:' + params.urlParams.cartId + ')';
 }
-function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$5(storeKeyMap, luvio, response, () => keyBuilder$6(luvio, resourceParams));
+function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$6(storeKeyMap, luvio, response, () => keyBuilder$7(luvio, resourceParams));
 }
-function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$6(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$5, body);
+    const key = keyBuilder$7(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$6, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$a(),
+        node: select$d(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -3557,12 +3582,12 @@ function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$6(luvio, params);
+    const key = keyBuilder$7(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$5(config) {
+function createResourceRequest$7(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -3576,60 +3601,60 @@ function createResourceRequest$5(config) {
     };
 }
 
-const adapterName$5 = 'getCart';
+const adapterName$7 = 'getCart';
 const getCart_ConfigPropertyMetadata = [
     generateParamConfigMetadata('cartId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getCart_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getCart_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$b(getCart_ConfigPropertyMetadata);
-function keyBuilder$5(luvio, config) {
-    const resourceParams = createResourceParams$5(config);
-    return keyBuilder$6(luvio, resourceParams);
+const getCart_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getCart_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$d(getCart_ConfigPropertyMetadata);
+function keyBuilder$6(luvio, config) {
+    const resourceParams = createResourceParams$7(config);
+    return keyBuilder$7(luvio, resourceParams);
 }
-function typeCheckConfig$5(untrustedConfig) {
+function typeCheckConfig$7(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, getCart_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getCart_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$5(untrustedConfig);
+    const config = typeCheckConfig$7(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment(luvio, config) {
-    createResourceParams$5(config);
-    return select$a();
+    createResourceParams$7(config);
+    return select$d();
 }
 function onFetchResponseSuccess(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError(luvio, config, resourceParams, response) {
     const snapshot = ingestError(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$5(luvio, config, options) {
-    const resourceParams = createResourceParams$5(config);
-    const request = createResourceRequest$5(resourceParams);
+function buildNetworkSnapshot$7(luvio, config, options) {
+    const resourceParams = createResourceParams$7(config);
+    const request = createResourceRequest$7(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$7(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3637,23 +3662,23 @@ function buildNetworkSnapshot$5(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
+    return buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$5(luvio, config),
+        recordId: keyBuilder$6(luvio, config),
         node: adapterFragment(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getCartAdapterFactory = (luvio) => function cpq__getCart(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$5(untrustedConfig, getCart_ConfigPropertyNames);
+    const config = validateAdapterConfig$7(untrustedConfig, getCart_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -3662,7 +3687,7 @@ const getCartAdapterFactory = (luvio) => function cpq__getCart(untrustedConfig,
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
-function validate$t(obj, path = 'UpdateCartInputRepresentation') {
+function validate$u(obj, path = 'UpdateCartInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3697,7 +3722,7 @@ function validate$t(obj, path = 'UpdateCartInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$s(obj, path = 'ValidationResultOutputRepresentation') {
+function validate$t(obj, path = 'ValidationResultOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3741,7 +3766,7 @@ function validate$s(obj, path = 'ValidationResultOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$r(obj, path = 'ValidateCartOutputRepresentation') {
+function validate$s(obj, path = 'ValidateCartOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3755,7 +3780,7 @@ function validate$r(obj, path = 'ValidateCartOutputRepresentation') {
             for (let i = 0; i < obj_attributeErrors.length; i++) {
                 const obj_attributeErrors_item = obj_attributeErrors[i];
                 const path_attributeErrors_item = path_attributeErrors + '[' + i + ']';
-                const referencepath_attributeErrors_itemValidationError = validate$s(obj_attributeErrors_item, path_attributeErrors_item);
+                const referencepath_attributeErrors_itemValidationError = validate$t(obj_attributeErrors_item, path_attributeErrors_item);
                 if (referencepath_attributeErrors_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ValidationResultOutputRepresentation (at "' + path_attributeErrors_item + '")\n';
                     message += referencepath_attributeErrors_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3772,7 +3797,7 @@ function validate$r(obj, path = 'ValidateCartOutputRepresentation') {
             for (let i = 0; i < obj_breErrors.length; i++) {
                 const obj_breErrors_item = obj_breErrors[i];
                 const path_breErrors_item = path_breErrors + '[' + i + ']';
-                const referencepath_breErrors_itemValidationError = validate$s(obj_breErrors_item, path_breErrors_item);
+                const referencepath_breErrors_itemValidationError = validate$t(obj_breErrors_item, path_breErrors_item);
                 if (referencepath_breErrors_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ValidationResultOutputRepresentation (at "' + path_breErrors_item + '")\n';
                     message += referencepath_breErrors_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3789,7 +3814,7 @@ function validate$r(obj, path = 'ValidateCartOutputRepresentation') {
             for (let i = 0; i < obj_cardinalityErrors.length; i++) {
                 const obj_cardinalityErrors_item = obj_cardinalityErrors[i];
                 const path_cardinalityErrors_item = path_cardinalityErrors + '[' + i + ']';
-                const referencepath_cardinalityErrors_itemValidationError = validate$s(obj_cardinalityErrors_item, path_cardinalityErrors_item);
+                const referencepath_cardinalityErrors_itemValidationError = validate$t(obj_cardinalityErrors_item, path_cardinalityErrors_item);
                 if (referencepath_cardinalityErrors_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ValidationResultOutputRepresentation (at "' + path_cardinalityErrors_item + '")\n';
                     message += referencepath_cardinalityErrors_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3808,16 +3833,16 @@ function validate$r(obj, path = 'ValidateCartOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$4 = 1000;
-const VERSION$4 = "b0d6081a9f20773285c8aeb2e715ead3";
-function validate$q(obj, path = 'UpdateCartOutputRepresentation') {
+const TTL$5 = 1000;
+const VERSION$5 = "b0d6081a9f20773285c8aeb2e715ead3";
+function validate$r(obj, path = 'UpdateCartOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
         const obj_apiStatus = obj.apiStatus;
         const path_apiStatus = path + '.apiStatus';
-        const referencepath_apiStatusValidationError = validate$J(obj_apiStatus, path_apiStatus);
+        const referencepath_apiStatusValidationError = validate$K(obj_apiStatus, path_apiStatus);
         if (referencepath_apiStatusValidationError !== null) {
             let message = 'Object doesn\'t match ApiStatusOutputRepresentation (at "' + path_apiStatus + '")\n';
             message += referencepath_apiStatusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3825,7 +3850,7 @@ function validate$q(obj, path = 'UpdateCartOutputRepresentation') {
         }
         const obj_validationResults = obj.validationResults;
         const path_validationResults = path + '.validationResults';
-        const referencepath_validationResultsValidationError = validate$r(obj_validationResults, path_validationResults);
+        const referencepath_validationResultsValidationError = validate$s(obj_validationResults, path_validationResults);
         if (referencepath_validationResultsValidationError !== null) {
             let message = 'Object doesn\'t match ValidateCartOutputRepresentation (at "' + path_validationResults + '")\n';
             message += referencepath_validationResultsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3834,68 +3859,68 @@ function validate$q(obj, path = 'UpdateCartOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$4 = 'UpdateCartOutputRepresentation';
-function keyBuilder$4(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$4 + ':' + config.message;
+const RepresentationType$5 = 'UpdateCartOutputRepresentation';
+function keyBuilder$5(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$5 + ':' + config.message;
 }
-function keyBuilderFromType$4(luvio, object) {
+function keyBuilderFromType$5(luvio, object) {
     const keyParams = {
         message: object.apiStatus.statusCode
     };
-    return keyBuilder$4(luvio, keyParams);
+    return keyBuilder$5(luvio, keyParams);
 }
-function normalize$4(input, existing, path, luvio, store, timestamp) {
+function normalize$5(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$9 = function UpdateCartOutputRepresentationSelect() {
+const select$c = function UpdateCartOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$4,
+        version: VERSION$5,
         private: [],
         opaque: true
     };
 };
-function equals$4(existing, incoming) {
+function equals$5(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$4 = function UpdateCartOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$5 = function UpdateCartOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$q(input);
+        const validateError = validate$r(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$4(luvio, input);
-    const ttlToUse = TTL$4;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "cpq", VERSION$4, RepresentationType$4, equals$4);
+    const key = keyBuilderFromType$5(luvio, input);
+    const ttlToUse = TTL$5;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$5, "cpq", VERSION$5, RepresentationType$5, equals$5);
     return createLink(key);
 };
-function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$4(luvio, input);
+    const rootKey = keyBuilderFromType$5(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$4,
+        representationName: RepresentationType$5,
         mergeable: false
     });
 }
 
-function select$8(luvio, params) {
-    return select$9();
+function select$b(luvio, params) {
+    return select$c();
 }
-function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$4(storeKeyMap, luvio, response);
+function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$5(storeKeyMap, luvio, response);
 }
-function ingestSuccess$4(luvio, resourceParams, response) {
+function ingestSuccess$6(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$4(luvio, body);
-    luvio.storeIngest(key, ingest$4, body);
+    const key = keyBuilderFromType$5(luvio, body);
+    luvio.storeIngest(key, ingest$5, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$8(),
+        node: select$b(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3906,7 +3931,7 @@ function ingestSuccess$4(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$4(config) {
+function createResourceRequest$6(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -3920,47 +3945,47 @@ function createResourceRequest$4(config) {
     };
 }
 
-const adapterName$4 = 'updateCart';
+const adapterName$6 = 'updateCart';
 const updateCart_ConfigPropertyMetadata = [
     generateParamConfigMetadata('cartId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('requestBody', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const updateCart_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, updateCart_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$b(updateCart_ConfigPropertyMetadata);
-function typeCheckConfig$4(untrustedConfig) {
+const updateCart_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, updateCart_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$d(updateCart_ConfigPropertyMetadata);
+function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, updateCart_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, updateCart_ConfigPropertyMetadata);
     const untrustedConfig_requestBody = untrustedConfig.requestBody;
-    const referenceUpdateCartInputRepresentationValidationError = validate$t(untrustedConfig_requestBody);
+    const referenceUpdateCartInputRepresentationValidationError = validate$u(untrustedConfig_requestBody);
     if (referenceUpdateCartInputRepresentationValidationError === null) {
         config.requestBody = untrustedConfig_requestBody;
     }
     return config;
 }
-function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$4(untrustedConfig);
+    const config = typeCheckConfig$6(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$4(luvio, config, options) {
-    const resourceParams = createResourceParams$4(config);
-    const request = createResourceRequest$4(resourceParams);
+function buildNetworkSnapshot$6(luvio, config, options) {
+    const resourceParams = createResourceParams$6(config);
+    const request = createResourceRequest$6(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$4(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$6(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3970,16 +3995,16 @@ function buildNetworkSnapshot$4(luvio, config, options) {
 }
 const updateCartAdapterFactory = (luvio) => {
     return function updateCart(untrustedConfig) {
-        const config = validateAdapterConfig$4(untrustedConfig, updateCart_ConfigPropertyNames);
+        const config = validateAdapterConfig$6(untrustedConfig, updateCart_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "updateCart"');
         }
-        return buildNetworkSnapshot$4(luvio, config);
+        return buildNetworkSnapshot$6(luvio, config);
     };
 };
 
-function validate$p(obj, path = 'UpdateCartItemsInputRepresentation') {
+function validate$q(obj, path = 'UpdateCartItemsInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4016,16 +4041,16 @@ function validate$p(obj, path = 'UpdateCartItemsInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$3 = 1000;
-const VERSION$3 = "7f205594e7cf298b4bee71200afab626";
-function validate$o(obj, path = 'UpdateCartItemsOutputRepresentation') {
+const TTL$4 = 1000;
+const VERSION$4 = "7f205594e7cf298b4bee71200afab626";
+function validate$p(obj, path = 'UpdateCartItemsOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
         const obj_apiStatus = obj.apiStatus;
         const path_apiStatus = path + '.apiStatus';
-        const referencepath_apiStatusValidationError = validate$J(obj_apiStatus, path_apiStatus);
+        const referencepath_apiStatusValidationError = validate$K(obj_apiStatus, path_apiStatus);
         if (referencepath_apiStatusValidationError !== null) {
             let message = 'Object doesn\'t match ApiStatusOutputRepresentation (at "' + path_apiStatus + '")\n';
             message += referencepath_apiStatusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4041,68 +4066,68 @@ function validate$o(obj, path = 'UpdateCartItemsOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$3 = 'UpdateCartItemsOutputRepresentation';
-function keyBuilder$3(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$3 + ':' + config.message;
+const RepresentationType$4 = 'UpdateCartItemsOutputRepresentation';
+function keyBuilder$4(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$4 + ':' + config.message;
 }
-function keyBuilderFromType$3(luvio, object) {
+function keyBuilderFromType$4(luvio, object) {
     const keyParams = {
         message: object.apiStatus.statusCode
     };
-    return keyBuilder$3(luvio, keyParams);
+    return keyBuilder$4(luvio, keyParams);
 }
-function normalize$3(input, existing, path, luvio, store, timestamp) {
+function normalize$4(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$7 = function UpdateCartItemsOutputRepresentationSelect() {
+const select$a = function UpdateCartItemsOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$3,
+        version: VERSION$4,
         private: [],
         opaque: true
     };
 };
-function equals$3(existing, incoming) {
+function equals$4(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$3 = function UpdateCartItemsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$4 = function UpdateCartItemsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$o(input);
+        const validateError = validate$p(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$3(luvio, input);
-    const ttlToUse = TTL$3;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "cpq", VERSION$3, RepresentationType$3, equals$3);
+    const key = keyBuilderFromType$4(luvio, input);
+    const ttlToUse = TTL$4;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "cpq", VERSION$4, RepresentationType$4, equals$4);
     return createLink(key);
 };
-function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$3(luvio, input);
+    const rootKey = keyBuilderFromType$4(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$3,
+        representationName: RepresentationType$4,
         mergeable: false
     });
 }
 
-function select$6(luvio, params) {
-    return select$7();
+function select$9(luvio, params) {
+    return select$a();
 }
-function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$3(storeKeyMap, luvio, response);
+function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$4(storeKeyMap, luvio, response);
 }
-function ingestSuccess$3(luvio, resourceParams, response) {
+function ingestSuccess$5(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$3(luvio, body);
-    luvio.storeIngest(key, ingest$3, body);
+    const key = keyBuilderFromType$4(luvio, body);
+    luvio.storeIngest(key, ingest$4, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$6(),
+        node: select$9(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -4113,7 +4138,7 @@ function ingestSuccess$3(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$3(config) {
+function createResourceRequest$5(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -4127,47 +4152,47 @@ function createResourceRequest$3(config) {
     };
 }
 
-const adapterName$3 = 'updateCartItems';
+const adapterName$5 = 'updateCartItems';
 const updateCartItems_ConfigPropertyMetadata = [
     generateParamConfigMetadata('cartId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('requestBody', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const updateCartItems_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, updateCartItems_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$b(updateCartItems_ConfigPropertyMetadata);
-function typeCheckConfig$3(untrustedConfig) {
+const updateCartItems_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, updateCartItems_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$d(updateCartItems_ConfigPropertyMetadata);
+function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, updateCartItems_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, updateCartItems_ConfigPropertyMetadata);
     const untrustedConfig_requestBody = untrustedConfig.requestBody;
-    const referenceUpdateCartItemsInputRepresentationValidationError = validate$p(untrustedConfig_requestBody);
+    const referenceUpdateCartItemsInputRepresentationValidationError = validate$q(untrustedConfig_requestBody);
     if (referenceUpdateCartItemsInputRepresentationValidationError === null) {
         config.requestBody = untrustedConfig_requestBody;
     }
     return config;
 }
-function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$3(untrustedConfig);
+    const config = typeCheckConfig$5(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$3(luvio, config, options) {
-    const resourceParams = createResourceParams$3(config);
-    const request = createResourceRequest$3(resourceParams);
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$3(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$5(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -4177,16 +4202,16 @@ function buildNetworkSnapshot$3(luvio, config, options) {
 }
 const updateCartItemsAdapterFactory = (luvio) => {
     return function updateCartItems(untrustedConfig) {
-        const config = validateAdapterConfig$3(untrustedConfig, updateCartItems_ConfigPropertyNames);
+        const config = validateAdapterConfig$5(untrustedConfig, updateCartItems_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "updateCartItems"');
         }
-        return buildNetworkSnapshot$3(luvio, config);
+        return buildNetworkSnapshot$5(luvio, config);
     };
 };
 
-function validate$n(obj, path = 'CreateCartItemsInputRepresentation') {
+function validate$o(obj, path = 'CreateCartItemsInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4223,16 +4248,16 @@ function validate$n(obj, path = 'CreateCartItemsInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$2 = 1000;
-const VERSION$2 = "34153309b079451754e6d3fbf85bb8bd";
-function validate$m(obj, path = 'CreateCartItemsOutputRepresentation') {
+const TTL$3 = 1000;
+const VERSION$3 = "34153309b079451754e6d3fbf85bb8bd";
+function validate$n(obj, path = 'CreateCartItemsOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
         const obj_apiStatus = obj.apiStatus;
         const path_apiStatus = path + '.apiStatus';
-        const referencepath_apiStatusValidationError = validate$J(obj_apiStatus, path_apiStatus);
+        const referencepath_apiStatusValidationError = validate$K(obj_apiStatus, path_apiStatus);
         if (referencepath_apiStatusValidationError !== null) {
             let message = 'Object doesn\'t match ApiStatusOutputRepresentation (at "' + path_apiStatus + '")\n';
             message += referencepath_apiStatusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4248,68 +4273,68 @@ function validate$m(obj, path = 'CreateCartItemsOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$2 = 'CreateCartItemsOutputRepresentation';
-function keyBuilder$2(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$2 + ':' + config.message;
+const RepresentationType$3 = 'CreateCartItemsOutputRepresentation';
+function keyBuilder$3(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$3 + ':' + config.message;
 }
-function keyBuilderFromType$2(luvio, object) {
+function keyBuilderFromType$3(luvio, object) {
     const keyParams = {
         message: object.apiStatus.statusCode
     };
-    return keyBuilder$2(luvio, keyParams);
+    return keyBuilder$3(luvio, keyParams);
 }
-function normalize$2(input, existing, path, luvio, store, timestamp) {
+function normalize$3(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$5 = function CreateCartItemsOutputRepresentationSelect() {
+const select$8 = function CreateCartItemsOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$2,
+        version: VERSION$3,
         private: [],
         opaque: true
     };
 };
-function equals$2(existing, incoming) {
+function equals$3(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$2 = function CreateCartItemsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$3 = function CreateCartItemsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$m(input);
+        const validateError = validate$n(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$2(luvio, input);
-    const ttlToUse = TTL$2;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "cpq", VERSION$2, RepresentationType$2, equals$2);
+    const key = keyBuilderFromType$3(luvio, input);
+    const ttlToUse = TTL$3;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "cpq", VERSION$3, RepresentationType$3, equals$3);
     return createLink(key);
 };
-function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$2(luvio, input);
+    const rootKey = keyBuilderFromType$3(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$2,
+        representationName: RepresentationType$3,
         mergeable: false
     });
 }
 
-function select$4(luvio, params) {
-    return select$5();
+function select$7(luvio, params) {
+    return select$8();
 }
-function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$2(storeKeyMap, luvio, response);
+function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$3(storeKeyMap, luvio, response);
 }
-function ingestSuccess$2(luvio, resourceParams, response) {
+function ingestSuccess$4(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$2(luvio, body);
-    luvio.storeIngest(key, ingest$2, body);
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$3, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$4(),
+        node: select$7(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -4320,7 +4345,7 @@ function ingestSuccess$2(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$2(config) {
+function createResourceRequest$4(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -4334,47 +4359,47 @@ function createResourceRequest$2(config) {
     };
 }
 
-const adapterName$2 = 'createCartItems';
+const adapterName$4 = 'createCartItems';
 const createCartItems_ConfigPropertyMetadata = [
     generateParamConfigMetadata('cartId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('requestBody', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createCartItems_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, createCartItems_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$b(createCartItems_ConfigPropertyMetadata);
-function typeCheckConfig$2(untrustedConfig) {
+const createCartItems_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, createCartItems_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$d(createCartItems_ConfigPropertyMetadata);
+function typeCheckConfig$4(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, createCartItems_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, createCartItems_ConfigPropertyMetadata);
     const untrustedConfig_requestBody = untrustedConfig.requestBody;
-    const referenceCreateCartItemsInputRepresentationValidationError = validate$n(untrustedConfig_requestBody);
+    const referenceCreateCartItemsInputRepresentationValidationError = validate$o(untrustedConfig_requestBody);
     if (referenceCreateCartItemsInputRepresentationValidationError === null) {
         config.requestBody = untrustedConfig_requestBody;
     }
     return config;
 }
-function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$2(untrustedConfig);
+    const config = typeCheckConfig$4(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$2(luvio, config, options) {
-    const resourceParams = createResourceParams$2(config);
-    const request = createResourceRequest$2(resourceParams);
+function buildNetworkSnapshot$4(luvio, config, options) {
+    const resourceParams = createResourceParams$4(config);
+    const request = createResourceRequest$4(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$2(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$4(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -4384,16 +4409,16 @@ function buildNetworkSnapshot$2(luvio, config, options) {
 }
 const createCartItemsAdapterFactory = (luvio) => {
     return function createCartItems(untrustedConfig) {
-        const config = validateAdapterConfig$2(untrustedConfig, createCartItems_ConfigPropertyNames);
+        const config = validateAdapterConfig$4(untrustedConfig, createCartItems_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createCartItems"');
         }
-        return buildNetworkSnapshot$2(luvio, config);
+        return buildNetworkSnapshot$4(luvio, config);
     };
 };
 
-function validate$l(obj, path = 'PriceCartInputRepresentation') {
+function validate$m(obj, path = 'PriceCartInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4430,16 +4455,16 @@ function validate$l(obj, path = 'PriceCartInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$1 = 1000;
-const VERSION$1 = "b1e28ba15f534459065f2870a9dc703d";
-function validate$k(obj, path = 'CartPricingTotalOutputRepresentation') {
+const TTL$2 = 1000;
+const VERSION$2 = "b1e28ba15f534459065f2870a9dc703d";
+function validate$l(obj, path = 'CartPricingTotalOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
         const obj_apiStatus = obj.apiStatus;
         const path_apiStatus = path + '.apiStatus';
-        const referencepath_apiStatusValidationError = validate$J(obj_apiStatus, path_apiStatus);
+        const referencepath_apiStatusValidationError = validate$K(obj_apiStatus, path_apiStatus);
         if (referencepath_apiStatusValidationError !== null) {
             let message = 'Object doesn\'t match ApiStatusOutputRepresentation (at "' + path_apiStatus + '")\n';
             message += referencepath_apiStatusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4461,7 +4486,7 @@ function validate$k(obj, path = 'CartPricingTotalOutputRepresentation') {
             for (let i = 0; i < obj_cartPricingTotals.length; i++) {
                 const obj_cartPricingTotals_item = obj_cartPricingTotals[i];
                 const path_cartPricingTotals_item = path_cartPricingTotals + '[' + i + ']';
-                const referencepath_cartPricingTotals_itemValidationError = validate$v(obj_cartPricingTotals_item, path_cartPricingTotals_item);
+                const referencepath_cartPricingTotals_itemValidationError = validate$w(obj_cartPricingTotals_item, path_cartPricingTotals_item);
                 if (referencepath_cartPricingTotals_itemValidationError !== null) {
                     let message = 'Object doesn\'t match PricingTotalOutputRepresentation (at "' + path_cartPricingTotals_item + '")\n';
                     message += referencepath_cartPricingTotals_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4472,68 +4497,68 @@ function validate$k(obj, path = 'CartPricingTotalOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$1 = 'CartPricingTotalOutputRepresentation';
-function keyBuilder$1(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$1 + ':' + config.message;
+const RepresentationType$2 = 'CartPricingTotalOutputRepresentation';
+function keyBuilder$2(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$2 + ':' + config.message;
 }
-function keyBuilderFromType$1(luvio, object) {
+function keyBuilderFromType$2(luvio, object) {
     const keyParams = {
         message: object.apiStatus.statusCode
     };
-    return keyBuilder$1(luvio, keyParams);
+    return keyBuilder$2(luvio, keyParams);
 }
-function normalize$1(input, existing, path, luvio, store, timestamp) {
+function normalize$2(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$3 = function CartPricingTotalOutputRepresentationSelect() {
+const select$6 = function CartPricingTotalOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$1,
+        version: VERSION$2,
         private: [],
         opaque: true
     };
 };
-function equals$1(existing, incoming) {
+function equals$2(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$1 = function CartPricingTotalOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$2 = function CartPricingTotalOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$k(input);
+        const validateError = validate$l(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$1(luvio, input);
-    const ttlToUse = TTL$1;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "cpq", VERSION$1, RepresentationType$1, equals$1);
+    const key = keyBuilderFromType$2(luvio, input);
+    const ttlToUse = TTL$2;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "cpq", VERSION$2, RepresentationType$2, equals$2);
     return createLink(key);
 };
-function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$1(luvio, input);
+    const rootKey = keyBuilderFromType$2(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$1,
+        representationName: RepresentationType$2,
         mergeable: false
     });
 }
 
-function select$2(luvio, params) {
-    return select$3();
+function select$5(luvio, params) {
+    return select$6();
 }
-function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$1(storeKeyMap, luvio, response);
+function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response);
 }
-function ingestSuccess$1(luvio, resourceParams, response) {
+function ingestSuccess$3(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$1(luvio, body);
-    luvio.storeIngest(key, ingest$1, body);
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$2, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$2(),
+        node: select$5(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -4544,7 +4569,7 @@ function ingestSuccess$1(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$1(config) {
+function createResourceRequest$3(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -4558,47 +4583,47 @@ function createResourceRequest$1(config) {
     };
 }
 
-const adapterName$1 = 'priceCart';
+const adapterName$3 = 'priceCart';
 const priceCart_ConfigPropertyMetadata = [
     generateParamConfigMetadata('cartId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('requestBody', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const priceCart_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, priceCart_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$b(priceCart_ConfigPropertyMetadata);
-function typeCheckConfig$1(untrustedConfig) {
+const priceCart_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, priceCart_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$d(priceCart_ConfigPropertyMetadata);
+function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$b(untrustedConfig, config, priceCart_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, priceCart_ConfigPropertyMetadata);
     const untrustedConfig_requestBody = untrustedConfig.requestBody;
-    const referencePriceCartInputRepresentationValidationError = validate$l(untrustedConfig_requestBody);
+    const referencePriceCartInputRepresentationValidationError = validate$m(untrustedConfig_requestBody);
     if (referencePriceCartInputRepresentationValidationError === null) {
         config.requestBody = untrustedConfig_requestBody;
     }
     return config;
 }
-function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$1(untrustedConfig);
+    const config = typeCheckConfig$3(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$1(luvio, config, options) {
-    const resourceParams = createResourceParams$1(config);
-    const request = createResourceRequest$1(resourceParams);
+function buildNetworkSnapshot$3(luvio, config, options) {
+    const resourceParams = createResourceParams$3(config);
+    const request = createResourceRequest$3(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$1(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$3(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -4608,16 +4633,16 @@ function buildNetworkSnapshot$1(luvio, config, options) {
 }
 const priceCartAdapterFactory = (luvio) => {
     return function priceCart(untrustedConfig) {
-        const config = validateAdapterConfig$1(untrustedConfig, priceCart_ConfigPropertyNames);
+        const config = validateAdapterConfig$3(untrustedConfig, priceCart_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "priceCart"');
         }
-        return buildNetworkSnapshot$1(luvio, config);
+        return buildNetworkSnapshot$3(luvio, config);
     };
 };
 
-function validate$j(obj, path = 'ConfiguratorAddedNodeInputRepresentation') {
+function validate$k(obj, path = 'ConfiguratorAddedNodeInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4645,7 +4670,7 @@ function validate$j(obj, path = 'ConfiguratorAddedNodeInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$i(obj, path = 'ConfiguratorOptionsInputRepresentation') {
+function validate$j(obj, path = 'ConfiguratorOptionsInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4710,7 +4735,7 @@ function validate$i(obj, path = 'ConfiguratorOptionsInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$h(obj, path = 'ConfiguratorDeletedNodeInputRepresentation') {
+function validate$i(obj, path = 'ConfiguratorDeletedNodeInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4733,7 +4758,7 @@ function validate$h(obj, path = 'ConfiguratorDeletedNodeInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$g(obj, path = 'ConfiguratorUpdatedNodeInputRepresentation') {
+function validate$h(obj, path = 'ConfiguratorUpdatedNodeInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4761,7 +4786,7 @@ function validate$g(obj, path = 'ConfiguratorUpdatedNodeInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$f(obj, path = 'ConfiguratorInputRepresentation') {
+function validate$g(obj, path = 'ConfiguratorInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4775,7 +4800,7 @@ function validate$f(obj, path = 'ConfiguratorInputRepresentation') {
             for (let i = 0; i < obj_addedNodes.length; i++) {
                 const obj_addedNodes_item = obj_addedNodes[i];
                 const path_addedNodes_item = path_addedNodes + '[' + i + ']';
-                const referencepath_addedNodes_itemValidationError = validate$j(obj_addedNodes_item, path_addedNodes_item);
+                const referencepath_addedNodes_itemValidationError = validate$k(obj_addedNodes_item, path_addedNodes_item);
                 if (referencepath_addedNodes_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ConfiguratorAddedNodeInputRepresentation (at "' + path_addedNodes_item + '")\n';
                     message += referencepath_addedNodes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4786,7 +4811,7 @@ function validate$f(obj, path = 'ConfiguratorInputRepresentation') {
         if (obj.configuratorOptions !== undefined) {
             const obj_configuratorOptions = obj.configuratorOptions;
             const path_configuratorOptions = path + '.configuratorOptions';
-            const referencepath_configuratorOptionsValidationError = validate$i(obj_configuratorOptions, path_configuratorOptions);
+            const referencepath_configuratorOptionsValidationError = validate$j(obj_configuratorOptions, path_configuratorOptions);
             if (referencepath_configuratorOptionsValidationError !== null) {
                 let message = 'Object doesn\'t match ConfiguratorOptionsInputRepresentation (at "' + path_configuratorOptions + '")\n';
                 message += referencepath_configuratorOptionsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4844,7 +4869,7 @@ function validate$f(obj, path = 'ConfiguratorInputRepresentation') {
             for (let i = 0; i < obj_deletedNodes.length; i++) {
                 const obj_deletedNodes_item = obj_deletedNodes[i];
                 const path_deletedNodes_item = path_deletedNodes + '[' + i + ']';
-                const referencepath_deletedNodes_itemValidationError = validate$h(obj_deletedNodes_item, path_deletedNodes_item);
+                const referencepath_deletedNodes_itemValidationError = validate$i(obj_deletedNodes_item, path_deletedNodes_item);
                 if (referencepath_deletedNodes_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ConfiguratorDeletedNodeInputRepresentation (at "' + path_deletedNodes_item + '")\n';
                     message += referencepath_deletedNodes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4952,7 +4977,7 @@ function validate$f(obj, path = 'ConfiguratorInputRepresentation') {
             for (let i = 0; i < obj_updatedNodes.length; i++) {
                 const obj_updatedNodes_item = obj_updatedNodes[i];
                 const path_updatedNodes_item = path_updatedNodes + '[' + i + ']';
-                const referencepath_updatedNodes_itemValidationError = validate$g(obj_updatedNodes_item, path_updatedNodes_item);
+                const referencepath_updatedNodes_itemValidationError = validate$h(obj_updatedNodes_item, path_updatedNodes_item);
                 if (referencepath_updatedNodes_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ConfiguratorUpdatedNodeInputRepresentation (at "' + path_updatedNodes_item + '")\n';
                     message += referencepath_updatedNodes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4964,7 +4989,7 @@ function validate$f(obj, path = 'ConfiguratorInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$e(obj, path = 'ConfiguratorAdditionalFieldsOutputRepresentation') {
+function validate$f(obj, path = 'ConfiguratorAdditionalFieldsOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4994,7 +5019,7 @@ function validate$e(obj, path = 'ConfiguratorAdditionalFieldsOutputRepresentatio
     return v_error === undefined ? null : v_error;
 }
 
-function validate$d(obj, path = 'ConfiguratorAttributePicklistValueOutputRepresentation') {
+function validate$e(obj, path = 'ConfiguratorAttributePicklistValueOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5073,7 +5098,7 @@ function validate$d(obj, path = 'ConfiguratorAttributePicklistValueOutputReprese
     return v_error === undefined ? null : v_error;
 }
 
-function validate$c(obj, path = 'ConfiguratorAttributePicklistOutputRepresentation') {
+function validate$d(obj, path = 'ConfiguratorAttributePicklistOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5115,7 +5140,7 @@ function validate$c(obj, path = 'ConfiguratorAttributePicklistOutputRepresentati
             for (let i = 0; i < obj_values.length; i++) {
                 const obj_values_item = obj_values[i];
                 const path_values_item = path_values + '[' + i + ']';
-                const referencepath_values_itemValidationError = validate$d(obj_values_item, path_values_item);
+                const referencepath_values_itemValidationError = validate$e(obj_values_item, path_values_item);
                 if (referencepath_values_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ConfiguratorAttributePicklistValueOutputRepresentation (at "' + path_values_item + '")\n';
                     message += referencepath_values_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5127,7 +5152,7 @@ function validate$c(obj, path = 'ConfiguratorAttributePicklistOutputRepresentati
     return v_error === undefined ? null : v_error;
 }
 
-function validate$b(obj, path = 'ConfiguratorAttributeOutputRepresentation') {
+function validate$c(obj, path = 'ConfiguratorAttributeOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5149,7 +5174,7 @@ function validate$b(obj, path = 'ConfiguratorAttributeOutputRepresentation') {
         if (obj.attributePicklist !== undefined) {
             const obj_attributePicklist = obj.attributePicklist;
             const path_attributePicklist = path + '.attributePicklist';
-            const referencepath_attributePicklistValidationError = validate$c(obj_attributePicklist, path_attributePicklist);
+            const referencepath_attributePicklistValidationError = validate$d(obj_attributePicklist, path_attributePicklist);
             if (referencepath_attributePicklistValidationError !== null) {
                 let message = 'Object doesn\'t match ConfiguratorAttributePicklistOutputRepresentation (at "' + path_attributePicklist + '")\n';
                 message += referencepath_attributePicklistValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5328,7 +5353,7 @@ function validate$b(obj, path = 'ConfiguratorAttributeOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$a(obj, path = 'ConfiguratorAttributeCategoryOutputRepresentation') {
+function validate$b(obj, path = 'ConfiguratorAttributeCategoryOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5342,7 +5367,7 @@ function validate$a(obj, path = 'ConfiguratorAttributeCategoryOutputRepresentati
             for (let i = 0; i < obj_attributes.length; i++) {
                 const obj_attributes_item = obj_attributes[i];
                 const path_attributes_item = path_attributes + '[' + i + ']';
-                const referencepath_attributes_itemValidationError = validate$b(obj_attributes_item, path_attributes_item);
+                const referencepath_attributes_itemValidationError = validate$c(obj_attributes_item, path_attributes_item);
                 if (referencepath_attributes_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ConfiguratorAttributeOutputRepresentation (at "' + path_attributes_item + '")\n';
                     message += referencepath_attributes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5403,7 +5428,7 @@ function validate$a(obj, path = 'ConfiguratorAttributeCategoryOutputRepresentati
     return v_error === undefined ? null : v_error;
 }
 
-function validate$9(obj, path = 'ConfiguratorPricingModelOutputRepresentation') {
+function validate$a(obj, path = 'ConfiguratorPricingModelOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5454,7 +5479,7 @@ function validate$9(obj, path = 'ConfiguratorPricingModelOutputRepresentation')
     return v_error === undefined ? null : v_error;
 }
 
-function validate$8(obj, path = 'ConfiguratorPriceOutputRepresentation') {
+function validate$9(obj, path = 'ConfiguratorPriceOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5487,6 +5512,13 @@ function validate$8(obj, path = 'ConfiguratorPriceOutputRepresentation') {
                 return new TypeError('Expected "boolean" but received "' + typeof obj_isDefault + '" (at "' + path_isDefault + '")');
             }
         }
+        if (obj.isDerived !== undefined) {
+            const obj_isDerived = obj.isDerived;
+            const path_isDerived = path + '.isDerived';
+            if (typeof obj_isDerived !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isDerived + '" (at "' + path_isDerived + '")');
+            }
+        }
         if (obj.isSelected !== undefined) {
             const obj_isSelected = obj.isSelected;
             const path_isSelected = path + '.isSelected';
@@ -5511,7 +5543,7 @@ function validate$8(obj, path = 'ConfiguratorPriceOutputRepresentation') {
         if (obj.pricingModel !== undefined) {
             const obj_pricingModel = obj.pricingModel;
             const path_pricingModel = path + '.pricingModel';
-            const referencepath_pricingModelValidationError = validate$9(obj_pricingModel, path_pricingModel);
+            const referencepath_pricingModelValidationError = validate$a(obj_pricingModel, path_pricingModel);
             if (referencepath_pricingModelValidationError !== null) {
                 let message = 'Object doesn\'t match ConfiguratorPricingModelOutputRepresentation (at "' + path_pricingModel + '")\n';
                 message += referencepath_pricingModelValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5525,7 +5557,7 @@ function validate$8(obj, path = 'ConfiguratorPriceOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$7(obj, path = 'ConfiguratorProductClassificationOutputRepresentation') {
+function validate$8(obj, path = 'ConfiguratorProductClassificationOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5541,7 +5573,7 @@ function validate$7(obj, path = 'ConfiguratorProductClassificationOutputRepresen
     return v_error === undefined ? null : v_error;
 }
 
-function validate$6(obj, path = 'ConfiguratorProductComponentGroupOutputRepresentation') {
+function validate$7(obj, path = 'ConfiguratorProductComponentGroupOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5555,7 +5587,7 @@ function validate$6(obj, path = 'ConfiguratorProductComponentGroupOutputRepresen
             for (let i = 0; i < obj_classifications.length; i++) {
                 const obj_classifications_item = obj_classifications[i];
                 const path_classifications_item = path_classifications + '[' + i + ']';
-                const referencepath_classifications_itemValidationError = validate$7(obj_classifications_item, path_classifications_item);
+                const referencepath_classifications_itemValidationError = validate$8(obj_classifications_item, path_classifications_item);
                 if (referencepath_classifications_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ConfiguratorProductClassificationOutputRepresentation (at "' + path_classifications_item + '")\n';
                     message += referencepath_classifications_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5579,7 +5611,7 @@ function validate$6(obj, path = 'ConfiguratorProductComponentGroupOutputRepresen
             for (let i = 0; i < obj_components.length; i++) {
                 const obj_components_item = obj_components[i];
                 const path_components_item = path_components + '[' + i + ']';
-                const referencepath_components_itemValidationError = validate$1(obj_components_item, path_components_item);
+                const referencepath_components_itemValidationError = validate$2(obj_components_item, path_components_item);
                 if (referencepath_components_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ConfiguratorProductCatalogOutputRepresentation (at "' + path_components_item + '")\n';
                     message += referencepath_components_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5640,7 +5672,7 @@ function validate$6(obj, path = 'ConfiguratorProductComponentGroupOutputRepresen
     return v_error === undefined ? null : v_error;
 }
 
-function validate$5(obj, path = 'ConfiguratorProductRelatedComponentOutputRepresentation') {
+function validate$6(obj, path = 'ConfiguratorProductRelatedComponentOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5756,7 +5788,7 @@ function validate$5(obj, path = 'ConfiguratorProductRelatedComponentOutputRepres
     return v_error === undefined ? null : v_error;
 }
 
-function validate$4(obj, path = 'ConfiguratorProductSellingModelOutputRepresentation') {
+function validate$5(obj, path = 'ConfiguratorProductSellingModelOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5807,7 +5839,7 @@ function validate$4(obj, path = 'ConfiguratorProductSellingModelOutputRepresenta
     return v_error === undefined ? null : v_error;
 }
 
-function validate$3(obj, path = 'ConfiguratorProductSellingModelOptionOutputRepresentation') {
+function validate$4(obj, path = 'ConfiguratorProductSellingModelOptionOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5829,7 +5861,7 @@ function validate$3(obj, path = 'ConfiguratorProductSellingModelOptionOutputRepr
         if (obj.productSellingModel !== undefined) {
             const obj_productSellingModel = obj.productSellingModel;
             const path_productSellingModel = path + '.productSellingModel';
-            const referencepath_productSellingModelValidationError = validate$4(obj_productSellingModel, path_productSellingModel);
+            const referencepath_productSellingModelValidationError = validate$5(obj_productSellingModel, path_productSellingModel);
             if (referencepath_productSellingModelValidationError !== null) {
                 let message = 'Object doesn\'t match ConfiguratorProductSellingModelOutputRepresentation (at "' + path_productSellingModel + '")\n';
                 message += referencepath_productSellingModelValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5847,7 +5879,7 @@ function validate$3(obj, path = 'ConfiguratorProductSellingModelOptionOutputRepr
     return v_error === undefined ? null : v_error;
 }
 
-function validate$2(obj, path = 'ConfiguratorQualificationContextOutputRepresentation') {
+function validate$3(obj, path = 'ConfiguratorQualificationContextOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5870,7 +5902,7 @@ function validate$2(obj, path = 'ConfiguratorQualificationContextOutputRepresent
     return v_error === undefined ? null : v_error;
 }
 
-function validate$1(obj, path = 'ConfiguratorProductCatalogOutputRepresentation') {
+function validate$2(obj, path = 'ConfiguratorProductCatalogOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5884,7 +5916,7 @@ function validate$1(obj, path = 'ConfiguratorProductCatalogOutputRepresentation'
             for (let i = 0; i < obj_additionalFields.length; i++) {
                 const obj_additionalFields_item = obj_additionalFields[i];
                 const path_additionalFields_item = path_additionalFields + '[' + i + ']';
-                const referencepath_additionalFields_itemValidationError = validate$e(obj_additionalFields_item, path_additionalFields_item);
+                const referencepath_additionalFields_itemValidationError = validate$f(obj_additionalFields_item, path_additionalFields_item);
                 if (referencepath_additionalFields_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ConfiguratorAdditionalFieldsOutputRepresentation (at "' + path_additionalFields_item + '")\n';
                     message += referencepath_additionalFields_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5901,7 +5933,7 @@ function validate$1(obj, path = 'ConfiguratorProductCatalogOutputRepresentation'
             for (let i = 0; i < obj_attributeCategories.length; i++) {
                 const obj_attributeCategories_item = obj_attributeCategories[i];
                 const path_attributeCategories_item = path_attributeCategories + '[' + i + ']';
-                const referencepath_attributeCategories_itemValidationError = validate$a(obj_attributeCategories_item, path_attributeCategories_item);
+                const referencepath_attributeCategories_itemValidationError = validate$b(obj_attributeCategories_item, path_attributeCategories_item);
                 if (referencepath_attributeCategories_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ConfiguratorAttributeCategoryOutputRepresentation (at "' + path_attributeCategories_item + '")\n';
                     message += referencepath_attributeCategories_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -6023,7 +6055,7 @@ function validate$1(obj, path = 'ConfiguratorProductCatalogOutputRepresentation'
             for (let i = 0; i < obj_prices.length; i++) {
                 const obj_prices_item = obj_prices[i];
                 const path_prices_item = path_prices + '[' + i + ']';
-                const referencepath_prices_itemValidationError = validate$8(obj_prices_item, path_prices_item);
+                const referencepath_prices_itemValidationError = validate$9(obj_prices_item, path_prices_item);
                 if (referencepath_prices_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ConfiguratorPriceOutputRepresentation (at "' + path_prices_item + '")\n';
                     message += referencepath_prices_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -6034,7 +6066,7 @@ function validate$1(obj, path = 'ConfiguratorProductCatalogOutputRepresentation'
         if (obj.productClassification !== undefined) {
             const obj_productClassification = obj.productClassification;
             const path_productClassification = path + '.productClassification';
-            const referencepath_productClassificationValidationError = validate$7(obj_productClassification, path_productClassification);
+            const referencepath_productClassificationValidationError = validate$8(obj_productClassification, path_productClassification);
             if (referencepath_productClassificationValidationError !== null) {
                 let message = 'Object doesn\'t match ConfiguratorProductClassificationOutputRepresentation (at "' + path_productClassification + '")\n';
                 message += referencepath_productClassificationValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -6057,7 +6089,7 @@ function validate$1(obj, path = 'ConfiguratorProductCatalogOutputRepresentation'
             for (let i = 0; i < obj_productComponentGroups.length; i++) {
                 const obj_productComponentGroups_item = obj_productComponentGroups[i];
                 const path_productComponentGroups_item = path_productComponentGroups + '[' + i + ']';
-                const referencepath_productComponentGroups_itemValidationError = validate$6(obj_productComponentGroups_item, path_productComponentGroups_item);
+                const referencepath_productComponentGroups_itemValidationError = validate$7(obj_productComponentGroups_item, path_productComponentGroups_item);
                 if (referencepath_productComponentGroups_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ConfiguratorProductComponentGroupOutputRepresentation (at "' + path_productComponentGroups_item + '")\n';
                     message += referencepath_productComponentGroups_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -6068,7 +6100,7 @@ function validate$1(obj, path = 'ConfiguratorProductCatalogOutputRepresentation'
         if (obj.productRelatedComponent !== undefined) {
             const obj_productRelatedComponent = obj.productRelatedComponent;
             const path_productRelatedComponent = path + '.productRelatedComponent';
-            const referencepath_productRelatedComponentValidationError = validate$5(obj_productRelatedComponent, path_productRelatedComponent);
+            const referencepath_productRelatedComponentValidationError = validate$6(obj_productRelatedComponent, path_productRelatedComponent);
             if (referencepath_productRelatedComponentValidationError !== null) {
                 let message = 'Object doesn\'t match ConfiguratorProductRelatedComponentOutputRepresentation (at "' + path_productRelatedComponent + '")\n';
                 message += referencepath_productRelatedComponentValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -6084,7 +6116,7 @@ function validate$1(obj, path = 'ConfiguratorProductCatalogOutputRepresentation'
             for (let i = 0; i < obj_productSellingModelOptions.length; i++) {
                 const obj_productSellingModelOptions_item = obj_productSellingModelOptions[i];
                 const path_productSellingModelOptions_item = path_productSellingModelOptions + '[' + i + ']';
-                const referencepath_productSellingModelOptions_itemValidationError = validate$3(obj_productSellingModelOptions_item, path_productSellingModelOptions_item);
+                const referencepath_productSellingModelOptions_itemValidationError = validate$4(obj_productSellingModelOptions_item, path_productSellingModelOptions_item);
                 if (referencepath_productSellingModelOptions_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ConfiguratorProductSellingModelOptionOutputRepresentation (at "' + path_productSellingModelOptions_item + '")\n';
                     message += referencepath_productSellingModelOptions_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -6102,7 +6134,7 @@ function validate$1(obj, path = 'ConfiguratorProductCatalogOutputRepresentation'
         if (obj.qualificationContext !== undefined) {
             const obj_qualificationContext = obj.qualificationContext;
             const path_qualificationContext = path + '.qualificationContext';
-            const referencepath_qualificationContextValidationError = validate$2(obj_qualificationContext, path_qualificationContext);
+            const referencepath_qualificationContextValidationError = validate$3(obj_qualificationContext, path_qualificationContext);
             if (referencepath_qualificationContextValidationError !== null) {
                 let message = 'Object doesn\'t match ConfiguratorQualificationContextOutputRepresentation (at "' + path_qualificationContext + '")\n';
                 message += referencepath_qualificationContextValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -6120,9 +6152,9 @@ function validate$1(obj, path = 'ConfiguratorProductCatalogOutputRepresentation'
     return v_error === undefined ? null : v_error;
 }
 
-const TTL = 1000;
-const VERSION = "1e94956cf0691aeb2e892924e1798d6c";
-function validate(obj, path = 'ConfiguratorOutputRepresentation') {
+const TTL$1 = 1000;
+const VERSION$1 = "a9e74c89f83dab5ce88d601ec57daa71";
+function validate$1(obj, path = 'ConfiguratorOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -6136,7 +6168,7 @@ function validate(obj, path = 'ConfiguratorOutputRepresentation') {
             for (let i = 0; i < obj_catalogProducts.length; i++) {
                 const obj_catalogProducts_item = obj_catalogProducts[i];
                 const path_catalogProducts_item = path_catalogProducts + '[' + i + ']';
-                const referencepath_catalogProducts_itemValidationError = validate$1(obj_catalogProducts_item, path_catalogProducts_item);
+                const referencepath_catalogProducts_itemValidationError = validate$2(obj_catalogProducts_item, path_catalogProducts_item);
                 if (referencepath_catalogProducts_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ConfiguratorProductCatalogOutputRepresentation (at "' + path_catalogProducts_item + '")\n';
                     message += referencepath_catalogProducts_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -6198,23 +6230,209 @@ function validate(obj, path = 'ConfiguratorOutputRepresentation') {
                 return new TypeError('Expected "defined" but received "' + typeof obj_transactionQualification + '" (at "' + path_transactionQualification + '")');
             }
         }
+        if (obj.uiModifications !== undefined) {
+            const obj_uiModifications = obj.uiModifications;
+            const path_uiModifications = path + '.uiModifications';
+            if (obj_uiModifications === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_uiModifications + '" (at "' + path_uiModifications + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$1 = 'ConfiguratorOutputRepresentation';
+function keyBuilder$1(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$1 + ':' + config.contextId;
+}
+function keyBuilderFromType$1(luvio, object) {
+    const keyParams = {
+        contextId: object.transactionContextId
+    };
+    return keyBuilder$1(luvio, keyParams);
+}
+function normalize$1(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$4 = function ConfiguratorOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$1,
+        private: [],
+        opaque: true
+    };
+};
+function equals$1(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest$1 = function ConfiguratorOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$1(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$1(luvio, input);
+    const ttlToUse = TTL$1;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "cpq", VERSION$1, RepresentationType$1, equals$1);
+    return createLink(key);
+};
+function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$1(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+}
+
+function select$3(luvio, params) {
+    return select$4();
+}
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$1(storeKeyMap, luvio, response);
+}
+function ingestSuccess$2(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$1(luvio, body);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$3(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v61.0',
+        basePath: '/connect/cpq/configurator/actions/configure',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$2 = 'configure';
+const configure_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('configuratorInput', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const configure_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, configure_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$d(configure_ConfigPropertyMetadata);
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_configuratorInput = untrustedConfig.configuratorInput;
+    const referenceConfiguratorInputRepresentationValidationError = validate$g(untrustedConfig_configuratorInput);
+    if (referenceConfiguratorInputRepresentationValidationError === null) {
+        config.configuratorInput = untrustedConfig_configuratorInput;
+    }
+    return config;
+}
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$2(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$2(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const configureAdapterFactory = (luvio) => {
+    return function configure(untrustedConfig) {
+        const config = validateAdapterConfig$2(untrustedConfig, configure_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "configure"');
+        }
+        return buildNetworkSnapshot$2(luvio, config);
+    };
+};
+
+const TTL = 60000;
+const VERSION = "58609222da9b23820be663483875555c";
+function validate(obj, path = 'ConfiguratorRuleOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.message !== undefined) {
+            const obj_message = obj.message;
+            const path_message = path + '.message';
+            if (typeof obj_message !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_message + '" (at "' + path_message + '")');
+            }
+        }
+        const obj_productConfigurationRuleId = obj.productConfigurationRuleId;
+        const path_productConfigurationRuleId = path + '.productConfigurationRuleId';
+        if (typeof obj_productConfigurationRuleId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_productConfigurationRuleId + '" (at "' + path_productConfigurationRuleId + '")');
+        }
+        if (obj.ruleId !== undefined) {
+            const obj_ruleId = obj.ruleId;
+            const path_ruleId = path + '.ruleId';
+            if (typeof obj_ruleId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_ruleId + '" (at "' + path_ruleId + '")');
+            }
+        }
+        if (obj.success !== undefined) {
+            const obj_success = obj.success;
+            const path_success = path + '.success';
+            if (typeof obj_success !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_success + '" (at "' + path_success + '")');
+            }
+        }
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType = 'ConfiguratorOutputRepresentation';
+const RepresentationType = 'ConfiguratorRuleOutputRepresentation';
 function keyBuilder(luvio, config) {
-    return keyPrefix + '::' + RepresentationType + ':' + config.contextId;
+    return keyPrefix + '::' + RepresentationType + ':' + config.productConfigurationRuleId;
 }
 function keyBuilderFromType(luvio, object) {
     const keyParams = {
-        contextId: object.transactionContextId
+        productConfigurationRuleId: object.productConfigurationRuleId
     };
     return keyBuilder(luvio, keyParams);
 }
 function normalize(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$1 = function ConfiguratorOutputRepresentationSelect() {
+const select$2 = function ConfiguratorRuleOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION,
@@ -6228,7 +6446,7 @@ function equals(existing, incoming) {
     }
     return true;
 }
-const ingest = function ConfiguratorOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest = function ConfiguratorRuleOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate(input);
         if (validateError !== null) {
@@ -6250,8 +6468,126 @@ function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
+function select$1(luvio, params) {
+    return select$2();
+}
+function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys(storeKeyMap, luvio, response);
+}
+function ingestSuccess$1(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType(luvio, body);
+    luvio.storeIngest(key, ingest, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$1(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest$1(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v61.0',
+        basePath: '/connect/cpq/configurator/actions/create-rule',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$1 = 'createRule';
+const createRule_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('actions', true, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('criteria', true, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('criteriaExpression', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('endDate', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('name', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('scope', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('sequence', false, 2 /* Body */, 3 /* Integer */),
+    generateParamConfigMetadata('startDate', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('status', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('usageSubType', false, 2 /* Body */, 0 /* String */),
+];
+const createRule_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, createRule_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$d(createRule_ConfigPropertyMetadata);
+function typeCheckConfig$1(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$d(untrustedConfig, config, createRule_ConfigPropertyMetadata);
+    const untrustedConfig_actions = untrustedConfig.actions;
+    if (ArrayIsArray$1(untrustedConfig_actions)) {
+        const untrustedConfig_actions_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_actions.length; i < arrayLength; i++) {
+            const untrustedConfig_actions_item = untrustedConfig_actions[i];
+            untrustedConfig_actions_array.push(untrustedConfig_actions_item);
+        }
+        config.actions = untrustedConfig_actions_array;
+    }
+    const untrustedConfig_criteria = untrustedConfig.criteria;
+    if (ArrayIsArray$1(untrustedConfig_criteria)) {
+        const untrustedConfig_criteria_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_criteria.length; i < arrayLength; i++) {
+            const untrustedConfig_criteria_item = untrustedConfig_criteria[i];
+            untrustedConfig_criteria_array.push(untrustedConfig_criteria_item);
+        }
+        config.criteria = untrustedConfig_criteria_array;
+    }
+    return config;
+}
+function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$1(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$1(luvio, config, options) {
+    const resourceParams = createResourceParams$1(config);
+    const request = createResourceRequest$1(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$1(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const createRuleAdapterFactory = (luvio) => {
+    return function createRule(untrustedConfig) {
+        const config = validateAdapterConfig$1(untrustedConfig, createRule_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createRule"');
+        }
+        return buildNetworkSnapshot$1(luvio, config);
+    };
+};
+
 function select(luvio, params) {
-    return select$1();
+    return select$2();
 }
 function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys(storeKeyMap, luvio, response);
@@ -6277,7 +6613,7 @@ function createResourceRequest(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
-        basePath: '/connect/cpq/configurator/actions/configure',
+        basePath: '/connect/cpq/configurator/actions/update-rule',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -6287,18 +6623,42 @@ function createResourceRequest(config) {
     };
 }
 
-const adapterName = 'configure';
-const configure_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('configuratorInput', true, 2 /* Body */, 4 /* Unsupported */),
+const adapterName = 'updateRule';
+const updateRule_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('actions', true, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('criteria', true, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('criteriaExpression', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('endDate', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('name', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('scope', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('sequence', false, 2 /* Body */, 3 /* Integer */),
+    generateParamConfigMetadata('startDate', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('status', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('usageSubType', false, 2 /* Body */, 0 /* String */),
 ];
-const configure_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, configure_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$b(configure_ConfigPropertyMetadata);
+const updateRule_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, updateRule_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$d(updateRule_ConfigPropertyMetadata);
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    const untrustedConfig_configuratorInput = untrustedConfig.configuratorInput;
-    const referenceConfiguratorInputRepresentationValidationError = validate$f(untrustedConfig_configuratorInput);
-    if (referenceConfiguratorInputRepresentationValidationError === null) {
-        config.configuratorInput = untrustedConfig_configuratorInput;
+    typeCheckConfig$d(untrustedConfig, config, updateRule_ConfigPropertyMetadata);
+    const untrustedConfig_actions = untrustedConfig.actions;
+    if (ArrayIsArray$1(untrustedConfig_actions)) {
+        const untrustedConfig_actions_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_actions.length; i < arrayLength; i++) {
+            const untrustedConfig_actions_item = untrustedConfig_actions[i];
+            untrustedConfig_actions_array.push(untrustedConfig_actions_item);
+        }
+        config.actions = untrustedConfig_actions_array;
+    }
+    const untrustedConfig_criteria = untrustedConfig.criteria;
+    if (ArrayIsArray$1(untrustedConfig_criteria)) {
+        const untrustedConfig_criteria_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_criteria.length; i < arrayLength; i++) {
+            const untrustedConfig_criteria_item = untrustedConfig_criteria[i];
+            untrustedConfig_criteria_array.push(untrustedConfig_criteria_item);
+        }
+        config.criteria = untrustedConfig_criteria_array;
     }
     return config;
 }
@@ -6333,15 +6693,15 @@ function buildNetworkSnapshot(luvio, config, options) {
         throw response;
     });
 }
-const configureAdapterFactory = (luvio) => {
-    return function configure(untrustedConfig) {
-        const config = validateAdapterConfig(untrustedConfig, configure_ConfigPropertyNames);
+const updateRuleAdapterFactory = (luvio) => {
+    return function updateRule(untrustedConfig) {
+        const config = validateAdapterConfig(untrustedConfig, updateRule_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error('Invalid config for "configure"');
+            throw new Error('Invalid config for "updateRule"');
         }
         return buildNetworkSnapshot(luvio, config);
     };
 };
 
-export { configureAdapterFactory, createCartAdapterFactory, createCartItemsAdapterFactory, getCartAdapterFactory, previewAdapterFactory, priceCartAdapterFactory, productDetailsAdapterFactory, productListAdapterFactory, searchProductListAdapterFactory, updateCartAdapterFactory, updateCartItemsAdapterFactory };
+export { configureAdapterFactory, createCartAdapterFactory, createCartItemsAdapterFactory, createRuleAdapterFactory, getCartAdapterFactory, previewAdapterFactory, priceCartAdapterFactory, productDetailsAdapterFactory, productListAdapterFactory, searchProductListAdapterFactory, updateCartAdapterFactory, updateCartItemsAdapterFactory, updateRuleAdapterFactory };