npm - @salesforce/lds-adapters-industries-decisiontable - Versions diffs - 1.393.0 → 1.395.0 - Mend

@salesforce/lds-adapters-industries-decisiontable 1.393.0 → 1.395.0

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

Files changed (11) hide show

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

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
-import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$5, typeCheckConfig as typeCheckConfig$7, StoreKeyMap, createResourceParams as createResourceParams$7 } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$5, typeCheckConfig as typeCheckConfig$8, StoreKeyMap, createResourceParams as createResourceParams$8 } from '@luvio/engine';
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -80,7 +80,7 @@ function createLink(ref) {
     };
 }
-function validate$e(obj, path = 'DecisionTableParameterOutputRepresentation') {
+function validate$f(obj, path = 'DecisionTableParameterOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -180,7 +180,7 @@ function validate$e(obj, path = 'DecisionTableParameterOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
-function validate$d(obj, path = 'DecisionTableSourceCriteriaOutputRepresentation') {
+function validate$e(obj, path = 'DecisionTableSourceCriteriaOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -224,7 +224,7 @@ function validate$d(obj, path = 'DecisionTableSourceCriteriaOutputRepresentation
     return v_error === undefined ? null : v_error;
 }
-function validate$c(obj, path = 'DecisionTableDefinitionOutputRepresentation') {
+function validate$d(obj, path = 'DecisionTableDefinitionOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -286,7 +286,7 @@ function validate$c(obj, path = 'DecisionTableDefinitionOutputRepresentation') {
         for (let i = 0; i < obj_parameters.length; i++) {
             const obj_parameters_item = obj_parameters[i];
             const path_parameters_item = path_parameters + '[' + i + ']';
-            const referencepath_parameters_itemValidationError = validate$e(obj_parameters_item, path_parameters_item);
+            const referencepath_parameters_itemValidationError = validate$f(obj_parameters_item, path_parameters_item);
             if (referencepath_parameters_itemValidationError !== null) {
                 let message = 'Object doesn\'t match DecisionTableParameterOutputRepresentation (at "' + path_parameters_item + '")\n';
                 message += referencepath_parameters_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -308,7 +308,7 @@ function validate$c(obj, path = 'DecisionTableDefinitionOutputRepresentation') {
         for (let i = 0; i < obj_sourceCriteria.length; i++) {
             const obj_sourceCriteria_item = obj_sourceCriteria[i];
             const path_sourceCriteria_item = path_sourceCriteria + '[' + i + ']';
-            const referencepath_sourceCriteria_itemValidationError = validate$d(obj_sourceCriteria_item, path_sourceCriteria_item);
+            const referencepath_sourceCriteria_itemValidationError = validate$e(obj_sourceCriteria_item, path_sourceCriteria_item);
             if (referencepath_sourceCriteria_itemValidationError !== null) {
                 let message = 'Object doesn\'t match DecisionTableSourceCriteriaOutputRepresentation (at "' + path_sourceCriteria_item + '")\n';
                 message += referencepath_sourceCriteria_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -354,9 +354,9 @@ function validate$c(obj, path = 'DecisionTableDefinitionOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
-const TTL$5 = 1000;
-const VERSION$5 = "21435364536c593ed8b8972af7d154d5";
-function validate$b(obj, path = 'DecisionTableOutputRepresentation') {
+const TTL$6 = 1000;
+const VERSION$6 = "21435364536c593ed8b8972af7d154d5";
+function validate$c(obj, path = 'DecisionTableOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -370,7 +370,7 @@ function validate$b(obj, path = 'DecisionTableOutputRepresentation') {
         }
         const obj_decisionTable = obj.decisionTable;
         const path_decisionTable = path + '.decisionTable';
-        const referencepath_decisionTableValidationError = validate$c(obj_decisionTable, path_decisionTable);
+        const referencepath_decisionTableValidationError = validate$d(obj_decisionTable, path_decisionTable);
         if (referencepath_decisionTableValidationError !== null) {
             let message = 'Object doesn\'t match DecisionTableDefinitionOutputRepresentation (at "' + path_decisionTable + '")\n';
             message += referencepath_decisionTableValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -393,62 +393,62 @@ function validate$b(obj, path = 'DecisionTableOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$5 = 'DecisionTableOutputRepresentation';
-function normalize$5(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$6 = 'DecisionTableOutputRepresentation';
+function normalize$6(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$c = function DecisionTableOutputRepresentationSelect() {
+const select$e = function DecisionTableOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$5,
+        version: VERSION$6,
         private: [],
         opaque: true
     };
 };
-function equals$5(existing, incoming) {
+function equals$6(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$5 = function DecisionTableOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$6 = function DecisionTableOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$b(input);
+        const validateError = validate$c(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$5;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$5, "DecisionTable", VERSION$5, RepresentationType$5, equals$5);
+    const ttlToUse = TTL$6;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$6, "DecisionTable", 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$b(luvio, params) {
-    return select$c();
+function select$d(luvio, params) {
+    return select$e();
 }
-function keyBuilder$b(luvio, params) {
+function keyBuilder$c(luvio, params) {
     return keyPrefix + '::DecisionTableOutputRepresentation:(' + 'decisionTableId:' + params.urlParams.decisionTableId + ')';
 }
-function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$5(storeKeyMap, luvio, response, () => keyBuilder$b(luvio, resourceParams));
+function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$6(storeKeyMap, luvio, response, () => keyBuilder$c(luvio, resourceParams));
 }
-function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$b(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$5, body);
+    const key = keyBuilder$c(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$6, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$b(),
+        node: select$d(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -460,18 +460,18 @@ function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$4(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$b(luvio, params);
+    const key = keyBuilder$c(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$5,
+        ttl: TTL$6,
         namespace: keyPrefix,
-        version: VERSION$5,
-        representationName: RepresentationType$5
+        version: VERSION$6,
+        representationName: RepresentationType$6
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$6(config) {
+function createResourceRequest$7(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v66.0',
@@ -485,60 +485,60 @@ function createResourceRequest$6(config) {
     };
 }
-const adapterName$6 = 'getDecisionTable';
+const adapterName$7 = 'getDecisionTable';
 const getDecisionTable_ConfigPropertyMetadata = [
     generateParamConfigMetadata('decisionTableId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getDecisionTable_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getDecisionTable_ConfigPropertyMetadata);
-const createResourceParams$6 = /*#__PURE__*/ createResourceParams$7(getDecisionTable_ConfigPropertyMetadata);
-function keyBuilder$a(luvio, config) {
-    const resourceParams = createResourceParams$6(config);
-    return keyBuilder$b(luvio, resourceParams);
+const getDecisionTable_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getDecisionTable_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$8(getDecisionTable_ConfigPropertyMetadata);
+function keyBuilder$b(luvio, config) {
+    const resourceParams = createResourceParams$7(config);
+    return keyBuilder$c(luvio, resourceParams);
 }
-function typeCheckConfig$6(untrustedConfig) {
+function typeCheckConfig$7(untrustedConfig) {
     const config = {};
-    typeCheckConfig$7(untrustedConfig, config, getDecisionTable_ConfigPropertyMetadata);
+    typeCheckConfig$8(untrustedConfig, config, getDecisionTable_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$6(untrustedConfig);
+    const config = typeCheckConfig$7(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$4(luvio, config) {
-    createResourceParams$6(config);
-    return select$b();
+    createResourceParams$7(config);
+    return select$d();
 }
 function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$4(luvio, config, resourceParams, response) {
     const snapshot = ingestError$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$6(luvio, config, options) {
-    const resourceParams = createResourceParams$6(config);
-    const request = createResourceRequest$6(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$4(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$7(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -546,23 +546,23 @@ function buildNetworkSnapshot$6(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
+    return buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$a(luvio, config),
+        recordId: keyBuilder$b(luvio, config),
         node: adapterFragment$4(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getDecisionTableAdapterFactory = (luvio) => function DecisionTable__getDecisionTable(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$6(untrustedConfig, getDecisionTable_ConfigPropertyNames);
+    const config = validateAdapterConfig$7(untrustedConfig, getDecisionTable_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -571,7 +571,7 @@ const getDecisionTableAdapterFactory = (luvio) => function DecisionTable__getDec
     buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
 };
-function validate$a(obj, path = 'DecisionTableTemplateOutputRepresentation') {
+function validate$b(obj, path = 'DecisionTableTemplateOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -601,7 +601,7 @@ function validate$a(obj, path = 'DecisionTableTemplateOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
-function validate$9(obj, path = 'ErrorParametersOutputRepresentation') {
+function validate$a(obj, path = 'ErrorParametersOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -624,7 +624,7 @@ function validate$9(obj, path = 'ErrorParametersOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
-function validate$8(obj, path = 'ErrorTargetsOutputRepresentation') {
+function validate$9(obj, path = 'ErrorTargetsOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -647,7 +647,7 @@ function validate$8(obj, path = 'ErrorTargetsOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
-function validate$7(obj, path = 'ErrorOutputRepresentation') {
+function validate$8(obj, path = 'ErrorOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -682,7 +682,7 @@ function validate$7(obj, path = 'ErrorOutputRepresentation') {
             for (let i = 0; i < obj_parameters.length; i++) {
                 const obj_parameters_item = obj_parameters[i];
                 const path_parameters_item = path_parameters + '[' + i + ']';
-                const referencepath_parameters_itemValidationError = validate$9(obj_parameters_item, path_parameters_item);
+                const referencepath_parameters_itemValidationError = validate$a(obj_parameters_item, path_parameters_item);
                 if (referencepath_parameters_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ErrorParametersOutputRepresentation (at "' + path_parameters_item + '")\n';
                     message += referencepath_parameters_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -699,7 +699,7 @@ function validate$7(obj, path = 'ErrorOutputRepresentation') {
             for (let i = 0; i < obj_targets.length; i++) {
                 const obj_targets_item = obj_targets[i];
                 const path_targets_item = path_targets + '[' + i + ']';
-                const referencepath_targets_itemValidationError = validate$8(obj_targets_item, path_targets_item);
+                const referencepath_targets_itemValidationError = validate$9(obj_targets_item, path_targets_item);
                 if (referencepath_targets_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ErrorTargetsOutputRepresentation (at "' + path_targets_item + '")\n';
                     message += referencepath_targets_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -711,9 +711,9 @@ function validate$7(obj, path = 'ErrorOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
-const TTL$4 = 1000;
-const VERSION$4 = "a2891bd122ab9f728d5937bf70b9f600";
-function validate$6(obj, path = 'DecisionTableTemplatesListOutputRepresentation') {
+const TTL$5 = 1000;
+const VERSION$5 = "a2891bd122ab9f728d5937bf70b9f600";
+function validate$7(obj, path = 'DecisionTableTemplatesListOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -727,7 +727,7 @@ function validate$6(obj, path = 'DecisionTableTemplatesListOutputRepresentation'
             for (let i = 0; i < obj_decisionTableTemplates.length; i++) {
                 const obj_decisionTableTemplates_item = obj_decisionTableTemplates[i];
                 const path_decisionTableTemplates_item = path_decisionTableTemplates + '[' + i + ']';
-                const referencepath_decisionTableTemplates_itemValidationError = validate$a(obj_decisionTableTemplates_item, path_decisionTableTemplates_item);
+                const referencepath_decisionTableTemplates_itemValidationError = validate$b(obj_decisionTableTemplates_item, path_decisionTableTemplates_item);
                 if (referencepath_decisionTableTemplates_itemValidationError !== null) {
                     let message = 'Object doesn\'t match DecisionTableTemplateOutputRepresentation (at "' + path_decisionTableTemplates_item + '")\n';
                     message += referencepath_decisionTableTemplates_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -744,7 +744,7 @@ function validate$6(obj, path = 'DecisionTableTemplatesListOutputRepresentation'
             for (let i = 0; i < obj_errors.length; i++) {
                 const obj_errors_item = obj_errors[i];
                 const path_errors_item = path_errors + '[' + i + ']';
-                const referencepath_errors_itemValidationError = validate$7(obj_errors_item, path_errors_item);
+                const referencepath_errors_itemValidationError = validate$8(obj_errors_item, path_errors_item);
                 if (referencepath_errors_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ErrorOutputRepresentation (at "' + path_errors_item + '")\n';
                     message += referencepath_errors_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -755,62 +755,62 @@ function validate$6(obj, path = 'DecisionTableTemplatesListOutputRepresentation'
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$4 = 'DecisionTableTemplatesListOutputRepresentation';
-function normalize$4(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$5 = 'DecisionTableTemplatesListOutputRepresentation';
+function normalize$5(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$a = function DecisionTableTemplatesListOutputRepresentationSelect() {
+const select$c = function DecisionTableTemplatesListOutputRepresentationSelect() {
     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 DecisionTableTemplatesListOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$5 = function DecisionTableTemplatesListOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$6(input);
+        const validateError = validate$7(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$4;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "DecisionTable", VERSION$4, RepresentationType$4, equals$4);
+    const ttlToUse = TTL$5;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$5, "DecisionTable", 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 = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$4,
+        representationName: RepresentationType$5,
         mergeable: false
     });
 }
-function select$9(luvio, params) {
-    return select$a();
+function select$b(luvio, params) {
+    return select$c();
 }
-function keyBuilder$9(luvio, params) {
+function keyBuilder$a(luvio, params) {
     return keyPrefix + '::DecisionTableTemplatesListOutputRepresentation:(' + 'usageType:' + params.queryParams.usageType + ')';
 }
-function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$4(storeKeyMap, luvio, response, () => keyBuilder$9(luvio, resourceParams));
+function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$5(storeKeyMap, luvio, response, () => keyBuilder$a(luvio, resourceParams));
 }
-function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$9(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$4, body);
+    const key = keyBuilder$a(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$5, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$9(),
+        node: select$b(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -822,18 +822,18 @@ function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$3(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$9(luvio, params);
+    const key = keyBuilder$a(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$4,
+        ttl: TTL$5,
         namespace: keyPrefix,
-        version: VERSION$4,
-        representationName: RepresentationType$4
+        version: VERSION$5,
+        representationName: RepresentationType$5
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$5(config) {
+function createResourceRequest$6(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v66.0',
@@ -847,60 +847,60 @@ function createResourceRequest$5(config) {
     };
 }
-const adapterName$5 = 'getDecisionTableTemplateList';
+const adapterName$6 = 'getDecisionTableTemplateList';
 const getDecisionTableTemplateList_ConfigPropertyMetadata = [
     generateParamConfigMetadata('usageType', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getDecisionTableTemplateList_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getDecisionTableTemplateList_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$7(getDecisionTableTemplateList_ConfigPropertyMetadata);
-function keyBuilder$8(luvio, config) {
-    const resourceParams = createResourceParams$5(config);
-    return keyBuilder$9(luvio, resourceParams);
+const getDecisionTableTemplateList_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getDecisionTableTemplateList_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$8(getDecisionTableTemplateList_ConfigPropertyMetadata);
+function keyBuilder$9(luvio, config) {
+    const resourceParams = createResourceParams$6(config);
+    return keyBuilder$a(luvio, resourceParams);
 }
-function typeCheckConfig$5(untrustedConfig) {
+function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$7(untrustedConfig, config, getDecisionTableTemplateList_ConfigPropertyMetadata);
+    typeCheckConfig$8(untrustedConfig, config, getDecisionTableTemplateList_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$5(untrustedConfig);
+    const config = typeCheckConfig$6(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$3(luvio, config) {
-    createResourceParams$5(config);
-    return select$9();
+    createResourceParams$6(config);
+    return select$b();
 }
 function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$3(luvio, config, resourceParams, response) {
     const snapshot = ingestError$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(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$6(luvio, config, options) {
+    const resourceParams = createResourceParams$6(config);
+    const request = createResourceRequest$6(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -908,23 +908,23 @@ function buildNetworkSnapshot$5(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
+    return buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$8(luvio, config),
+        recordId: keyBuilder$9(luvio, config),
         node: adapterFragment$3(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getDecisionTableTemplateListAdapterFactory = (luvio) => function DecisionTable__getDecisionTableTemplateList(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$5(untrustedConfig, getDecisionTableTemplateList_ConfigPropertyNames);
+    const config = validateAdapterConfig$6(untrustedConfig, getDecisionTableTemplateList_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -933,9 +933,9 @@ const getDecisionTableTemplateListAdapterFactory = (luvio) => function DecisionT
     buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
 };
-const TTL$3 = 1000;
-const VERSION$3 = "9a106f486843ccdb3e85594fb33ef97f";
-function validate$5(obj, path = 'DecisionTableTemplateDefinitionOutputRepresentation') {
+const TTL$4 = 1000;
+const VERSION$4 = "9a106f486843ccdb3e85594fb33ef97f";
+function validate$6(obj, path = 'DecisionTableTemplateDefinitionOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -943,7 +943,7 @@ function validate$5(obj, path = 'DecisionTableTemplateDefinitionOutputRepresenta
         if (obj.decisionTableTemplate !== undefined) {
             const obj_decisionTableTemplate = obj.decisionTableTemplate;
             const path_decisionTableTemplate = path + '.decisionTableTemplate';
-            const referencepath_decisionTableTemplateValidationError = validate$c(obj_decisionTableTemplate, path_decisionTableTemplate);
+            const referencepath_decisionTableTemplateValidationError = validate$d(obj_decisionTableTemplate, path_decisionTableTemplate);
             if (referencepath_decisionTableTemplateValidationError !== null) {
                 let message = 'Object doesn\'t match DecisionTableDefinitionOutputRepresentation (at "' + path_decisionTableTemplate + '")\n';
                 message += referencepath_decisionTableTemplateValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -959,7 +959,7 @@ function validate$5(obj, path = 'DecisionTableTemplateDefinitionOutputRepresenta
             for (let i = 0; i < obj_errors.length; i++) {
                 const obj_errors_item = obj_errors[i];
                 const path_errors_item = path_errors + '[' + i + ']';
-                const referencepath_errors_itemValidationError = validate$7(obj_errors_item, path_errors_item);
+                const referencepath_errors_itemValidationError = validate$8(obj_errors_item, path_errors_item);
                 if (referencepath_errors_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ErrorOutputRepresentation (at "' + path_errors_item + '")\n';
                     message += referencepath_errors_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -970,62 +970,62 @@ function validate$5(obj, path = 'DecisionTableTemplateDefinitionOutputRepresenta
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$3 = 'DecisionTableTemplateDefinitionOutputRepresentation';
-function normalize$3(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$4 = 'DecisionTableTemplateDefinitionOutputRepresentation';
+function normalize$4(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$8 = function DecisionTableTemplateDefinitionOutputRepresentationSelect() {
+const select$a = function DecisionTableTemplateDefinitionOutputRepresentationSelect() {
     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 DecisionTableTemplateDefinitionOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$4 = function DecisionTableTemplateDefinitionOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$5(input);
+        const validateError = validate$6(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$3;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "DecisionTable", VERSION$3, RepresentationType$3, equals$3);
+    const ttlToUse = TTL$4;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "DecisionTable", 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 = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$3,
+        representationName: RepresentationType$4,
         mergeable: false
     });
 }
-function select$7(luvio, params) {
-    return select$8();
+function select$9(luvio, params) {
+    return select$a();
 }
-function keyBuilder$7(luvio, params) {
+function keyBuilder$8(luvio, params) {
     return keyPrefix + '::DecisionTableTemplateDefinitionOutputRepresentation:(' + 'templateName:' + params.urlParams.templateName + ')';
 }
-function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$3(storeKeyMap, luvio, response, () => keyBuilder$7(luvio, resourceParams));
+function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$4(storeKeyMap, luvio, response, () => keyBuilder$8(luvio, resourceParams));
 }
-function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$7(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$3, body);
+    const key = keyBuilder$8(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$4, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$7(),
+        node: select$9(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1037,18 +1037,18 @@ function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$2(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$7(luvio, params);
+    const key = keyBuilder$8(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$3,
+        ttl: TTL$4,
         namespace: keyPrefix,
-        version: VERSION$3,
-        representationName: RepresentationType$3
+        version: VERSION$4,
+        representationName: RepresentationType$4
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$4(config) {
+function createResourceRequest$5(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v66.0',
@@ -1062,60 +1062,60 @@ function createResourceRequest$4(config) {
     };
 }
-const adapterName$4 = 'getDecisionTableTemplate';
+const adapterName$5 = 'getDecisionTableTemplate';
 const getDecisionTableTemplate_ConfigPropertyMetadata = [
     generateParamConfigMetadata('templateName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getDecisionTableTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getDecisionTableTemplate_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$7(getDecisionTableTemplate_ConfigPropertyMetadata);
-function keyBuilder$6(luvio, config) {
-    const resourceParams = createResourceParams$4(config);
-    return keyBuilder$7(luvio, resourceParams);
+const getDecisionTableTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getDecisionTableTemplate_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$8(getDecisionTableTemplate_ConfigPropertyMetadata);
+function keyBuilder$7(luvio, config) {
+    const resourceParams = createResourceParams$5(config);
+    return keyBuilder$8(luvio, resourceParams);
 }
-function typeCheckConfig$4(untrustedConfig) {
+function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$7(untrustedConfig, config, getDecisionTableTemplate_ConfigPropertyMetadata);
+    typeCheckConfig$8(untrustedConfig, config, getDecisionTableTemplate_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$4(untrustedConfig);
+    const config = typeCheckConfig$5(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$2(luvio, config) {
-    createResourceParams$4(config);
-    return select$7();
+    createResourceParams$5(config);
+    return select$9();
 }
 function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$2(luvio, config, resourceParams, response) {
     const snapshot = ingestError$2(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$4(luvio, config, options) {
-    const resourceParams = createResourceParams$4(config);
-    const request = createResourceRequest$4(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(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1123,23 +1123,23 @@ function buildNetworkSnapshot$4(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
+    return buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$6(luvio, config),
+        recordId: keyBuilder$7(luvio, config),
         node: adapterFragment$2(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getDecisionTableTemplateAdapterFactory = (luvio) => function DecisionTable__getDecisionTableTemplate(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$4(untrustedConfig, getDecisionTableTemplate_ConfigPropertyNames);
+    const config = validateAdapterConfig$5(untrustedConfig, getDecisionTableTemplate_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -1148,7 +1148,7 @@ const getDecisionTableTemplateAdapterFactory = (luvio) => function DecisionTable
     buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
 };
-function validate$4(obj, path = 'DecisionTableRowInputRepresentation') {
+function validate$5(obj, path = 'DecisionTableRowInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1181,9 +1181,9 @@ function validate$4(obj, path = 'DecisionTableRowInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
-const TTL$2 = 1000;
-const VERSION$2 = "58833f5bd113747199f0032242bf21b6";
-function validate$3(obj, path = 'DecisionTableDataOutputRepresentation') {
+const TTL$3 = 1000;
+const VERSION$3 = "58833f5bd113747199f0032242bf21b6";
+function validate$4(obj, path = 'DecisionTableDataOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1210,68 +1210,68 @@ function validate$3(obj, path = 'DecisionTableDataOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$2 = 'DecisionTableDataOutputRepresentation';
-function keyBuilder$5(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$2 + ':' + config.errorFileId;
+const RepresentationType$3 = 'DecisionTableDataOutputRepresentation';
+function keyBuilder$6(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$3 + ':' + config.errorFileId;
 }
-function keyBuilderFromType$1(luvio, object) {
+function keyBuilderFromType$2(luvio, object) {
     const keyParams = {
         errorFileId: object.errorFileId
     };
-    return keyBuilder$5(luvio, keyParams);
+    return keyBuilder$6(luvio, keyParams);
 }
-function normalize$2(input, existing, path, luvio, store, timestamp) {
+function normalize$3(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$6 = function DecisionTableDataOutputRepresentationSelect() {
+const select$8 = function DecisionTableDataOutputRepresentationSelect() {
     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 DecisionTableDataOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$3 = function DecisionTableDataOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$3(input);
+        const validateError = validate$4(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$1(luvio, input);
-    const ttlToUse = TTL$2;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "DecisionTable", VERSION$2, RepresentationType$2, equals$2);
+    const key = keyBuilderFromType$2(luvio, input);
+    const ttlToUse = TTL$3;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "DecisionTable", 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$1(luvio, input);
+    const rootKey = keyBuilderFromType$2(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$2,
+        representationName: RepresentationType$3,
         mergeable: false
     });
 }
-function select$5(luvio, params) {
-    return select$6();
+function select$7(luvio, params) {
+    return select$8();
 }
-function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$2(storeKeyMap, luvio, response);
+function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$3(storeKeyMap, luvio, response);
 }
-function ingestSuccess$3(luvio, resourceParams, response) {
+function ingestSuccess$4(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$1(luvio, body);
-    luvio.storeIngest(key, ingest$2, body);
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$3, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$5(),
+        node: select$7(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1282,7 +1282,7 @@ function ingestSuccess$3(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$3(config) {
+function createResourceRequest$4(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v66.0',
@@ -1296,22 +1296,22 @@ function createResourceRequest$3(config) {
     };
 }
-const adapterName$3 = 'postDecisionTableRows';
+const adapterName$4 = 'postDecisionTableRows';
 const postDecisionTableRows_ConfigPropertyMetadata = [
     generateParamConfigMetadata('decisionTableId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('rows', false, 2 /* Body */, 4 /* Unsupported */, true),
 ];
-const postDecisionTableRows_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, postDecisionTableRows_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$7(postDecisionTableRows_ConfigPropertyMetadata);
-function typeCheckConfig$3(untrustedConfig) {
+const postDecisionTableRows_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, postDecisionTableRows_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$8(postDecisionTableRows_ConfigPropertyMetadata);
+function typeCheckConfig$4(untrustedConfig) {
     const config = {};
-    typeCheckConfig$7(untrustedConfig, config, postDecisionTableRows_ConfigPropertyMetadata);
+    typeCheckConfig$8(untrustedConfig, config, postDecisionTableRows_ConfigPropertyMetadata);
     const untrustedConfig_rows = untrustedConfig.rows;
     if (ArrayIsArray$1(untrustedConfig_rows)) {
         const untrustedConfig_rows_array = [];
         for (let i = 0, arrayLength = untrustedConfig_rows.length; i < arrayLength; i++) {
             const untrustedConfig_rows_item = untrustedConfig_rows[i];
-            const referenceDecisionTableRowInputRepresentationValidationError = validate$4(untrustedConfig_rows_item);
+            const referenceDecisionTableRowInputRepresentationValidationError = validate$5(untrustedConfig_rows_item);
             if (referenceDecisionTableRowInputRepresentationValidationError === null) {
                 untrustedConfig_rows_array.push(untrustedConfig_rows_item);
             }
@@ -1320,30 +1320,30 @@ function typeCheckConfig$3(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$3(untrustedConfig);
+    const config = typeCheckConfig$4(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$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$3(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$4(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1353,16 +1353,16 @@ function buildNetworkSnapshot$3(luvio, config, options) {
 }
 const postDecisionTableRowsAdapterFactory = (luvio) => {
     return function postDecisionTableRows(untrustedConfig) {
-        const config = validateAdapterConfig$3(untrustedConfig, postDecisionTableRows_ConfigPropertyNames);
+        const config = validateAdapterConfig$4(untrustedConfig, postDecisionTableRows_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "postDecisionTableRows"');
         }
-        return buildNetworkSnapshot$3(luvio, config);
+        return buildNetworkSnapshot$4(luvio, config);
     };
 };
-function validate$2(obj, path = 'DecisionTableRowOutputRepresentation') {
+function validate$3(obj, path = 'DecisionTableRowOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1390,9 +1390,9 @@ function validate$2(obj, path = 'DecisionTableRowOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
-const TTL$1 = 1000;
-const VERSION$1 = "10dd31535fc5c028227867bd30804643";
-function validate$1(obj, path = 'DecisionTableRowsListOutputRepresentation') {
+const TTL$2 = 1000;
+const VERSION$2 = "10dd31535fc5c028227867bd30804643";
+function validate$2(obj, path = 'DecisionTableRowsListOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1405,7 +1405,7 @@ function validate$1(obj, path = 'DecisionTableRowsListOutputRepresentation') {
         for (let i = 0; i < obj_rows.length; i++) {
             const obj_rows_item = obj_rows[i];
             const path_rows_item = path_rows + '[' + i + ']';
-            const referencepath_rows_itemValidationError = validate$2(obj_rows_item, path_rows_item);
+            const referencepath_rows_itemValidationError = validate$3(obj_rows_item, path_rows_item);
             if (referencepath_rows_itemValidationError !== null) {
                 let message = 'Object doesn\'t match DecisionTableRowOutputRepresentation (at "' + path_rows_item + '")\n';
                 message += referencepath_rows_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1441,62 +1441,62 @@ function validate$1(obj, path = 'DecisionTableRowsListOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$1 = 'DecisionTableRowsListOutputRepresentation';
-function normalize$1(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$2 = 'DecisionTableRowsListOutputRepresentation';
+function normalize$2(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$4 = function DecisionTableRowsListOutputRepresentationSelect() {
+const select$6 = function DecisionTableRowsListOutputRepresentationSelect() {
     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 DecisionTableRowsListOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$2 = function DecisionTableRowsListOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$1(input);
+        const validateError = validate$2(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$1;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "DecisionTable", VERSION$1, RepresentationType$1, equals$1);
+    const ttlToUse = TTL$2;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "DecisionTable", 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 = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$1,
+        representationName: RepresentationType$2,
         mergeable: false
     });
 }
-function select$3(luvio, params) {
-    return select$4();
+function select$5(luvio, params) {
+    return select$6();
 }
-function keyBuilder$4(luvio, params) {
+function keyBuilder$5(luvio, params) {
     return keyPrefix + '::DecisionTableRowsListOutputRepresentation:(' + 'filter:' + params.queryParams.filter + ',' + 'limit:' + params.queryParams.limit + ',' + 'offset:' + params.queryParams.offset + ',' + 'decisionTableId:' + params.urlParams.decisionTableId + ')';
 }
-function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$1(storeKeyMap, luvio, response, () => keyBuilder$4(luvio, resourceParams));
+function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response, () => keyBuilder$5(luvio, resourceParams));
 }
-function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$4(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$1, body);
+    const key = keyBuilder$5(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$2, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$3(),
+        node: select$5(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1508,18 +1508,18 @@ function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$1(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$4(luvio, params);
+    const key = keyBuilder$5(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$1,
+        ttl: TTL$2,
         namespace: keyPrefix,
-        version: VERSION$1,
-        representationName: RepresentationType$1
+        version: VERSION$2,
+        representationName: RepresentationType$2
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$2(config) {
+function createResourceRequest$3(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v66.0',
@@ -1533,63 +1533,63 @@ function createResourceRequest$2(config) {
     };
 }
-const adapterName$2 = 'getDecisionTableRows';
+const adapterName$3 = 'getDecisionTableRows';
 const getDecisionTableRows_ConfigPropertyMetadata = [
     generateParamConfigMetadata('decisionTableId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('filter', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('limit', false, 1 /* QueryParameter */, 3 /* Integer */),
     generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
 ];
-const getDecisionTableRows_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getDecisionTableRows_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$7(getDecisionTableRows_ConfigPropertyMetadata);
-function keyBuilder$3(luvio, config) {
-    const resourceParams = createResourceParams$2(config);
-    return keyBuilder$4(luvio, resourceParams);
+const getDecisionTableRows_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getDecisionTableRows_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$8(getDecisionTableRows_ConfigPropertyMetadata);
+function keyBuilder$4(luvio, config) {
+    const resourceParams = createResourceParams$3(config);
+    return keyBuilder$5(luvio, resourceParams);
 }
-function typeCheckConfig$2(untrustedConfig) {
+function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$7(untrustedConfig, config, getDecisionTableRows_ConfigPropertyMetadata);
+    typeCheckConfig$8(untrustedConfig, config, getDecisionTableRows_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$2(untrustedConfig);
+    const config = typeCheckConfig$3(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$1(luvio, config) {
-    createResourceParams$2(config);
-    return select$3();
+    createResourceParams$3(config);
+    return select$5();
 }
 function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$2(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$1(luvio, config, resourceParams, response) {
     const snapshot = ingestError$1(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$2(luvio, config, options) {
-    const resourceParams = createResourceParams$2(config);
-    const request = createResourceRequest$2(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(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1597,23 +1597,23 @@ function buildNetworkSnapshot$2(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
+    return buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$3(luvio, config),
+        recordId: keyBuilder$4(luvio, config),
         node: adapterFragment$1(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getDecisionTableRowsAdapterFactory = (luvio) => function DecisionTable__getDecisionTableRows(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$2(untrustedConfig, getDecisionTableRows_ConfigPropertyNames);
+    const config = validateAdapterConfig$3(untrustedConfig, getDecisionTableRows_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -1622,9 +1622,9 @@ const getDecisionTableRowsAdapterFactory = (luvio) => function DecisionTable__ge
     buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
 };
-const TTL = 1000;
-const VERSION = "581abdd509fd88568bfa17b4a220d8db";
-function validate(obj, path = 'DecisionTableFileOutputRepresentation') {
+const TTL$1 = 1000;
+const VERSION$1 = "581abdd509fd88568bfa17b4a220d8db";
+function validate$1(obj, path = 'DecisionTableFileOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1637,71 +1637,71 @@ function validate(obj, path = 'DecisionTableFileOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType = 'DecisionTableFileOutputRepresentation';
-function keyBuilder$2(luvio, config) {
-    return keyPrefix + '::' + RepresentationType + ':' + config.message;
+const RepresentationType$1 = 'DecisionTableFileOutputRepresentation';
+function keyBuilder$3(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$1 + ':' + config.message;
 }
-function keyBuilderFromType(luvio, object) {
+function keyBuilderFromType$1(luvio, object) {
     const keyParams = {
         message: object.message
     };
-    return keyBuilder$2(luvio, keyParams);
+    return keyBuilder$3(luvio, keyParams);
 }
-function normalize(input, existing, path, luvio, store, timestamp) {
+function normalize$1(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$2 = function DecisionTableFileOutputRepresentationSelect() {
+const select$4 = function DecisionTableFileOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION,
+        version: VERSION$1,
         private: [],
         opaque: true
     };
 };
-function equals(existing, incoming) {
+function equals$1(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest = function DecisionTableFileOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$1 = function DecisionTableFileOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate(input);
+        const validateError = validate$1(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType(luvio, input);
-    const ttlToUse = TTL;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "DecisionTable", VERSION, RepresentationType, equals);
+    const key = keyBuilderFromType$1(luvio, input);
+    const ttlToUse = TTL$1;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "DecisionTable", VERSION$1, RepresentationType$1, equals$1);
     return createLink(key);
 };
-function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType(luvio, input);
+    const rootKey = keyBuilderFromType$1(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType,
+        representationName: RepresentationType$1,
         mergeable: false
     });
 }
-function select$1(luvio, params) {
-    return select$2();
+function select$3(luvio, params) {
+    return select$4();
 }
-function keyBuilder$1(luvio, params) {
+function keyBuilder$2(luvio, params) {
     return keyPrefix + '::DecisionTableFileOutputRepresentation:(' + 'filter:' + params.queryParams.filter + ',' + 'decisionTableId:' + params.urlParams.decisionTableId + ')';
 }
-function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys(storeKeyMap, luvio, response);
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$1(storeKeyMap, luvio, response);
 }
-function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$1(luvio, resourceParams);
-    luvio.storeIngest(key, ingest, body);
+    const key = keyBuilder$2(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$1, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$1(),
+        node: select$3(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1713,18 +1713,18 @@ function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$1(luvio, params);
+    const key = keyBuilder$2(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL,
+        ttl: TTL$1,
         namespace: keyPrefix,
-        version: VERSION,
-        representationName: RepresentationType
+        version: VERSION$1,
+        representationName: RepresentationType$1
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$1(config) {
+function createResourceRequest$2(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v66.0',
@@ -1738,61 +1738,61 @@ function createResourceRequest$1(config) {
     };
 }
-const adapterName$1 = 'getDecisionTableFile';
+const adapterName$2 = 'getDecisionTableFile';
 const getDecisionTableFile_ConfigPropertyMetadata = [
     generateParamConfigMetadata('decisionTableId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('filter', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getDecisionTableFile_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getDecisionTableFile_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$7(getDecisionTableFile_ConfigPropertyMetadata);
-function keyBuilder(luvio, config) {
-    const resourceParams = createResourceParams$1(config);
-    return keyBuilder$1(luvio, resourceParams);
+const getDecisionTableFile_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getDecisionTableFile_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$8(getDecisionTableFile_ConfigPropertyMetadata);
+function keyBuilder$1(luvio, config) {
+    const resourceParams = createResourceParams$2(config);
+    return keyBuilder$2(luvio, resourceParams);
 }
-function typeCheckConfig$1(untrustedConfig) {
+function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$7(untrustedConfig, config, getDecisionTableFile_ConfigPropertyMetadata);
+    typeCheckConfig$8(untrustedConfig, config, getDecisionTableFile_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$1(untrustedConfig);
+    const config = typeCheckConfig$2(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment(luvio, config) {
-    createResourceParams$1(config);
-    return select$1();
+    createResourceParams$2(config);
+    return select$3();
 }
 function onFetchResponseSuccess(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$2(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError(luvio, config, resourceParams, response) {
     const snapshot = ingestError(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$1(luvio, config, options) {
-    const resourceParams = createResourceParams$1(config);
-    const request = createResourceRequest$1(resourceParams);
+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(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1800,23 +1800,23 @@ function buildNetworkSnapshot$1(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext, buildNetworkSnapshot$1, undefined, false);
+    return buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder(luvio, config),
+        recordId: keyBuilder$1(luvio, config),
         node: adapterFragment(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getDecisionTableFileAdapterFactory = (luvio) => function DecisionTable__getDecisionTableFile(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$1(untrustedConfig, getDecisionTableFile_ConfigPropertyNames);
+    const config = validateAdapterConfig$2(untrustedConfig, getDecisionTableFile_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -1825,8 +1825,169 @@ const getDecisionTableFileAdapterFactory = (luvio) => function DecisionTable__ge
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
+function select$2(luvio, params) {
+    return select$4();
+}
+function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$1(storeKeyMap, luvio, response);
+}
+function ingestSuccess$1(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$2(),
+        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/v66.0',
+        basePath: '/connect/business-rules/decision-table/' + config.urlParams.decisionTableId + '/file',
+        method: 'post',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+const adapterName$1 = 'postDecisionTableFile';
+const postDecisionTableFile_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('decisionTableId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('deleteAllRows', false, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('fileId', true, 2 /* Body */, 0 /* String */),
+];
+const postDecisionTableFile_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, postDecisionTableFile_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$8(postDecisionTableFile_ConfigPropertyMetadata);
+function typeCheckConfig$1(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$8(untrustedConfig, config, postDecisionTableFile_ConfigPropertyMetadata);
+    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 postDecisionTableFileAdapterFactory = (luvio) => {
+    return function postDecisionTableFile(untrustedConfig) {
+        const config = validateAdapterConfig$1(untrustedConfig, postDecisionTableFile_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "postDecisionTableFile"');
+        }
+        return buildNetworkSnapshot$1(luvio, config);
+    };
+};
+const TTL = 1000;
+const VERSION = "b0d141e11ef33593ddcf5bb30203b031";
+function validate(obj, path = 'DecisionTableRefreshOutput') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_errorMessage = obj.errorMessage;
+        const path_errorMessage = path + '.errorMessage';
+        if (typeof obj_errorMessage !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_errorMessage + '" (at "' + path_errorMessage + '")');
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        if (typeof obj_status !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'DecisionTableRefreshOutput';
+function keyBuilder(luvio, config) {
+    return keyPrefix + '::' + RepresentationType + ':' + config.errorMessage;
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        errorMessage: object.errorMessage
+    };
+    return keyBuilder(luvio, keyParams);
+}
+function normalize(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$1 = function DecisionTableRefreshOutputSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        opaque: true
+    };
+};
+function equals(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest = function DecisionTableRefreshOutputIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType(luvio, input);
+    const ttlToUse = TTL;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "DecisionTable", VERSION, RepresentationType, equals);
+    return createLink(key);
+};
+function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType,
+        mergeable: false
+    });
+}
 function select(luvio, params) {
-    return select$2();
+    return select$1();
 }
 function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys(storeKeyMap, luvio, response);
@@ -1852,27 +2013,40 @@ function createResourceRequest(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v66.0',
-        basePath: '/connect/business-rules/decision-table/' + config.urlParams.decisionTableId + '/file',
+        basePath: '/connect/decision-table/refresh',
         method: 'post',
         body: config.body,
-        urlParams: config.urlParams,
+        urlParams: {},
         queryParams: {},
         headers,
         priority: 'normal',
     };
 }
-const adapterName = 'postDecisionTableFile';
-const postDecisionTableFile_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('decisionTableId', true, 0 /* UrlParameter */, 0 /* String */),
-    generateParamConfigMetadata('deleteAllRows', false, 2 /* Body */, 1 /* Boolean */),
-    generateParamConfigMetadata('fileId', true, 2 /* Body */, 0 /* String */),
+const adapterName = 'refreshDecisionTable';
+const refreshDecisionTable_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('decisionTableId', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('instantRefreshRecordsIds', false, 2 /* Body */, 4 /* Unsupported */, true),
 ];
-const postDecisionTableFile_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, postDecisionTableFile_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$7(postDecisionTableFile_ConfigPropertyMetadata);
+const refreshDecisionTable_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, refreshDecisionTable_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$8(refreshDecisionTable_ConfigPropertyMetadata);
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$7(untrustedConfig, config, postDecisionTableFile_ConfigPropertyMetadata);
+    typeCheckConfig$8(untrustedConfig, config, refreshDecisionTable_ConfigPropertyMetadata);
+    const untrustedConfig_instantRefreshRecordsIds = untrustedConfig.instantRefreshRecordsIds;
+    if (ArrayIsArray$1(untrustedConfig_instantRefreshRecordsIds)) {
+        const untrustedConfig_instantRefreshRecordsIds_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_instantRefreshRecordsIds.length; i < arrayLength; i++) {
+            const untrustedConfig_instantRefreshRecordsIds_item = untrustedConfig_instantRefreshRecordsIds[i];
+            if (typeof untrustedConfig_instantRefreshRecordsIds_item === 'string') {
+                untrustedConfig_instantRefreshRecordsIds_array.push(untrustedConfig_instantRefreshRecordsIds_item);
+            }
+            if (untrustedConfig_instantRefreshRecordsIds_item === null) {
+                untrustedConfig_instantRefreshRecordsIds_array.push(untrustedConfig_instantRefreshRecordsIds_item);
+            }
+        }
+        config.instantRefreshRecordsIds = untrustedConfig_instantRefreshRecordsIds_array;
+    }
     return config;
 }
 function validateAdapterConfig(untrustedConfig, configPropertyNames) {
@@ -1906,15 +2080,15 @@ function buildNetworkSnapshot(luvio, config, options) {
         throw response;
     });
 }
-const postDecisionTableFileAdapterFactory = (luvio) => {
-    return function postDecisionTableFile(untrustedConfig) {
-        const config = validateAdapterConfig(untrustedConfig, postDecisionTableFile_ConfigPropertyNames);
+const refreshDecisionTableAdapterFactory = (luvio) => {
+    return function refreshDecisionTable(untrustedConfig) {
+        const config = validateAdapterConfig(untrustedConfig, refreshDecisionTable_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error('Invalid config for "postDecisionTableFile"');
+            throw new Error('Invalid config for "refreshDecisionTable"');
         }
         return buildNetworkSnapshot(luvio, config);
     };
 };
-export { getDecisionTableAdapterFactory, getDecisionTableFileAdapterFactory, getDecisionTableRowsAdapterFactory, getDecisionTableTemplateAdapterFactory, getDecisionTableTemplateListAdapterFactory, postDecisionTableFileAdapterFactory, postDecisionTableRowsAdapterFactory };
+export { getDecisionTableAdapterFactory, getDecisionTableFileAdapterFactory, getDecisionTableRowsAdapterFactory, getDecisionTableTemplateAdapterFactory, getDecisionTableTemplateListAdapterFactory, postDecisionTableFileAdapterFactory, postDecisionTableRowsAdapterFactory, refreshDecisionTableAdapterFactory };