@salesforce/lds-adapters-industries-rule-builder 1.212.1 → 1.213.1

package/dist/es/es2018/industries-rule-builder.js

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, deepFreeze, StoreKeyMap, typeCheckScalars, typeCheckArrayOfScalars } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, typeCheckScalars, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$h, typeCheckArrayOfScalars } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -48,6 +48,24 @@ const snapshotRefreshOptions = {
         },
     }
 };
+function generateParamConfigMetadata(name, required, coerceFn) {
+    return {
+        name,
+        required,
+        coerceFn,
+    };
+}
+function buildAdapterValidationConfig(displayName, paramsMeta) {
+    const required = paramsMeta.filter(p => p.required).map(p => p.name);
+    const optional = paramsMeta.filter(p => !p.required).map(p => p.name);
+    return {
+        displayName,
+        parameters: {
+            required,
+            optional,
+        }
+    };
+}
 const keyPrefix = 'interaction';
 
 const { keys: ObjectKeys, create: ObjectCreate, assign: ObjectAssign } = Object;
@@ -856,26 +874,8 @@ const ingest$k = function ExpressionSetOutputRepresentationIngest(input, path, l
         }
     }
     const key = keyBuilderFromType$6(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$h;
-    let incomingRecord = normalize$k(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$l(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$l,
-            representationName: RepresentationType$k,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$k, "interaction", VERSION$l, RepresentationType$k, equals$l);
     return createLink(key);
 };
 function getTypeCacheKeys$k(rootKeySet, luvio, input, fullPathFactory) {
@@ -925,13 +925,11 @@ function createResourceRequest$p(config) {
     };
 }
 
-const createExpressionSet_ConfigPropertyNames = {
-    displayName: 'createExpressionSet',
-    parameters: {
-        required: ['esInputRepresentationObject'],
-        optional: []
-    }
-};
+const adapterName$p = 'createExpressionSet';
+const createExpressionSet_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('esInputRepresentationObject', true),
+];
+const createExpressionSet_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$p, createExpressionSet_ConfigPropertyMetadata);
 function createResourceParams$p(config) {
     const resourceParams = {
         body: {
@@ -1022,14 +1020,11 @@ function createResourceRequest$o(config) {
     };
 }
 
-const adapterName = 'deleteExpressionSet';
-const deleteExpressionSet_ConfigPropertyNames = {
-    displayName: 'deleteExpressionSet',
-    parameters: {
-        required: ['expressionSetId'],
-        optional: []
-    }
-};
+const adapterName$o = 'deleteExpressionSet';
+const deleteExpressionSet_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('expressionSetId', true),
+];
+const deleteExpressionSet_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$o, deleteExpressionSet_ConfigPropertyMetadata);
 function createResourceParams$o(config) {
     const resourceParams = {
         urlParams: {
@@ -1081,7 +1076,7 @@ const deleteExpressionSetAdapterFactory = (luvio) => {
         const config = validateAdapterConfig$o(untrustedConfig, deleteExpressionSet_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName}"`);
+            throw new Error(`Invalid config for "${adapterName$o}"`);
         }
         return buildNetworkSnapshot$o(luvio, config);
     };
@@ -1141,13 +1136,11 @@ function createResourceRequest$n(config) {
     };
 }
 
-const getExpressionSet_ConfigPropertyNames = {
-    displayName: 'getExpressionSet',
-    parameters: {
-        required: ['expressionSetId'],
-        optional: []
-    }
-};
+const adapterName$n = 'getExpressionSet';
+const getExpressionSet_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('expressionSetId', true),
+];
+const getExpressionSet_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$n, getExpressionSet_ConfigPropertyMetadata);
 function createResourceParams$n(config) {
     const resourceParams = {
         urlParams: {
@@ -1213,21 +1206,7 @@ function buildNetworkSnapshot$n(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$n(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$n, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$g(context, storeLookup) {
     const { luvio, config } = context;
@@ -1289,13 +1268,12 @@ function createResourceRequest$m(config) {
     };
 }
 
-const updateExpressionSet_ConfigPropertyNames = {
-    displayName: 'updateExpressionSet',
-    parameters: {
-        required: ['expressionSetId', 'esInputRepresentationObject'],
-        optional: []
-    }
-};
+const adapterName$m = 'updateExpressionSet';
+const updateExpressionSet_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('expressionSetId', true),
+    generateParamConfigMetadata('esInputRepresentationObject', true),
+];
+const updateExpressionSet_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$m, updateExpressionSet_ConfigPropertyMetadata);
 function createResourceParams$m(config) {
     const resourceParams = {
         urlParams: {
@@ -1463,26 +1441,8 @@ const ingest$j = function ExplainabilityLogsRepresentationIngest(input, path, lu
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$g;
-    let incomingRecord = normalize$j(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$k(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$k,
-            representationName: RepresentationType$j,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$j, "interaction", VERSION$k, RepresentationType$j, equals$k);
     return createLink(key);
 };
 function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
@@ -1547,13 +1507,18 @@ function createResourceRequest$l(config) {
     };
 }
 
-const getExplainabilityLogs_ConfigPropertyNames = {
-    displayName: 'getExplainabilityLogs',
-    parameters: {
-        required: [],
-        optional: ['actionContextCode', 'applicationSubType', 'applicationType', 'createdAfter', 'createdBefore', 'pageSize', 'processType', 'queryMore']
-    }
-};
+const adapterName$l = 'getExplainabilityLogs';
+const getExplainabilityLogs_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('actionContextCode', false),
+    generateParamConfigMetadata('applicationSubType', false),
+    generateParamConfigMetadata('applicationType', false),
+    generateParamConfigMetadata('createdAfter', false),
+    generateParamConfigMetadata('createdBefore', false),
+    generateParamConfigMetadata('pageSize', false),
+    generateParamConfigMetadata('processType', false),
+    generateParamConfigMetadata('queryMore', false),
+];
+const getExplainabilityLogs_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$l, getExplainabilityLogs_ConfigPropertyMetadata);
 function createResourceParams$l(config) {
     const resourceParams = {
         queryParams: {
@@ -1626,21 +1591,7 @@ function buildNetworkSnapshot$l(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$l(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$l, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$f(context, storeLookup) {
     const { luvio, config } = context;
@@ -1731,26 +1682,8 @@ const ingest$i = function MessageTemplateDetailOutputRepresentationIngest(input,
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$f;
-    let incomingRecord = normalize$i(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$j(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$j,
-            representationName: RepresentationType$i,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$i, "interaction", VERSION$j, RepresentationType$i, equals$j);
     return createLink(key);
 };
 function getTypeCacheKeys$i(rootKeySet, luvio, input, fullPathFactory) {
@@ -1837,26 +1770,8 @@ const ingest$h = function MessageTemplatesListOutputRepresentationIngest(input,
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$e;
-    let incomingRecord = normalize$h(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$i(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$i,
-            representationName: RepresentationType$h,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$h, "interaction", VERSION$i, RepresentationType$h, equals$i);
     return createLink(key);
 };
 function getTypeCacheKeys$h(rootKeySet, luvio, input, fullPathFactory) {
@@ -1921,13 +1836,14 @@ function createResourceRequest$k(config) {
     };
 }
 
-const searchMessageTemplates_ConfigPropertyNames = {
-    displayName: 'searchMessageTemplates',
-    parameters: {
-        required: [],
-        optional: ['isDefault', 'messageType', 'searchKey', 'stepType']
-    }
-};
+const adapterName$k = 'searchMessageTemplates';
+const searchMessageTemplates_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('isDefault', false),
+    generateParamConfigMetadata('messageType', false),
+    generateParamConfigMetadata('searchKey', false),
+    generateParamConfigMetadata('stepType', false),
+];
+const searchMessageTemplates_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$k, searchMessageTemplates_ConfigPropertyMetadata);
 function createResourceParams$k(config) {
     const resourceParams = {
         queryParams: {
@@ -1996,21 +1912,7 @@ function buildNetworkSnapshot$k(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$e(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$k(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$k, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
     const { luvio, config } = context;
@@ -2087,13 +1989,11 @@ function createResourceRequest$j(config) {
     };
 }
 
-const getMessageTemplateDetail_ConfigPropertyNames = {
-    displayName: 'getMessageTemplateDetail',
-    parameters: {
-        required: ['messageTemplateId'],
-        optional: []
-    }
-};
+const adapterName$j = 'getMessageTemplateDetail';
+const getMessageTemplateDetail_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('messageTemplateId', true),
+];
+const getMessageTemplateDetail_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$j, getMessageTemplateDetail_ConfigPropertyMetadata);
 function createResourceParams$j(config) {
     const resourceParams = {
         urlParams: {
@@ -2159,21 +2059,7 @@ function buildNetworkSnapshot$j(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$d(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$j(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$j, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$d(context, storeLookup) {
     const { luvio, config } = context;
@@ -2684,26 +2570,8 @@ const ingest$g = function SimulationEvalServiceOutputRepresentationIngest(input,
         }
     }
     const key = keyBuilderFromType$5(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 360000;
-    let incomingRecord = normalize$g(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$h(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$h,
-            representationName: RepresentationType$g,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$g, "interaction", VERSION$h, RepresentationType$g, equals$h);
     return createLink(key);
 };
 function getTypeCacheKeys$g(rootKeySet, luvio, input, fullPathFactory) {
@@ -2799,26 +2667,8 @@ const ingest$f = function BusinessRulesResultRepresentationIngest(input, path, l
         }
     }
     const key = keyBuilderFromType$4(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$d;
-    let incomingRecord = normalize$f(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$g(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$g,
-            representationName: RepresentationType$f,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$f, "interaction", VERSION$g, RepresentationType$f, equals$g);
     return createLink(key);
 };
 function getTypeCacheKeys$f(rootKeySet, luvio, input, fullPathFactory) {
@@ -2868,13 +2718,12 @@ function createResourceRequest$i(config) {
     };
 }
 
-const postInvokeExpressionSet_ConfigPropertyNames = {
-    displayName: 'postInvokeExpressionSet',
-    parameters: {
-        required: ['expressionSetName', 'ruleInput'],
-        optional: []
-    }
-};
+const adapterName$i = 'postInvokeExpressionSet';
+const postInvokeExpressionSet_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('expressionSetName', true),
+    generateParamConfigMetadata('ruleInput', true),
+];
+const postInvokeExpressionSet_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$i, postInvokeExpressionSet_ConfigPropertyMetadata);
 function createResourceParams$i(config) {
     const resourceParams = {
         urlParams: {
@@ -3238,26 +3087,8 @@ const ingest$e = function LookupTablesResultListRepresentationIngest(input, path
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 360000;
-    let incomingRecord = normalize$e(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$e(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$e,
-            representationName: RepresentationType$e,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$e, "interaction", VERSION$e, RepresentationType$e, equals$e);
     return createLink(key);
 };
 function getTypeCacheKeys$e(rootKeySet, luvio, input, fullPathFactory) {
@@ -3316,13 +3147,13 @@ function createResourceRequest$h(config) {
     };
 }
 
-const getLookupTables_ConfigPropertyNames = {
-    displayName: 'getLookupTables',
-    parameters: {
-        required: ['searchKey', 'usageType'],
-        optional: ['lookupTypes']
-    }
-};
+const adapterName$h = 'getLookupTables';
+const getLookupTables_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('lookupTypes', false),
+    generateParamConfigMetadata('searchKey', true),
+    generateParamConfigMetadata('usageType', true),
+];
+const getLookupTables_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$h, getLookupTables_ConfigPropertyMetadata);
 function createResourceParams$h(config) {
     const resourceParams = {
         queryParams: {
@@ -3392,21 +3223,7 @@ function buildNetworkSnapshot$h(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$c(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$h(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$h, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$c(context, storeLookup) {
     const { luvio, config } = context;
@@ -3535,26 +3352,8 @@ const ingest$d = function DecisionTableResultListRepresentationIngest(input, pat
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$c;
-    let incomingRecord = normalize$d(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$d(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$d,
-            representationName: RepresentationType$d,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$d, "interaction", VERSION$d, RepresentationType$d, equals$d);
     return createLink(key);
 };
 function getTypeCacheKeys$d(rootKeySet, luvio, input, fullPathFactory) {
@@ -3619,13 +3418,11 @@ function createResourceRequest$g(config) {
     };
 }
 
-const searchDecisionTableByName_ConfigPropertyNames = {
-    displayName: 'searchDecisionTableByName',
-    parameters: {
-        required: ['searchKey'],
-        optional: []
-    }
-};
+const adapterName$g = 'searchDecisionTableByName';
+const searchDecisionTableByName_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('searchKey', true),
+];
+const searchDecisionTableByName_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$g, searchDecisionTableByName_ConfigPropertyMetadata);
 function createResourceParams$g(config) {
     const resourceParams = {
         queryParams: {
@@ -3691,21 +3488,7 @@ function buildNetworkSnapshot$g(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$b(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$g(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$g, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$b(context, storeLookup) {
     const { luvio, config } = context;
@@ -3875,26 +3658,8 @@ const ingest$c = function DecisionTableResultRepresentationIngest(input, path, l
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$b;
-    let incomingRecord = normalize$c(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$c(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$c,
-            representationName: RepresentationType$c,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$c, "interaction", VERSION$c, RepresentationType$c, equals$c);
     return createLink(key);
 };
 function getTypeCacheKeys$c(rootKeySet, luvio, input, fullPathFactory) {
@@ -3959,13 +3724,12 @@ function createResourceRequest$f(config) {
     };
 }
 
-const getDecisionTableDetails_ConfigPropertyNames = {
-    displayName: 'getDecisionTableDetails',
-    parameters: {
-        required: ['decisionTableId'],
-        optional: ['isBuilderApi']
-    }
-};
+const adapterName$f = 'getDecisionTableDetails';
+const getDecisionTableDetails_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('decisionTableId', true),
+    generateParamConfigMetadata('isBuilderApi', false),
+];
+const getDecisionTableDetails_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, getDecisionTableDetails_ConfigPropertyMetadata);
 function createResourceParams$f(config) {
     const resourceParams = {
         urlParams: {
@@ -4035,21 +3799,7 @@ function buildNetworkSnapshot$f(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$f(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$f, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     const { luvio, config } = context;
@@ -4185,26 +3935,8 @@ const ingest$b = function CalculationProcedureListOutputRepresentationIngest(inp
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$a;
-    let incomingRecord = normalize$b(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$b(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$b,
-            representationName: RepresentationType$b,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$b, "interaction", VERSION$b, RepresentationType$b, equals$b);
     return createLink(key);
 };
 function getTypeCacheKeys$b(rootKeySet, luvio, input, fullPathFactory) {
@@ -4269,13 +4001,12 @@ function createResourceRequest$e(config) {
     };
 }
 
-const searchCalculationProcedure_ConfigPropertyNames = {
-    displayName: 'searchCalculationProcedure',
-    parameters: {
-        required: ['searchKey'],
-        optional: ['usageType']
-    }
-};
+const adapterName$e = 'searchCalculationProcedure';
+const searchCalculationProcedure_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('searchKey', true),
+    generateParamConfigMetadata('usageType', false),
+];
+const searchCalculationProcedure_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, searchCalculationProcedure_ConfigPropertyMetadata);
 function createResourceParams$e(config) {
     const resourceParams = {
         queryParams: {
@@ -4342,21 +4073,7 @@ function buildNetworkSnapshot$e(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$e(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$e, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
     const { luvio, config } = context;
@@ -5531,26 +5248,8 @@ const ingest$a = function CalculationProcedureVersionDefinitionOutputRepresentat
         }
     }
     const key = keyBuilderFromType$3(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$9;
-    let incomingRecord = normalize$a(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$a(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$a,
-            representationName: RepresentationType$a,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$a, "interaction", VERSION$a, RepresentationType$a, equals$a);
     return createLink(key);
 };
 function getTypeCacheKeys$a(rootKeySet, luvio, input, fullPathFactory) {
@@ -5600,13 +5299,11 @@ function createResourceRequest$d(config) {
     };
 }
 
-const postCalcProcVersionDetails_ConfigPropertyNames = {
-    displayName: 'postCalcProcVersionDetails',
-    parameters: {
-        required: ['calculationProcedureDefinition'],
-        optional: []
-    }
-};
+const adapterName$d = 'postCalcProcVersionDetails';
+const postCalcProcVersionDetails_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('calculationProcedureDefinition', true),
+];
+const postCalcProcVersionDetails_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, postCalcProcVersionDetails_ConfigPropertyMetadata);
 function createResourceParams$d(config) {
     const resourceParams = {
         body: {
@@ -5720,13 +5417,11 @@ function createResourceRequest$c(config) {
     };
 }
 
-const getCalcProcVersionDetails_ConfigPropertyNames = {
-    displayName: 'getCalcProcVersionDetails',
-    parameters: {
-        required: ['id'],
-        optional: []
-    }
-};
+const adapterName$c = 'getCalcProcVersionDetails';
+const getCalcProcVersionDetails_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+];
+const getCalcProcVersionDetails_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, getCalcProcVersionDetails_ConfigPropertyMetadata);
 function createResourceParams$c(config) {
     const resourceParams = {
         urlParams: {
@@ -5792,21 +5487,7 @@ function buildNetworkSnapshot$c(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$c(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$c, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
@@ -5901,26 +5582,8 @@ const ingest$9 = function CalculationProcedureActivationOutputRepresentationInge
         }
     }
     const key = keyBuilderFromType$2(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 360000;
-    let incomingRecord = normalize$9(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$9(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$9,
-            representationName: RepresentationType$9,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$9, "interaction", VERSION$9, RepresentationType$9, equals$9);
     return createLink(key);
 };
 function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
@@ -5970,13 +5633,12 @@ function createResourceRequest$b(config) {
     };
 }
 
-const activateCalcProcedureVersion_ConfigPropertyNames = {
-    displayName: 'activateCalcProcedureVersion',
-    parameters: {
-        required: ['id'],
-        optional: ['action']
-    }
-};
+const adapterName$b = 'activateCalcProcedureVersion';
+const activateCalcProcedureVersion_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+    generateParamConfigMetadata('action', false),
+];
+const activateCalcProcedureVersion_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, activateCalcProcedureVersion_ConfigPropertyMetadata);
 function createResourceParams$b(config) {
     const resourceParams = {
         urlParams: {
@@ -6186,26 +5848,8 @@ const ingest$8 = function CalculationProcedureDetailOutputRepresentationIngest(i
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$8;
-    let incomingRecord = normalize$8(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$8(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$8,
-            representationName: RepresentationType$8,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$8, "interaction", VERSION$8, RepresentationType$8, equals$8);
     return createLink(key);
 };
 function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
@@ -6270,13 +5914,11 @@ function createResourceRequest$a(config) {
     };
 }
 
-const getCalcProcDetails_ConfigPropertyNames = {
-    displayName: 'getCalcProcDetails',
-    parameters: {
-        required: ['id'],
-        optional: []
-    }
-};
+const adapterName$a = 'getCalcProcDetails';
+const getCalcProcDetails_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+];
+const getCalcProcDetails_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, getCalcProcDetails_ConfigPropertyMetadata);
 function createResourceParams$a(config) {
     const resourceParams = {
         urlParams: {
@@ -6342,21 +5984,7 @@ function buildNetworkSnapshot$a(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$a(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$a, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
@@ -6496,26 +6124,8 @@ const ingest$7 = function SimulationInputVariablesResultListRepresentationIngest
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$7;
-    let incomingRecord = normalize$7(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$7(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$7,
-            representationName: RepresentationType$7,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$7, "interaction", VERSION$7, RepresentationType$7, equals$7);
     return createLink(key);
 };
 function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
@@ -6580,13 +6190,12 @@ function createResourceRequest$9(config) {
     };
 }
 
-const getSimulationInputVariables_ConfigPropertyNames = {
-    displayName: 'getSimulationInputVariables',
-    parameters: {
-        required: ['id'],
-        optional: ['inputVariables']
-    }
-};
+const adapterName$9 = 'getSimulationInputVariables';
+const getSimulationInputVariables_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+    generateParamConfigMetadata('inputVariables', false),
+];
+const getSimulationInputVariables_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getSimulationInputVariables_ConfigPropertyMetadata);
 function createResourceParams$9(config) {
     const resourceParams = {
         urlParams: {
@@ -6656,21 +6265,7 @@ function buildNetworkSnapshot$9(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$9(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
@@ -6841,13 +6436,13 @@ function createResourceRequest$8(config) {
     };
 }
 
-const simulateEvaluationService_ConfigPropertyNames = {
-    displayName: 'simulateEvaluationService',
-    parameters: {
-        required: ['id', 'simulationInput'],
-        optional: ['shouldSaveSimulationInput']
-    }
-};
+const adapterName$8 = 'simulateEvaluationService';
+const simulateEvaluationService_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+    generateParamConfigMetadata('simulationInput', true),
+    generateParamConfigMetadata('shouldSaveSimulationInput', false),
+];
+const simulateEvaluationService_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, simulateEvaluationService_ConfigPropertyMetadata);
 function createResourceParams$8(config) {
     const resourceParams = {
         urlParams: {
@@ -7021,26 +6616,8 @@ const ingest$6 = function DecisionMatrixResultListRepresentationIngest(input, pa
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$6;
-    let incomingRecord = normalize$6(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$6(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$6,
-            representationName: RepresentationType$6,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$6, "interaction", VERSION$6, RepresentationType$6, equals$6);
     return createLink(key);
 };
 function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
@@ -7105,13 +6682,11 @@ function createResourceRequest$7(config) {
     };
 }
 
-const searchDecisionMatrixByName_ConfigPropertyNames = {
-    displayName: 'searchDecisionMatrixByName',
-    parameters: {
-        required: ['searchKey'],
-        optional: []
-    }
-};
+const adapterName$7 = 'searchDecisionMatrixByName';
+const searchDecisionMatrixByName_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('searchKey', true),
+];
+const searchDecisionMatrixByName_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, searchDecisionMatrixByName_ConfigPropertyMetadata);
 function createResourceParams$7(config) {
     const resourceParams = {
         queryParams: {
@@ -7177,21 +6752,7 @@ function buildNetworkSnapshot$7(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$7(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
@@ -7359,26 +6920,8 @@ const ingest$5 = function DecisionMatrixResultRepresentationIngest(input, path,
         }
     }
     const key = keyBuilderFromType$1(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$5;
-    let incomingRecord = normalize$5(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$5(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$5,
-            representationName: RepresentationType$5,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$5, "interaction", VERSION$5, RepresentationType$5, equals$5);
     return createLink(key);
 };
 function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
@@ -7445,13 +6988,11 @@ function createResourceRequest$6(config) {
     };
 }
 
-const getDecisionMatrixDetails_ConfigPropertyNames = {
-    displayName: 'getDecisionMatrixDetails',
-    parameters: {
-        required: ['matrixId'],
-        optional: []
-    }
-};
+const adapterName$6 = 'getDecisionMatrixDetails';
+const getDecisionMatrixDetails_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('matrixId', true),
+];
+const getDecisionMatrixDetails_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getDecisionMatrixDetails_ConfigPropertyMetadata);
 function createResourceParams$6(config) {
     const resourceParams = {
         urlParams: {
@@ -7517,21 +7058,7 @@ function buildNetworkSnapshot$6(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$6(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
@@ -7695,26 +7222,8 @@ const ingest$4 = function ExpressionSetAliasMetaInfoRepresentationIngest(input,
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$4;
-    let incomingRecord = normalize$4(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$4(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$4,
-            representationName: RepresentationType$4,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "interaction", VERSION$4, RepresentationType$4, equals$4);
     return createLink(key);
 };
 function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
@@ -7779,13 +7288,11 @@ function createResourceRequest$5(config) {
     };
 }
 
-const getExpressionSetAliasMetaInfo_ConfigPropertyNames = {
-    displayName: 'getExpressionSetAliasMetaInfo',
-    parameters: {
-        required: [],
-        optional: ['includeObjectList']
-    }
-};
+const adapterName$5 = 'getExpressionSetAliasMetaInfo';
+const getExpressionSetAliasMetaInfo_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('includeObjectList', false),
+];
+const getExpressionSetAliasMetaInfo_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getExpressionSetAliasMetaInfo_ConfigPropertyMetadata);
 function createResourceParams$5(config) {
     const resourceParams = {
         queryParams: {
@@ -7851,21 +7358,7 @@ function buildNetworkSnapshot$5(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$5(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
@@ -8006,26 +7499,8 @@ const ingest$3 = function BusinessKnowledgeModelParameterRepresentationIngest(in
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$3;
-    let incomingRecord = normalize$3(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$3(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$3,
-            representationName: RepresentationType$3,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "interaction", VERSION$3, RepresentationType$3, equals$3);
     return createLink(key);
 };
 function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
@@ -8090,13 +7565,12 @@ function createResourceRequest$4(config) {
     };
 }
 
-const getBusinessKnowledgeModel_ConfigPropertyNames = {
-    displayName: 'getBusinessKnowledgeModel',
-    parameters: {
-        required: ['businessKnowledgeModelName'],
-        optional: ['filterParams']
-    }
-};
+const adapterName$4 = 'getBusinessKnowledgeModel';
+const getBusinessKnowledgeModel_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('businessKnowledgeModelName', true),
+    generateParamConfigMetadata('filterParams', false),
+];
+const getBusinessKnowledgeModel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getBusinessKnowledgeModel_ConfigPropertyMetadata);
 function createResourceParams$4(config) {
     const resourceParams = {
         urlParams: {
@@ -8166,21 +7640,7 @@ function buildNetworkSnapshot$4(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$4(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
@@ -8424,26 +7884,8 @@ const ingest$2 = function ProcessTypeOutputRepresentationIngest(input, path, luv
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$2;
-    let incomingRecord = normalize$2(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$2(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$2,
-            representationName: RepresentationType$2,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "interaction", VERSION$2, RepresentationType$2, equals$2);
     return createLink(key);
 };
 function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
@@ -8508,13 +7950,11 @@ function createResourceRequest$3(config) {
     };
 }
 
-const getProcessType_ConfigPropertyNames = {
-    displayName: 'getProcessType',
-    parameters: {
-        required: ['processTypeName'],
-        optional: []
-    }
-};
+const adapterName$3 = 'getProcessType';
+const getProcessType_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('processTypeName', true),
+];
+const getProcessType_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getProcessType_ConfigPropertyMetadata);
 function createResourceParams$3(config) {
     const resourceParams = {
         urlParams: {
@@ -8580,21 +8020,7 @@ function buildNetworkSnapshot$3(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$3(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { luvio, config } = context;
@@ -8689,26 +8115,8 @@ const ingest$1 = function UsageTypeListOutputRepresentationIngest(input, path, l
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$1;
-    let incomingRecord = normalize$1(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION$1,
-            representationName: RepresentationType$1,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "interaction", VERSION$1, RepresentationType$1, equals$1);
     return createLink(key);
 };
 function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
@@ -8773,13 +8181,9 @@ function createResourceRequest$2(config) {
     };
 }
 
-const getUsageTypes_ConfigPropertyNames = {
-    displayName: 'getUsageTypes',
-    parameters: {
-        required: [],
-        optional: []
-    }
-};
+const adapterName$2 = 'getUsageTypes';
+const getUsageTypes_ConfigPropertyMetadata = [];
+const getUsageTypes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getUsageTypes_ConfigPropertyMetadata);
 function createResourceParams$2(config) {
     const resourceParams = {};
     return resourceParams;
@@ -8836,21 +8240,7 @@ function buildNetworkSnapshot$2(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$2(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
@@ -9062,26 +8452,8 @@ const ingest = function ExpressionSetObjectAliasOutputRepresentationIngest(input
         }
     }
     const key = keyBuilderFromType(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL;
-    let incomingRecord = normalize(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "interaction",
-            version: VERSION,
-            representationName: RepresentationType,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "interaction", VERSION, RepresentationType, equals);
     return createLink(key);
 };
 function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
@@ -9131,13 +8503,11 @@ function createResourceRequest$1(config) {
     };
 }
 
-const createObjectAlias_ConfigPropertyNames = {
-    displayName: 'createObjectAlias',
-    parameters: {
-        required: ['expressionSetObjectAlias'],
-        optional: []
-    }
-};
+const adapterName$1 = 'createObjectAlias';
+const createObjectAlias_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('expressionSetObjectAlias', true),
+];
+const createObjectAlias_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, createObjectAlias_ConfigPropertyMetadata);
 function createResourceParams$1(config) {
     const resourceParams = {
         body: {
@@ -9234,13 +8604,12 @@ function createResourceRequest(config) {
     };
 }
 
-const updateAliasField_ConfigPropertyNames = {
-    displayName: 'updateAliasField',
-    parameters: {
-        required: ['id', 'expressionSetObjectAlias'],
-        optional: []
-    }
-};
+const adapterName = 'updateAliasField';
+const updateAliasField_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+    generateParamConfigMetadata('expressionSetObjectAlias', true),
+];
+const updateAliasField_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, updateAliasField_ConfigPropertyMetadata);
 function createResourceParams(config) {
     const resourceParams = {
         urlParams: {