@salesforce/lds-adapters-analytics-wave 1.213.0 → 1.213.2

package/dist/es/es2018/analytics-wave.js

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, deepFreeze, typeCheckScalars, StoreKeyMap, typeCheckArrayOfScalars } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$z, typeCheckScalars, StoreKeyMap, typeCheckArrayOfScalars } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -104,6 +104,24 @@ function stableJSONStringify(node) {
     }
     return '{' + out + '}';
 }
+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 = 'WAVE';
 
 const { keys: ObjectKeys, create: ObjectCreate, assign: ObjectAssign } = Object;
@@ -338,26 +356,8 @@ const ingest$M = function ActionCollectionRepresentationIngest(input, path, luvi
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$y;
-    let incomingRecord = normalize$L(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1Q(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$1Q,
-            representationName: RepresentationType$N,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$L, "WAVE", VERSION$1Q, RepresentationType$N, equals$1Q);
     return createLink(key);
 };
 function getTypeCacheKeys$M(rootKeySet, luvio, input, fullPathFactory) {
@@ -422,13 +422,11 @@ function createResourceRequest$T(config) {
     };
 }
 
-const getActions_ConfigPropertyNames = {
-    displayName: 'getActions',
-    parameters: {
-        required: ['entityId'],
-        optional: []
-    }
-};
+const adapterName$T = 'getActions';
+const getActions_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('entityId', true),
+];
+const getActions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$T, getActions_ConfigPropertyMetadata);
 function createResourceParams$T(config) {
     const resourceParams = {
         urlParams: {
@@ -494,21 +492,7 @@ function buildNetworkSnapshot$U(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$y(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$U(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$U, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$C(context, storeLookup) {
     const { luvio, config } = context;
@@ -773,26 +757,8 @@ const ingest$L = function HourlyScheduleRepresentationIngest(input, path, luvio,
         }
     }
     const key = keyBuilderFromType$s(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$K(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1N(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$1N,
-            representationName: RepresentationType$M,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$K, "WAVE", VERSION$1N, RepresentationType$M, equals$1N);
     return createLink(key);
 };
 function getTypeCacheKeys$L(rootKeySet, luvio, input, fullPathFactory) {
@@ -877,26 +843,8 @@ const ingest$K = function MonthlySpecificScheduleRepresentationIngest(input, pat
         }
     }
     const key = keyBuilderFromType$r(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$J(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1M(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$1M,
-            representationName: RepresentationType$L,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$J, "WAVE", VERSION$1M, RepresentationType$L, equals$1M);
     return createLink(key);
 };
 function getTypeCacheKeys$K(rootKeySet, luvio, input, fullPathFactory) {
@@ -1020,26 +968,8 @@ const ingest$J = function MinutelyScheduleRepresentationIngest(input, path, luvi
         }
     }
     const key = keyBuilderFromType$q(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$I(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1L(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$1L,
-            representationName: RepresentationType$K,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$I, "WAVE", VERSION$1L, RepresentationType$K, equals$1L);
     return createLink(key);
 };
 function getTypeCacheKeys$J(rootKeySet, luvio, input, fullPathFactory) {
@@ -1122,26 +1052,8 @@ const ingest$I = function EventDrivenScheduleRepresentationIngest(input, path, l
         }
     }
     const key = keyBuilderFromType$p(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$H(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1K(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$1K,
-            representationName: RepresentationType$J,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$H, "WAVE", VERSION$1K, RepresentationType$J, equals$1K);
     return createLink(key);
 };
 function getTypeCacheKeys$I(rootKeySet, luvio, input, fullPathFactory) {
@@ -1226,26 +1138,8 @@ const ingest$H = function WeeklyScheduleRepresentationIngest(input, path, luvio,
         }
     }
     const key = keyBuilderFromType$o(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$G(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1J(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$1J,
-            representationName: RepresentationType$I,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$G, "WAVE", VERSION$1J, RepresentationType$I, equals$1J);
     return createLink(key);
 };
 function getTypeCacheKeys$H(rootKeySet, luvio, input, fullPathFactory) {
@@ -1353,26 +1247,8 @@ const ingest$G = function MonthlyRelativeScheduleRepresentationIngest(input, pat
         }
     }
     const key = keyBuilderFromType$n(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$F(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1I(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$1I,
-            representationName: RepresentationType$H,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$F, "WAVE", VERSION$1I, RepresentationType$H, equals$1I);
     return createLink(key);
 };
 function getTypeCacheKeys$G(rootKeySet, luvio, input, fullPathFactory) {
@@ -1430,26 +1306,8 @@ const ingest$F = function DailyScheduleRepresentationIngest(input, path, luvio,
         }
     }
     const key = keyBuilderFromType$m(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$E(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1H(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$1H,
-            representationName: RepresentationType$G,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$E, "WAVE", VERSION$1H, RepresentationType$G, equals$1H);
     return createLink(key);
 };
 function getTypeCacheKeys$F(rootKeySet, luvio, input, fullPathFactory) {
@@ -1507,26 +1365,8 @@ const ingest$E = function EmptyScheduleRepresentationIngest(input, path, luvio,
         }
     }
     const key = keyBuilderFromType$l(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$D(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1G(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$1G,
-            representationName: RepresentationType$F,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$D, "WAVE", VERSION$1G, RepresentationType$F, equals$1G);
     return createLink(key);
 };
 function getTypeCacheKeys$E(rootKeySet, luvio, input, fullPathFactory) {
@@ -1715,33 +1555,33 @@ function equals$1F(existing, incoming) {
     return true;
 }
 const ingest$D = function ScheduleRepresentationIngest(input, path, luvio, store, timestamp) {
-    return discriminatorIngest(input, path, luvio, store);
+    return discriminatorIngest(input, path, luvio, store, timestamp);
 };
 const discriminatorIngest = function ScheduleRepresentationDiscriminatorIngest(input, path, luvio, store, timestamp) {
     const discriminatorValue = input.frequency;
     if (discriminatorValue === 'hourly') {
-        return ingest$L(input, path, luvio, store);
+        return ingest$L(input, path, luvio, store, timestamp);
     }
     if (discriminatorValue === 'monthly') {
-        return ingest$K(input, path, luvio, store);
+        return ingest$K(input, path, luvio, store, timestamp);
     }
     if (discriminatorValue === 'minutely') {
-        return ingest$J(input, path, luvio, store);
+        return ingest$J(input, path, luvio, store, timestamp);
     }
     if (discriminatorValue === 'eventdriven') {
-        return ingest$I(input, path, luvio, store);
+        return ingest$I(input, path, luvio, store, timestamp);
     }
     if (discriminatorValue === 'weekly') {
-        return ingest$H(input, path, luvio, store);
+        return ingest$H(input, path, luvio, store, timestamp);
     }
     if (discriminatorValue === 'monthlyrelative') {
-        return ingest$G(input, path, luvio, store);
+        return ingest$G(input, path, luvio, store, timestamp);
     }
     if (discriminatorValue === 'daily') {
-        return ingest$F(input, path, luvio, store);
+        return ingest$F(input, path, luvio, store, timestamp);
     }
     if (discriminatorValue === 'none') {
-        return ingest$E(input, path, luvio, store);
+        return ingest$E(input, path, luvio, store, timestamp);
     }
     throw new Error(`Invalid discriminatorValue "${discriminatorValue}". Expected one of "hourly","monthly","minutely","eventdriven","weekly","monthlyrelative","daily","none"`);
 };
@@ -1822,13 +1662,11 @@ function createResourceRequest$S(config) {
     };
 }
 
-const getSchedule_ConfigPropertyNames = {
-    displayName: 'getSchedule',
-    parameters: {
-        required: ['assetId'],
-        optional: []
-    }
-};
+const adapterName$S = 'getSchedule';
+const getSchedule_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('assetId', true),
+];
+const getSchedule_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$S, getSchedule_ConfigPropertyMetadata);
 function createResourceParams$S(config) {
     const resourceParams = {
         urlParams: {
@@ -1894,21 +1732,7 @@ function buildNetworkSnapshot$T(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$x(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$T(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$T, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$B(context, storeLookup) {
     const { luvio, config } = context;
@@ -2009,13 +1833,12 @@ function createResourceRequest$R(config) {
     };
 }
 
-const updateSchedule_ConfigPropertyNames = {
-    displayName: 'updateSchedule',
-    parameters: {
-        required: ['assetId', 'schedule'],
-        optional: []
-    }
-};
+const adapterName$R = 'updateSchedule';
+const updateSchedule_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('assetId', true),
+    generateParamConfigMetadata('schedule', true),
+];
+const updateSchedule_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$R, updateSchedule_ConfigPropertyMetadata);
 function createResourceParams$R(config) {
     const resourceParams = {
         urlParams: {
@@ -5912,26 +5735,8 @@ const ingest$C = function DatasetVersionRepresentationIngest(input, path, luvio,
         }
     }
     const key = keyBuilderFromType$j(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$r;
-    let incomingRecord = normalize$C(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1l(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$1l,
-            representationName: RepresentationType$D,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$C, "WAVE", VERSION$1l, RepresentationType$D, equals$1l);
     return createLink(key);
 };
 function getTypeCacheKeys$C(rootKeySet, luvio, input, fullPathFactory) {
@@ -6524,7 +6329,7 @@ function normalize$B(input, existing, path, luvio, store, timestamp) {
             existing: existing,
         },
         ttl: path.ttl
-    }, luvio, store);
+    }, luvio, store, timestamp);
     return input;
 }
 const select$21 = function RecipeRepresentationSelect() {
@@ -6890,26 +6695,8 @@ const ingest$B = function RecipeRepresentationIngest(input, path, luvio, store,
         }
     }
     const key = keyBuilderFromType$i(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$r;
-    let incomingRecord = normalize$B(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$1g(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$1g,
-            representationName: RepresentationType$C,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$B, "WAVE", VERSION$1g, RepresentationType$C, equals$1g);
     return createLink(key);
 };
 function getTypeCacheKeys$B(rootKeySet, luvio, input, fullPathFactory) {
@@ -7314,26 +7101,8 @@ const ingest$A = function DataflowJobNodeRepresentationIngest(input, path, luvio
         }
     }
     const key = keyBuilderFromType$h(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$r;
-    let incomingRecord = normalize$A(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1e(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$1e,
-            representationName: RepresentationType$B,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$A, "WAVE", VERSION$1e, RepresentationType$B, equals$1e);
     return createLink(key);
 };
 function getTypeCacheKeys$A(rootKeySet, luvio, input, fullPathFactory) {
@@ -7929,26 +7698,8 @@ const ingest$z = function DatasetRepresentationIngest(input, path, luvio, store,
         }
     }
     const key = keyBuilderFromType$g(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$r;
-    let incomingRecord = normalize$z(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1c(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$1c,
-            representationName: RepresentationType$A,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$z, "WAVE", VERSION$1c, RepresentationType$A, equals$1c);
     return createLink(key);
 };
 function getTypeCacheKeys$z(rootKeySet, luvio, input, fullPathFactory) {
@@ -8502,26 +8253,8 @@ const ingest$y = function DataflowRepresentationIngest(input, path, luvio, store
         }
     }
     const key = keyBuilderFromType$f(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$r;
-    let incomingRecord = normalize$y(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$18(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$18,
-            representationName: RepresentationType$z,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$y, "WAVE", VERSION$18, RepresentationType$z, equals$18);
     return createLink(key);
 };
 function getTypeCacheKeys$y(rootKeySet, luvio, input, fullPathFactory) {
@@ -8960,7 +8693,7 @@ function normalize$x(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -9000,26 +8733,8 @@ const ingest$x = function DataflowCollectionRepresentationIngest(input, path, lu
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$t;
-    let incomingRecord = normalize$x(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$15(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$15,
-            representationName: RepresentationType$y,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$x, "WAVE", VERSION$15, RepresentationType$y, equals$15);
     return createLink(key);
 };
 function getTypeCacheKeys$x(rootKeySet, luvio, input, fullPathFactory) {
@@ -9280,7 +8995,7 @@ function normalize$w(input, existing, path, luvio, store, timestamp) {
             existing: existing,
         },
         ttl: path.ttl
-    }, luvio, store);
+    }, luvio, store, timestamp);
     return input;
 }
 const select$1R = function DataflowJobRepresentationSelect() {
@@ -9550,26 +9265,8 @@ const ingest$w = function DataflowJobRepresentationIngest(input, path, luvio, st
         }
     }
     const key = keyBuilderFromType$e(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$r;
-    let incomingRecord = normalize$w(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$14(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$14,
-            representationName: RepresentationType$x,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$w, "WAVE", VERSION$14, RepresentationType$x, equals$14);
     return createLink(key);
 };
 function getTypeCacheKeys$w(rootKeySet, luvio, input, fullPathFactory) {
@@ -10206,26 +9903,8 @@ const ingest$v = function WaveFolderRepresentationIngest(input, path, luvio, sto
         }
     }
     const key = keyBuilderFromType$d(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$r;
-    let incomingRecord = normalize$v(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$10(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$10,
-            representationName: RepresentationType$w,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$v, "WAVE", VERSION$10, RepresentationType$w, equals$10);
     return createLink(key);
 };
 function getTypeCacheKeys$v(rootKeySet, luvio, input, fullPathFactory) {
@@ -10892,7 +10571,7 @@ function normalize$u(input, existing, path, luvio, store, timestamp) {
             existing: existing,
         },
         ttl: path.ttl
-    }, luvio, store);
+    }, luvio, store, timestamp);
     return input;
 }
 const select$1K = function DataConnectorRepresentationSelect() {
@@ -11013,26 +10692,8 @@ const ingest$u = function DataConnectorRepresentationIngest(input, path, luvio,
         }
     }
     const key = keyBuilderFromType$b(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$r;
-    let incomingRecord = normalize$u(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$Z(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$Z,
-            representationName: RepresentationType$u,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$u, "WAVE", VERSION$Z, RepresentationType$u, equals$Z);
     return createLink(key);
 };
 function getTypeCacheKeys$u(rootKeySet, luvio, input, fullPathFactory) {
@@ -11088,7 +10749,7 @@ function normalize$t(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -11137,26 +10798,8 @@ const ingest$t = function DataConnectorCollectionRepresentationIngest(input, pat
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$p;
-    let incomingRecord = normalize$t(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$Y(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$Y,
-            representationName: RepresentationType$t,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$t, "WAVE", VERSION$Y, RepresentationType$t, equals$Y);
     return createLink(key);
 };
 function getTypeCacheKeys$t(rootKeySet, luvio, input, fullPathFactory) {
@@ -11225,13 +10868,13 @@ function createResourceRequest$Q(config) {
     };
 }
 
-const getDataConnectors_ConfigPropertyNames = {
-    displayName: 'getDataConnectors',
-    parameters: {
-        required: [],
-        optional: ['category', 'connectorType', 'scope']
-    }
-};
+const adapterName$Q = 'getDataConnectors';
+const getDataConnectors_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('category', false),
+    generateParamConfigMetadata('connectorType', false),
+    generateParamConfigMetadata('scope', false),
+];
+const getDataConnectors_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$Q, getDataConnectors_ConfigPropertyMetadata);
 function createResourceParams$Q(config) {
     const resourceParams = {
         queryParams: {
@@ -11299,21 +10942,7 @@ function buildNetworkSnapshot$R(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$w(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$R(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$R, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$A(context, storeLookup) {
     const { luvio, config } = context;
@@ -11482,13 +11111,11 @@ function createResourceRequest$P(config) {
     };
 }
 
-const createDataConnector_ConfigPropertyNames = {
-    displayName: 'createDataConnector',
-    parameters: {
-        required: ['dataConnector'],
-        optional: []
-    }
-};
+const adapterName$P = 'createDataConnector';
+const createDataConnector_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataConnector', true),
+];
+const createDataConnector_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$P, createDataConnector_ConfigPropertyMetadata);
 function createResourceParams$P(config) {
     const resourceParams = {
         body: {
@@ -11602,13 +11229,11 @@ function createResourceRequest$O(config) {
     };
 }
 
-const getDataConnector_ConfigPropertyNames = {
-    displayName: 'getDataConnector',
-    parameters: {
-        required: ['connectorIdOrApiName'],
-        optional: []
-    }
-};
+const adapterName$O = 'getDataConnector';
+const getDataConnector_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('connectorIdOrApiName', true),
+];
+const getDataConnector_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$O, getDataConnector_ConfigPropertyMetadata);
 function createResourceParams$O(config) {
     const resourceParams = {
         urlParams: {
@@ -11674,21 +11299,7 @@ function buildNetworkSnapshot$P(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$v(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$P(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$P, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$z(context, storeLookup) {
     const { luvio, config } = context;
@@ -11750,13 +11361,12 @@ function createResourceRequest$N(config) {
     };
 }
 
-const updateDataConnector_ConfigPropertyNames = {
-    displayName: 'updateDataConnector',
-    parameters: {
-        required: ['connectorIdOrApiName', 'dataConnector'],
-        optional: []
-    }
-};
+const adapterName$N = 'updateDataConnector';
+const updateDataConnector_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('connectorIdOrApiName', true),
+    generateParamConfigMetadata('dataConnector', true),
+];
+const updateDataConnector_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$N, updateDataConnector_ConfigPropertyMetadata);
 function createResourceParams$N(config) {
     const resourceParams = {
         urlParams: {
@@ -11853,14 +11463,11 @@ function createResourceRequest$M(config) {
     };
 }
 
-const adapterName$3 = 'deleteDataConnector';
-const deleteDataConnector_ConfigPropertyNames = {
-    displayName: 'deleteDataConnector',
-    parameters: {
-        required: ['connectorIdOrApiName'],
-        optional: []
-    }
-};
+const adapterName$M = 'deleteDataConnector';
+const deleteDataConnector_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('connectorIdOrApiName', true),
+];
+const deleteDataConnector_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$M, deleteDataConnector_ConfigPropertyMetadata);
 function createResourceParams$M(config) {
     const resourceParams = {
         urlParams: {
@@ -11912,7 +11519,7 @@ const deleteDataConnectorAdapterFactory = (luvio) => {
         const config = validateAdapterConfig$M(untrustedConfig, deleteDataConnector_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$3}"`);
+            throw new Error(`Invalid config for "${adapterName$M}"`);
         }
         return buildNetworkSnapshot$N(luvio, config);
     };
@@ -12101,26 +11708,8 @@ const ingest$s = function SourceObjectRepresentationIngest(input, path, luvio, s
         }
     }
     const key = keyBuilderFromType$a(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$o;
-    let incomingRecord = normalize$s(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$X(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$X,
-            representationName: RepresentationType$s,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$s, "WAVE", VERSION$X, RepresentationType$s, equals$X);
     return createLink(key);
 };
 function getTypeCacheKeys$s(rootKeySet, luvio, input, fullPathFactory) {
@@ -12190,7 +11779,7 @@ function normalize$r(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -12275,26 +11864,8 @@ const ingest$r = function SourceObjectCollectionRepresentationIngest(input, path
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$n;
-    let incomingRecord = normalize$r(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$W(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$W,
-            representationName: RepresentationType$r,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$r, "WAVE", VERSION$W, RepresentationType$r, equals$W);
     return createLink(key);
 };
 function getTypeCacheKeys$r(rootKeySet, luvio, input, fullPathFactory) {
@@ -12363,13 +11934,14 @@ function createResourceRequest$L(config) {
     };
 }
 
-const getDataConnectorSourceObjects_ConfigPropertyNames = {
-    displayName: 'getDataConnectorSourceObjects',
-    parameters: {
-        required: ['connectorIdOrApiName'],
-        optional: ['q', 'page', 'pageSize']
-    }
-};
+const adapterName$L = 'getDataConnectorSourceObjects';
+const getDataConnectorSourceObjects_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('connectorIdOrApiName', true),
+    generateParamConfigMetadata('q', false),
+    generateParamConfigMetadata('page', false),
+    generateParamConfigMetadata('pageSize', false),
+];
+const getDataConnectorSourceObjects_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$L, getDataConnectorSourceObjects_ConfigPropertyMetadata);
 function createResourceParams$L(config) {
     const resourceParams = {
         urlParams: {
@@ -12441,21 +12013,7 @@ function buildNetworkSnapshot$M(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$u(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$M(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$M, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$y(context, storeLookup) {
     const { luvio, config } = context;
@@ -12535,13 +12093,12 @@ function createResourceRequest$K(config) {
     };
 }
 
-const getDataConnectorSourceObject_ConfigPropertyNames = {
-    displayName: 'getDataConnectorSourceObject',
-    parameters: {
-        required: ['connectorIdOrApiName', 'sourceObjectName'],
-        optional: []
-    }
-};
+const adapterName$K = 'getDataConnectorSourceObject';
+const getDataConnectorSourceObject_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('connectorIdOrApiName', true),
+    generateParamConfigMetadata('sourceObjectName', true),
+];
+const getDataConnectorSourceObject_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$K, getDataConnectorSourceObject_ConfigPropertyMetadata);
 function createResourceParams$K(config) {
     const resourceParams = {
         urlParams: {
@@ -12608,21 +12165,7 @@ function buildNetworkSnapshot$L(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$t(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$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$L, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$x(context, storeLookup) {
     const { luvio, config } = context;
@@ -12750,26 +12293,8 @@ const ingest$q = function SourceObjectDataRepresentationIngest(input, path, luvi
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$m;
-    let incomingRecord = normalize$q(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$V(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$V,
-            representationName: RepresentationType$q,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$q, "WAVE", VERSION$V, RepresentationType$q, equals$V);
     return createLink(key);
 };
 function getTypeCacheKeys$q(rootKeySet, luvio, input, fullPathFactory) {
@@ -12834,13 +12359,13 @@ function createResourceRequest$J(config) {
     };
 }
 
-const getDataConnectorSourceObjectDataPreviewWithFields_ConfigPropertyNames = {
-    displayName: 'getDataConnectorSourceObjectDataPreviewWithFields',
-    parameters: {
-        required: ['connectorIdOrApiName', 'sourceObjectName', 'sourceObjectParam'],
-        optional: []
-    }
-};
+const adapterName$J = 'getDataConnectorSourceObjectDataPreviewWithFields';
+const getDataConnectorSourceObjectDataPreviewWithFields_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('connectorIdOrApiName', true),
+    generateParamConfigMetadata('sourceObjectName', true),
+    generateParamConfigMetadata('sourceObjectParam', true),
+];
+const getDataConnectorSourceObjectDataPreviewWithFields_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$J, getDataConnectorSourceObjectDataPreviewWithFields_ConfigPropertyMetadata);
 function createResourceParams$J(config) {
     const resourceParams = {
         urlParams: {
@@ -12915,21 +12440,7 @@ function buildNetworkSnapshot$K(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: 'get',
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$K(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$K, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$w(context, storeLookup) {
     const { luvio, config } = context;
@@ -13549,26 +13060,8 @@ const ingest$p = function SourceFieldCollectionRepresentationIngest(input, path,
         }
     }
     const key = keyBuilderFromType$9(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$l;
-    let incomingRecord = normalize$p(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$R(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$R,
-            representationName: RepresentationType$p,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$p, "WAVE", VERSION$R, RepresentationType$p, equals$R);
     return createLink(key);
 };
 function getTypeCacheKeys$p(rootKeySet, luvio, input, fullPathFactory) {
@@ -13636,13 +13129,12 @@ function createResourceRequest$I(config) {
     };
 }
 
-const getDataConnectorSourceFields_ConfigPropertyNames = {
-    displayName: 'getDataConnectorSourceFields',
-    parameters: {
-        required: ['connectorIdOrApiName', 'sourceObjectName'],
-        optional: []
-    }
-};
+const adapterName$I = 'getDataConnectorSourceFields';
+const getDataConnectorSourceFields_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('connectorIdOrApiName', true),
+    generateParamConfigMetadata('sourceObjectName', true),
+];
+const getDataConnectorSourceFields_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$I, getDataConnectorSourceFields_ConfigPropertyMetadata);
 function createResourceParams$I(config) {
     const resourceParams = {
         urlParams: {
@@ -13709,21 +13201,7 @@ function buildNetworkSnapshot$J(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$r(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$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$J, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$v(context, storeLookup) {
     const { luvio, config } = context;
@@ -13818,26 +13296,8 @@ const ingest$o = function RestoreDatasetVersionRepresentationIngest(input, path,
         }
     }
     const key = keyBuilderFromType$8(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$o(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$Q(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$Q,
-            representationName: RepresentationType$o,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$o, "WAVE", VERSION$Q, RepresentationType$o, equals$Q);
     return createLink(key);
 };
 function getTypeCacheKeys$o(rootKeySet, luvio, input, fullPathFactory) {
@@ -13887,13 +13347,11 @@ function createResourceRequest$H(config) {
     };
 }
 
-const ingestDataConnector_ConfigPropertyNames = {
-    displayName: 'ingestDataConnector',
-    parameters: {
-        required: ['connectorIdOrApiName'],
-        optional: []
-    }
-};
+const adapterName$H = 'ingestDataConnector';
+const ingestDataConnector_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('connectorIdOrApiName', true),
+];
+const ingestDataConnector_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$H, ingestDataConnector_ConfigPropertyMetadata);
 function createResourceParams$H(config) {
     const resourceParams = {
         urlParams: {
@@ -14027,26 +13485,8 @@ const ingest$n = function DataConnectorStatusRepresentationIngest(input, path, l
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$k;
-    let incomingRecord = normalize$n(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$P(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$P,
-            representationName: RepresentationType$n,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$n, "WAVE", VERSION$P, RepresentationType$n, equals$P);
     return createLink(key);
 };
 function getTypeCacheKeys$n(rootKeySet, luvio, input, fullPathFactory) {
@@ -14111,13 +13551,11 @@ function createResourceRequest$G(config) {
     };
 }
 
-const getDataConnectorStatus_ConfigPropertyNames = {
-    displayName: 'getDataConnectorStatus',
-    parameters: {
-        required: ['connectorIdOrApiName'],
-        optional: []
-    }
-};
+const adapterName$G = 'getDataConnectorStatus';
+const getDataConnectorStatus_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('connectorIdOrApiName', true),
+];
+const getDataConnectorStatus_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$G, getDataConnectorStatus_ConfigPropertyMetadata);
 function createResourceParams$G(config) {
     const resourceParams = {
         urlParams: {
@@ -14183,21 +13621,7 @@ function buildNetworkSnapshot$H(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$q(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$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$H, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$u(context, storeLookup) {
     const { luvio, config } = context;
@@ -14853,26 +14277,8 @@ const ingest$m = function DataConnectorTypeCollectionRepresentationIngest(input,
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$j;
-    let incomingRecord = normalize$m(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: "WAVE",
-            version: VERSION$L,
-            representationName: RepresentationType$m,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$m, "WAVE", VERSION$L, RepresentationType$m, equals$L);
     return createLink(key);
 };
 function getTypeCacheKeys$m(rootKeySet, luvio, input, fullPathFactory) {
@@ -14937,13 +14343,9 @@ function createResourceRequest$F(config) {
     };
 }
 
-const getDataConnectorTypes_ConfigPropertyNames = {
-    displayName: 'getDataConnectorTypes',
-    parameters: {
-        required: [],
-        optional: []
-    }
-};
+const adapterName$F = 'getDataConnectorTypes';
+const getDataConnectorTypes_ConfigPropertyMetadata = [];
+const getDataConnectorTypes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$F, getDataConnectorTypes_ConfigPropertyMetadata);
 function createResourceParams$F(config) {
     const resourceParams = {};
     return resourceParams;
@@ -15000,21 +14402,7 @@ function buildNetworkSnapshot$G(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$p(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$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$G, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$t(context, storeLookup) {
     const { luvio, config } = context;
@@ -15091,13 +14479,11 @@ function createResourceRequest$E(config) {
     };
 }
 
-const getDataflows_ConfigPropertyNames = {
-    displayName: 'getDataflows',
-    parameters: {
-        required: [],
-        optional: ['q']
-    }
-};
+const adapterName$E = 'getDataflows';
+const getDataflows_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('q', false),
+];
+const getDataflows_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$E, getDataflows_ConfigPropertyMetadata);
 function createResourceParams$E(config) {
     const resourceParams = {
         queryParams: {
@@ -15163,21 +14549,7 @@ function buildNetworkSnapshot$F(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$o(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$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$F, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$s(context, storeLookup) {
     const { luvio, config } = context;
@@ -15301,7 +14673,7 @@ function normalize$l(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -15386,26 +14758,8 @@ const ingest$l = function DataflowJobCollectionRepresentationIngest(input, path,
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$i;
-    let incomingRecord = normalize$l(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$K(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$K,
-            representationName: RepresentationType$l,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$l, "WAVE", VERSION$K, RepresentationType$l, equals$K);
     return createLink(key);
 };
 function getTypeCacheKeys$l(rootKeySet, luvio, input, fullPathFactory) {
@@ -15474,13 +14828,19 @@ function createResourceRequest$D(config) {
     };
 }
 
-const getDataflowJobs_ConfigPropertyNames = {
-    displayName: 'getDataflowJobs',
-    parameters: {
-        required: [],
-        optional: ['dataflowId', 'jobTypes', 'licenseType', 'page', 'pageSize', 'q', 'startedAfter', 'startedBefore', 'status']
-    }
-};
+const adapterName$D = 'getDataflowJobs';
+const getDataflowJobs_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataflowId', false),
+    generateParamConfigMetadata('jobTypes', false),
+    generateParamConfigMetadata('licenseType', false),
+    generateParamConfigMetadata('page', false),
+    generateParamConfigMetadata('pageSize', false),
+    generateParamConfigMetadata('q', false),
+    generateParamConfigMetadata('startedAfter', false),
+    generateParamConfigMetadata('startedBefore', false),
+    generateParamConfigMetadata('status', false),
+];
+const getDataflowJobs_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$D, getDataflowJobs_ConfigPropertyMetadata);
 function createResourceParams$D(config) {
     const resourceParams = {
         queryParams: {
@@ -15556,21 +14916,7 @@ function buildNetworkSnapshot$E(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$n(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$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$E, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$r(context, storeLookup) {
     const { luvio, config } = context;
@@ -15653,13 +14999,11 @@ function createResourceRequest$C(config) {
     };
 }
 
-const createDataflowJob_ConfigPropertyNames = {
-    displayName: 'createDataflowJob',
-    parameters: {
-        required: ['dataflowJob'],
-        optional: []
-    }
-};
+const adapterName$C = 'createDataflowJob';
+const createDataflowJob_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataflowJob', true),
+];
+const createDataflowJob_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$C, createDataflowJob_ConfigPropertyMetadata);
 function createResourceParams$C(config) {
     const resourceParams = {
         body: {
@@ -15773,13 +15117,11 @@ function createResourceRequest$B(config) {
     };
 }
 
-const getDataflowJob_ConfigPropertyNames = {
-    displayName: 'getDataflowJob',
-    parameters: {
-        required: ['dataflowjobId'],
-        optional: []
-    }
-};
+const adapterName$B = 'getDataflowJob';
+const getDataflowJob_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataflowjobId', true),
+];
+const getDataflowJob_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$B, getDataflowJob_ConfigPropertyMetadata);
 function createResourceParams$B(config) {
     const resourceParams = {
         urlParams: {
@@ -15845,21 +15187,7 @@ function buildNetworkSnapshot$C(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$m(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$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$C, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$q(context, storeLookup) {
     const { luvio, config } = context;
@@ -15921,13 +15249,12 @@ function createResourceRequest$A(config) {
     };
 }
 
-const updateDataflowJob_ConfigPropertyNames = {
-    displayName: 'updateDataflowJob',
-    parameters: {
-        required: ['dataflowjobId', 'dataflowJob'],
-        optional: []
-    }
-};
+const adapterName$A = 'updateDataflowJob';
+const updateDataflowJob_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataflowjobId', true),
+    generateParamConfigMetadata('dataflowJob', true),
+];
+const updateDataflowJob_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$A, updateDataflowJob_ConfigPropertyMetadata);
 function createResourceParams$A(config) {
     const resourceParams = {
         urlParams: {
@@ -16036,7 +15363,7 @@ function normalize$k(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -16085,26 +15412,8 @@ const ingest$k = function DataflowJobNodeCollectionRepresentationIngest(input, p
         }
     }
     const key = path.fullPath;
-    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
-    }, luvio, store);
-    if (existingRecord === undefined || equals$J(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$J,
-            representationName: RepresentationType$k,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$k, "WAVE", VERSION$J, RepresentationType$k, equals$J);
     return createLink(key);
 };
 function getTypeCacheKeys$k(rootKeySet, luvio, input, fullPathFactory) {
@@ -16173,13 +15482,11 @@ function createResourceRequest$z(config) {
     };
 }
 
-const getDataflowJobNodes_ConfigPropertyNames = {
-    displayName: 'getDataflowJobNodes',
-    parameters: {
-        required: ['dataflowjobId'],
-        optional: []
-    }
-};
+const adapterName$z = 'getDataflowJobNodes';
+const getDataflowJobNodes_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataflowjobId', true),
+];
+const getDataflowJobNodes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$z, getDataflowJobNodes_ConfigPropertyMetadata);
 function createResourceParams$z(config) {
     const resourceParams = {
         urlParams: {
@@ -16245,21 +15552,7 @@ function buildNetworkSnapshot$A(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$l(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$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$A, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$p(context, storeLookup) {
     const { luvio, config } = context;
@@ -16338,13 +15631,12 @@ function createResourceRequest$y(config) {
     };
 }
 
-const getDataflowJobNode_ConfigPropertyNames = {
-    displayName: 'getDataflowJobNode',
-    parameters: {
-        required: ['dataflowjobId', 'nodeId'],
-        optional: []
-    }
-};
+const adapterName$y = 'getDataflowJobNode';
+const getDataflowJobNode_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataflowjobId', true),
+    generateParamConfigMetadata('nodeId', true),
+];
+const getDataflowJobNode_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$y, getDataflowJobNode_ConfigPropertyMetadata);
 function createResourceParams$y(config) {
     const resourceParams = {
         urlParams: {
@@ -16411,21 +15703,7 @@ function buildNetworkSnapshot$z(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$k(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$z(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$z, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$o(context, storeLookup) {
     const { luvio, config } = context;
@@ -16545,7 +15823,7 @@ function normalize$j(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -16612,26 +15890,8 @@ const ingest$j = function DatasetCollectionRepresentationIngest(input, path, luv
         }
     }
     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
-    }, luvio, store);
-    if (existingRecord === undefined || equals$I(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$I,
-            representationName: RepresentationType$j,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$j, "WAVE", VERSION$I, RepresentationType$j, equals$I);
     return createLink(key);
 };
 function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
@@ -16700,13 +15960,26 @@ function createResourceRequest$x(config) {
     };
 }
 
-const getDatasets_ConfigPropertyNames = {
-    displayName: 'getDatasets',
-    parameters: {
-        required: [],
-        optional: ['createdAfter', 'createdBefore', 'datasetTypes', 'folderId', 'hasCurrentOnly', 'ids', 'includeCurrentVersion', 'lastQueriedAfter', 'lastQueriedBefore', 'licenseType', 'order', 'page', 'pageSize', 'q', 'scope', 'sort']
-    }
-};
+const adapterName$x = 'getDatasets';
+const getDatasets_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('createdAfter', false),
+    generateParamConfigMetadata('createdBefore', false),
+    generateParamConfigMetadata('datasetTypes', false),
+    generateParamConfigMetadata('folderId', false),
+    generateParamConfigMetadata('hasCurrentOnly', false),
+    generateParamConfigMetadata('ids', false),
+    generateParamConfigMetadata('includeCurrentVersion', false),
+    generateParamConfigMetadata('lastQueriedAfter', false),
+    generateParamConfigMetadata('lastQueriedBefore', false),
+    generateParamConfigMetadata('licenseType', false),
+    generateParamConfigMetadata('order', false),
+    generateParamConfigMetadata('page', false),
+    generateParamConfigMetadata('pageSize', false),
+    generateParamConfigMetadata('q', false),
+    generateParamConfigMetadata('scope', false),
+    generateParamConfigMetadata('sort', false),
+];
+const getDatasets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$x, getDatasets_ConfigPropertyMetadata);
 function createResourceParams$x(config) {
     const resourceParams = {
         queryParams: {
@@ -16789,21 +16062,7 @@ function buildNetworkSnapshot$y(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$j(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$y(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$y, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$n(context, storeLookup) {
     const { luvio, config } = context;
@@ -18065,13 +17324,11 @@ function createResourceRequest$w(config) {
     };
 }
 
-const createDataset_ConfigPropertyNames = {
-    displayName: 'createDataset',
-    parameters: {
-        required: ['dataset'],
-        optional: []
-    }
-};
+const adapterName$w = 'createDataset';
+const createDataset_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataset', true),
+];
+const createDataset_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$w, createDataset_ConfigPropertyMetadata);
 function createResourceParams$w(config) {
     const resourceParams = {
         body: {
@@ -18202,14 +17459,11 @@ function buildNetworkSnapshot$w(luvio, config) {
     });
 }
 
-const adapterName$2 = 'deleteDataset';
-const deleteDataset_ConfigPropertyNames = {
-    displayName: 'deleteDataset',
-    parameters: {
-        required: ['datasetIdOrApiName'],
-        optional: []
-    }
-};
+const adapterName$v = 'deleteDataset';
+const deleteDataset_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('datasetIdOrApiName', true),
+];
+const deleteDataset_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$v, deleteDataset_ConfigPropertyMetadata);
 function createResourceParams$v(config) {
     const resourceParams = {
         urlParams: {
@@ -18261,7 +17515,7 @@ const deleteDatasetAdapterFactory = (luvio) => {
         const config = validateAdapterConfig$v(untrustedConfig, deleteDataset_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$2}"`);
+            throw new Error(`Invalid config for "${adapterName$v}"`);
         }
         return buildNetworkSnapshot$w(luvio, config);
     };
@@ -18358,13 +17612,11 @@ function buildCachedSnapshotCachePolicy$m(context, storeLookup) {
     return buildCachedSnapshotCachePolicy$l(context, storeLookup);
 }
 
-const getDataset_ConfigPropertyNames = {
-    displayName: 'getDataset',
-    parameters: {
-        required: ['datasetIdOrApiName'],
-        optional: []
-    }
-};
+const adapterName$u = 'getDataset';
+const getDataset_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('datasetIdOrApiName', true),
+];
+const getDataset_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$u, getDataset_ConfigPropertyMetadata);
 function createResourceParams$u(config) {
     const resourceParams = {
         urlParams: {
@@ -18430,21 +17682,7 @@ function buildNetworkSnapshot$u(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$i(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$u(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$u, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$l(context, storeLookup) {
     const { luvio, config } = context;
@@ -18506,13 +17744,12 @@ function createResourceRequest$t(config) {
     };
 }
 
-const updateDataset_ConfigPropertyNames = {
-    displayName: 'updateDataset',
-    parameters: {
-        required: ['datasetIdOrApiName', 'dataset'],
-        optional: []
-    }
-};
+const adapterName$t = 'updateDataset';
+const updateDataset_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('datasetIdOrApiName', true),
+    generateParamConfigMetadata('dataset', true),
+];
+const updateDataset_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$t, updateDataset_ConfigPropertyMetadata);
 function createResourceParams$t(config) {
     const resourceParams = {
         urlParams: {
@@ -18621,7 +17858,7 @@ function normalize$i(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -18670,26 +17907,8 @@ const ingest$i = function DatasetVersionCollectionRepresentationIngest(input, pa
         }
     }
     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
-    }, luvio, store);
-    if (existingRecord === undefined || equals$H(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$H,
-            representationName: RepresentationType$i,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$i, "WAVE", VERSION$H, RepresentationType$i, equals$H);
     return createLink(key);
 };
 function getTypeCacheKeys$i(rootKeySet, luvio, input, fullPathFactory) {
@@ -18758,13 +17977,11 @@ function createResourceRequest$s(config) {
     };
 }
 
-const getDatasetVersions_ConfigPropertyNames = {
-    displayName: 'getDatasetVersions',
-    parameters: {
-        required: ['datasetIdOrApiName'],
-        optional: []
-    }
-};
+const adapterName$s = 'getDatasetVersions';
+const getDatasetVersions_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('datasetIdOrApiName', true),
+];
+const getDatasetVersions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$s, getDatasetVersions_ConfigPropertyMetadata);
 function createResourceParams$s(config) {
     const resourceParams = {
         urlParams: {
@@ -18830,21 +18047,7 @@ function buildNetworkSnapshot$s(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$h(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$s(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$s, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$k(context, storeLookup) {
     const { luvio, config } = context;
@@ -18923,13 +18126,12 @@ function createResourceRequest$r(config) {
     };
 }
 
-const createDatasetVersion_ConfigPropertyNames = {
-    displayName: 'createDatasetVersion',
-    parameters: {
-        required: ['datasetIdOrApiName', 'sourceVersion'],
-        optional: []
-    }
-};
+const adapterName$r = 'createDatasetVersion';
+const createDatasetVersion_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('datasetIdOrApiName', true),
+    generateParamConfigMetadata('sourceVersion', true),
+];
+const createDatasetVersion_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$r, createDatasetVersion_ConfigPropertyMetadata);
 function createResourceParams$r(config) {
     const resourceParams = {
         urlParams: {
@@ -19049,13 +18251,12 @@ function createResourceRequest$q(config) {
     };
 }
 
-const getDatasetVersion_ConfigPropertyNames = {
-    displayName: 'getDatasetVersion',
-    parameters: {
-        required: ['datasetIdOrApiName', 'versionId'],
-        optional: []
-    }
-};
+const adapterName$q = 'getDatasetVersion';
+const getDatasetVersion_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('datasetIdOrApiName', true),
+    generateParamConfigMetadata('versionId', true),
+];
+const getDatasetVersion_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$q, getDatasetVersion_ConfigPropertyMetadata);
 function createResourceParams$q(config) {
     const resourceParams = {
         urlParams: {
@@ -19122,21 +18323,7 @@ function buildNetworkSnapshot$q(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$q(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$q, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$j(context, storeLookup) {
     const { luvio, config } = context;
@@ -19259,13 +18446,13 @@ function createResourceRequest$p(config) {
     };
 }
 
-const updateDatasetVersion_ConfigPropertyNames = {
-    displayName: 'updateDatasetVersion',
-    parameters: {
-        required: ['datasetIdOrApiName', 'versionId', 'datasetVersion'],
-        optional: []
-    }
-};
+const adapterName$p = 'updateDatasetVersion';
+const updateDatasetVersion_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('datasetIdOrApiName', true),
+    generateParamConfigMetadata('versionId', true),
+    generateParamConfigMetadata('datasetVersion', true),
+];
+const updateDatasetVersion_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$p, updateDatasetVersion_ConfigPropertyMetadata);
 function createResourceParams$p(config) {
     const resourceParams = {
         urlParams: {
@@ -19744,26 +18931,8 @@ const ingest$h = function XmdRepresentationIngest(input, path, luvio, store, tim
         }
     }
     const key = keyBuilderFromType$7(luvio, input);
-    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$G(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$G,
-            representationName: RepresentationType$h,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$h, "WAVE", VERSION$G, RepresentationType$h, equals$G);
     return createLink(key);
 };
 function getTypeCacheKeys$h(rootKeySet, luvio, input, fullPathFactory) {
@@ -19830,13 +18999,13 @@ function createResourceRequest$o(config) {
     };
 }
 
-const getXmd_ConfigPropertyNames = {
-    displayName: 'getXmd',
-    parameters: {
-        required: ['datasetIdOrApiName', 'versionId', 'xmdType'],
-        optional: []
-    }
-};
+const adapterName$o = 'getXmd';
+const getXmd_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('datasetIdOrApiName', true),
+    generateParamConfigMetadata('versionId', true),
+    generateParamConfigMetadata('xmdType', true),
+];
+const getXmd_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$o, getXmd_ConfigPropertyMetadata);
 function createResourceParams$o(config) {
     const resourceParams = {
         urlParams: {
@@ -19904,21 +19073,7 @@ function buildNetworkSnapshot$o(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$o(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$o, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$i(context, storeLookup) {
     const { luvio, config } = context;
@@ -19980,13 +19135,14 @@ function createResourceRequest$n(config) {
     };
 }
 
-const updateXmd_ConfigPropertyNames = {
-    displayName: 'updateXmd',
-    parameters: {
-        required: ['datasetIdOrApiName', 'versionId', 'xmdType', 'xmd'],
-        optional: []
-    }
-};
+const adapterName$n = 'updateXmd';
+const updateXmd_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('datasetIdOrApiName', true),
+    generateParamConfigMetadata('versionId', true),
+    generateParamConfigMetadata('xmdType', true),
+    generateParamConfigMetadata('xmd', true),
+];
+const updateXmd_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$n, updateXmd_ConfigPropertyMetadata);
 function createResourceParams$n(config) {
     const resourceParams = {
         urlParams: {
@@ -20473,26 +19629,8 @@ const ingest$g = function DependencyRepresentationIngest(input, path, luvio, sto
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$d;
-    let incomingRecord = normalize$g(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);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$E,
-            representationName: RepresentationType$g,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$g, "WAVE", VERSION$E, RepresentationType$g, equals$E);
     return createLink(key);
 };
 function getTypeCacheKeys$g(rootKeySet, luvio, input, fullPathFactory) {
@@ -20557,13 +19695,11 @@ function createResourceRequest$m(config) {
     };
 }
 
-const getDependencies_ConfigPropertyNames = {
-    displayName: 'getDependencies',
-    parameters: {
-        required: ['assetId'],
-        optional: []
-    }
-};
+const adapterName$m = 'getDependencies';
+const getDependencies_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('assetId', true),
+];
+const getDependencies_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$m, getDependencies_ConfigPropertyMetadata);
 function createResourceParams$m(config) {
     const resourceParams = {
         urlParams: {
@@ -20629,21 +19765,7 @@ function buildNetworkSnapshot$m(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$m(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$m, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$h(context, storeLookup) {
     const { luvio, config } = context;
@@ -20744,7 +19866,7 @@ function normalize$f(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -20820,26 +19942,8 @@ const ingest$f = function WaveFolderCollectionRepresentationIngest(input, path,
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$c;
-    let incomingRecord = normalize$f(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$D(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$D,
-            representationName: RepresentationType$f,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$f, "WAVE", VERSION$D, RepresentationType$f, equals$D);
     return createLink(key);
 };
 function getTypeCacheKeys$f(rootKeySet, luvio, input, fullPathFactory) {
@@ -20908,13 +20012,18 @@ function createResourceRequest$l(config) {
     };
 }
 
-const getWaveFolders_ConfigPropertyNames = {
-    displayName: 'getWaveFolders',
-    parameters: {
-        required: [],
-        optional: ['isPinned', 'mobileOnlyFeaturedAssets', 'page', 'pageSize', 'q', 'scope', 'sort', 'templateSourceId']
-    }
-};
+const adapterName$l = 'getWaveFolders';
+const getWaveFolders_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('isPinned', false),
+    generateParamConfigMetadata('mobileOnlyFeaturedAssets', false),
+    generateParamConfigMetadata('page', false),
+    generateParamConfigMetadata('pageSize', false),
+    generateParamConfigMetadata('q', false),
+    generateParamConfigMetadata('scope', false),
+    generateParamConfigMetadata('sort', false),
+    generateParamConfigMetadata('templateSourceId', false),
+];
+const getWaveFolders_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$l, getWaveFolders_ConfigPropertyMetadata);
 function createResourceParams$l(config) {
     const resourceParams = {
         queryParams: {
@@ -20987,21 +20096,7 @@ function buildNetworkSnapshot$l(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$l(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$l, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$g(context, storeLookup) {
     const { luvio, config } = context;
@@ -21213,26 +20308,8 @@ const ingest$e = function WaveAnalyticsLimitCollectionRepresentationIngest(input
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$b;
-    let incomingRecord = normalize$e(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: "WAVE",
-            version: VERSION$B,
-            representationName: RepresentationType$e,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$e, "WAVE", VERSION$B, RepresentationType$e, equals$B);
     return createLink(key);
 };
 function getTypeCacheKeys$e(rootKeySet, luvio, input, fullPathFactory) {
@@ -21297,13 +20374,12 @@ function createResourceRequest$k(config) {
     };
 }
 
-const getAnalyticsLimits_ConfigPropertyNames = {
-    displayName: 'getAnalyticsLimits',
-    parameters: {
-        required: [],
-        optional: ['licenseType', 'types']
-    }
-};
+const adapterName$k = 'getAnalyticsLimits';
+const getAnalyticsLimits_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('licenseType', false),
+    generateParamConfigMetadata('types', false),
+];
+const getAnalyticsLimits_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$k, getAnalyticsLimits_ConfigPropertyMetadata);
 function createResourceParams$k(config) {
     const resourceParams = {
         queryParams: {
@@ -21372,21 +20448,7 @@ function buildNetworkSnapshot$k(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$k(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$k, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$f(context, storeLookup) {
     const { luvio, config } = context;
@@ -21544,26 +20606,8 @@ const ingest$d = function SaqlQueryResultsRepresentationIngest(input, path, luvi
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$d(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);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$A,
-            representationName: RepresentationType$d,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$d, "WAVE", VERSION$A, RepresentationType$d, equals$A);
     return createLink(key);
 };
 function getTypeCacheKeys$d(rootKeySet, luvio, input, fullPathFactory) {
@@ -21638,7 +20682,7 @@ function normalize$c(input, existing, path, luvio, store, timestamp) {
             existing: existing,
         },
         ttl: path.ttl
-    }, luvio, store);
+    }, luvio, store, timestamp);
     return input;
 }
 const select$R = function SaqlQueryResultRepresentationSelect() {
@@ -21693,26 +20737,8 @@ const ingest$c = function SaqlQueryResultRepresentationIngest(input, path, luvio
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$c(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$z(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$z,
-            representationName: RepresentationType$c,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$c, "WAVE", VERSION$z, RepresentationType$c, equals$z);
     return createLink(key);
 };
 function getTypeCacheKeys$c(rootKeySet, luvio, input, fullPathFactory) {
@@ -21772,13 +20798,11 @@ function createResourceRequest$j(config) {
     };
 }
 
-const executeQuery_ConfigPropertyNames = {
-    displayName: 'executeQuery',
-    parameters: {
-        required: ['query'],
-        optional: []
-    }
-};
+const adapterName$j = 'executeQuery';
+const executeQuery_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('query', true),
+];
+const executeQuery_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$j, executeQuery_ConfigPropertyMetadata);
 function createResourceParams$j(config) {
     const resourceParams = {
         body: {
@@ -21846,21 +20870,7 @@ function buildNetworkSnapshot$j(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$b(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: 'get',
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$j(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$j, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
     const { luvio, config } = context;
@@ -21982,7 +20992,7 @@ function normalize$b(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -22058,26 +21068,8 @@ const ingest$b = function RecipeCollectionRepresentationIngest(input, path, luvi
         }
     }
     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
-    }, luvio, store);
-    if (existingRecord === undefined || equals$y(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$y,
-            representationName: RepresentationType$b,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$b, "WAVE", VERSION$y, RepresentationType$b, equals$y);
     return createLink(key);
 };
 function getTypeCacheKeys$b(rootKeySet, luvio, input, fullPathFactory) {
@@ -22146,13 +21138,21 @@ function createResourceRequest$i(config) {
     };
 }
 
-const getRecipes_ConfigPropertyNames = {
-    displayName: 'getRecipes',
-    parameters: {
-        required: [],
-        optional: ['format', 'lastModifiedAfter', 'lastModifiedBefore', 'licenseType', 'nextScheduledAfter', 'nextScheduledBefore', 'page', 'pageSize', 'q', 'sort', 'status']
-    }
-};
+const adapterName$i = 'getRecipes';
+const getRecipes_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('format', false),
+    generateParamConfigMetadata('lastModifiedAfter', false),
+    generateParamConfigMetadata('lastModifiedBefore', false),
+    generateParamConfigMetadata('licenseType', false),
+    generateParamConfigMetadata('nextScheduledAfter', false),
+    generateParamConfigMetadata('nextScheduledBefore', false),
+    generateParamConfigMetadata('page', false),
+    generateParamConfigMetadata('pageSize', false),
+    generateParamConfigMetadata('q', false),
+    generateParamConfigMetadata('sort', false),
+    generateParamConfigMetadata('status', false),
+];
+const getRecipes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$i, getRecipes_ConfigPropertyMetadata);
 function createResourceParams$i(config) {
     const resourceParams = {
         queryParams: {
@@ -22230,21 +21230,7 @@ function buildNetworkSnapshot$i(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$i(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$i, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$d(context, storeLookup) {
     const { luvio, config } = context;
@@ -22323,13 +21309,12 @@ function createResourceRequest$h(config) {
     };
 }
 
-const getRecipe_ConfigPropertyNames = {
-    displayName: 'getRecipe',
-    parameters: {
-        required: ['id'],
-        optional: ['format']
-    }
-};
+const adapterName$h = 'getRecipe';
+const getRecipe_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+    generateParamConfigMetadata('format', false),
+];
+const getRecipe_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$h, getRecipe_ConfigPropertyMetadata);
 function createResourceParams$h(config) {
     const resourceParams = {
         urlParams: {
@@ -22399,21 +21384,7 @@ function buildNetworkSnapshot$h(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$h(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$h, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$c(context, storeLookup) {
     const { luvio, config } = context;
@@ -22469,14 +21440,11 @@ function createResourceRequest$g(config) {
     };
 }
 
-const adapterName$1 = 'deleteRecipe';
-const deleteRecipe_ConfigPropertyNames = {
-    displayName: 'deleteRecipe',
-    parameters: {
-        required: ['id'],
-        optional: []
-    }
-};
+const adapterName$g = 'deleteRecipe';
+const deleteRecipe_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+];
+const deleteRecipe_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$g, deleteRecipe_ConfigPropertyMetadata);
 function createResourceParams$g(config) {
     const resourceParams = {
         urlParams: {
@@ -22528,7 +21496,7 @@ const deleteRecipeAdapterFactory = (luvio) => {
         const config = validateAdapterConfig$g(untrustedConfig, deleteRecipe_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$1}"`);
+            throw new Error(`Invalid config for "${adapterName$g}"`);
         }
         return buildNetworkSnapshot$g(luvio, config);
     };
@@ -23048,13 +22016,14 @@ function createResourceRequest$f(config) {
     };
 }
 
-const updateRecipe_ConfigPropertyNames = {
-    displayName: 'updateRecipe',
-    parameters: {
-        required: ['id', 'recipeObject'],
-        optional: ['enableEditorValidation', 'validationContext']
-    }
-};
+const adapterName$f = 'updateRecipe';
+const updateRecipe_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+    generateParamConfigMetadata('enableEditorValidation', false),
+    generateParamConfigMetadata('validationContext', false),
+    generateParamConfigMetadata('recipeObject', true),
+];
+const updateRecipe_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, updateRecipe_ConfigPropertyMetadata);
 function createResourceParams$f(config) {
     const resourceParams = {
         urlParams: {
@@ -23226,26 +22195,8 @@ const ingest$a = function RecipeNotificationRepresentationIngest(input, path, lu
         }
     }
     const key = keyBuilderFromType$6(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$x(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$x,
-            representationName: RepresentationType$a,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$a, "WAVE", VERSION$x, RepresentationType$a, equals$x);
     return createLink(key);
 };
 function getTypeCacheKeys$a(rootKeySet, luvio, input, fullPathFactory) {
@@ -23312,13 +22263,11 @@ function createResourceRequest$e(config) {
     };
 }
 
-const getRecipeNotification_ConfigPropertyNames = {
-    displayName: 'getRecipeNotification',
-    parameters: {
-        required: ['id'],
-        optional: []
-    }
-};
+const adapterName$e = 'getRecipeNotification';
+const getRecipeNotification_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+];
+const getRecipeNotification_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, getRecipeNotification_ConfigPropertyMetadata);
 function createResourceParams$e(config) {
     const resourceParams = {
         urlParams: {
@@ -23384,21 +22333,7 @@ function buildNetworkSnapshot$e(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$e(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$e, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$b(context, storeLookup) {
     const { luvio, config } = context;
@@ -23502,13 +22437,12 @@ function createResourceRequest$d(config) {
     };
 }
 
-const updateRecipeNotification_ConfigPropertyNames = {
-    displayName: 'updateRecipeNotification',
-    parameters: {
-        required: ['id', 'recipeNotification'],
-        optional: []
-    }
-};
+const adapterName$d = 'updateRecipeNotification';
+const updateRecipeNotification_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+    generateParamConfigMetadata('recipeNotification', true),
+];
+const updateRecipeNotification_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, updateRecipeNotification_ConfigPropertyMetadata);
 function createResourceParams$d(config) {
     const resourceParams = {
         urlParams: {
@@ -24029,7 +22963,7 @@ function normalize$9(input, existing, path, luvio, store, timestamp) {
             existing: existing,
         },
         ttl: path.ttl
-    }, luvio, store);
+    }, luvio, store, timestamp);
     return input;
 }
 const select$G = function ReplicatedDatasetConnectorRepresentationSelect() {
@@ -24383,26 +23317,8 @@ const ingest$9 = function ReplicatedDatasetConnectorRepresentationIngest(input,
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$9(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$u(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$u,
-            representationName: RepresentationType$9,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$9, "WAVE", VERSION$u, RepresentationType$9, equals$u);
     return createLink(key);
 };
 function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
@@ -24787,7 +23703,7 @@ function normalize$8(input, existing, path, luvio, store, timestamp) {
             existing: existing,
         },
         ttl: path.ttl
-    }, luvio, store);
+    }, luvio, store, timestamp);
     return input;
 }
 const select$F = function ReplicatedDatasetRepresentationSelect() {
@@ -25335,26 +24251,8 @@ const ingest$8 = function ReplicatedDatasetRepresentationIngest(input, path, luv
         }
     }
     const key = keyBuilderFromType$5(luvio, input);
-    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
-    }, luvio, store);
-    if (existingRecord === undefined || equals$t(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$t,
-            representationName: RepresentationType$8,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$8, "WAVE", VERSION$t, RepresentationType$8, equals$t);
     return createLink(key);
 };
 function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
@@ -25411,7 +24309,7 @@ function normalize$7(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -25460,26 +24358,8 @@ const ingest$7 = function ReplicatedDatasetCollectionRepresentationIngest(input,
         }
     }
     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
-    }, luvio, store);
-    if (existingRecord === undefined || equals$s(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$s,
-            representationName: RepresentationType$7,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$7, "WAVE", VERSION$s, RepresentationType$7, equals$s);
     return createLink(key);
 };
 function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
@@ -25548,13 +24428,15 @@ function createResourceRequest$c(config) {
     };
 }
 
-const getReplicatedDatasets_ConfigPropertyNames = {
-    displayName: 'getReplicatedDatasets',
-    parameters: {
-        required: [],
-        optional: ['category', 'connector', 'q', 'sourceObject', 'includeLive']
-    }
-};
+const adapterName$c = 'getReplicatedDatasets';
+const getReplicatedDatasets_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('category', false),
+    generateParamConfigMetadata('connector', false),
+    generateParamConfigMetadata('q', false),
+    generateParamConfigMetadata('sourceObject', false),
+    generateParamConfigMetadata('includeLive', false),
+];
+const getReplicatedDatasets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, getReplicatedDatasets_ConfigPropertyMetadata);
 function createResourceParams$c(config) {
     const resourceParams = {
         queryParams: {
@@ -25624,21 +24506,7 @@ function buildNetworkSnapshot$c(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$c(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$c, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     const { luvio, config } = context;
@@ -25774,13 +24642,11 @@ function createResourceRequest$b(config) {
     };
 }
 
-const createReplicatedDataset_ConfigPropertyNames = {
-    displayName: 'createReplicatedDataset',
-    parameters: {
-        required: ['replicatedDataset'],
-        optional: []
-    }
-};
+const adapterName$b = 'createReplicatedDataset';
+const createReplicatedDataset_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('replicatedDataset', true),
+];
+const createReplicatedDataset_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, createReplicatedDataset_ConfigPropertyMetadata);
 function createResourceParams$b(config) {
     const resourceParams = {
         body: {
@@ -25871,14 +24737,11 @@ function createResourceRequest$a(config) {
     };
 }
 
-const adapterName = 'deleteReplicatedDataset';
-const deleteReplicatedDataset_ConfigPropertyNames = {
-    displayName: 'deleteReplicatedDataset',
-    parameters: {
-        required: ['id'],
-        optional: []
-    }
-};
+const adapterName$a = 'deleteReplicatedDataset';
+const deleteReplicatedDataset_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+];
+const deleteReplicatedDataset_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, deleteReplicatedDataset_ConfigPropertyMetadata);
 function createResourceParams$a(config) {
     const resourceParams = {
         urlParams: {
@@ -25930,7 +24793,7 @@ const deleteReplicatedDatasetAdapterFactory = (luvio) => {
         const config = validateAdapterConfig$a(untrustedConfig, deleteReplicatedDataset_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName}"`);
+            throw new Error(`Invalid config for "${adapterName$a}"`);
         }
         return buildNetworkSnapshot$a(luvio, config);
     };
@@ -25990,13 +24853,11 @@ function createResourceRequest$9(config) {
     };
 }
 
-const getReplicatedDataset_ConfigPropertyNames = {
-    displayName: 'getReplicatedDataset',
-    parameters: {
-        required: ['id'],
-        optional: []
-    }
-};
+const adapterName$9 = 'getReplicatedDataset';
+const getReplicatedDataset_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+];
+const getReplicatedDataset_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getReplicatedDataset_ConfigPropertyMetadata);
 function createResourceParams$9(config) {
     const resourceParams = {
         urlParams: {
@@ -26062,21 +24923,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$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
     const { luvio, config } = context;
@@ -26138,13 +24985,12 @@ function createResourceRequest$8(config) {
     };
 }
 
-const updateReplicatedDataset_ConfigPropertyNames = {
-    displayName: 'updateReplicatedDataset',
-    parameters: {
-        required: ['id', 'replicatedDataset'],
-        optional: []
-    }
-};
+const adapterName$8 = 'updateReplicatedDataset';
+const updateReplicatedDataset_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+    generateParamConfigMetadata('replicatedDataset', true),
+];
+const updateReplicatedDataset_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, updateReplicatedDataset_ConfigPropertyMetadata);
 function createResourceParams$8(config) {
     const resourceParams = {
         urlParams: {
@@ -26318,26 +25164,8 @@ const ingest$6 = function ReplicatedFieldCollectionRepresentationIngest(input, p
         }
     }
     const key = keyBuilderFromType$4(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$6;
-    let incomingRecord = normalize$6(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$r(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$r,
-            representationName: RepresentationType$6,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$6, "WAVE", VERSION$r, RepresentationType$6, equals$r);
     return createLink(key);
 };
 function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
@@ -26404,13 +25232,11 @@ function createResourceRequest$7(config) {
     };
 }
 
-const getReplicatedFields_ConfigPropertyNames = {
-    displayName: 'getReplicatedFields',
-    parameters: {
-        required: ['id'],
-        optional: []
-    }
-};
+const adapterName$7 = 'getReplicatedFields';
+const getReplicatedFields_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+];
+const getReplicatedFields_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getReplicatedFields_ConfigPropertyMetadata);
 function createResourceParams$7(config) {
     const resourceParams = {
         urlParams: {
@@ -26476,21 +25302,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$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
@@ -26573,13 +25385,12 @@ function createResourceRequest$6(config) {
     };
 }
 
-const updateReplicatedFields_ConfigPropertyNames = {
-    displayName: 'updateReplicatedFields',
-    parameters: {
-        required: ['id', 'replicatedFields'],
-        optional: []
-    }
-};
+const adapterName$6 = 'updateReplicatedFields';
+const updateReplicatedFields_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', true),
+    generateParamConfigMetadata('replicatedFields', true),
+];
+const updateReplicatedFields_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, updateReplicatedFields_ConfigPropertyMetadata);
 function createResourceParams$6(config) {
     const resourceParams = {
         urlParams: {
@@ -27159,26 +25970,8 @@ const ingest$5 = function DatasetCoverageRepresentationIngest(input, path, luvio
         }
     }
     const key = path.fullPath;
-    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$l(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$l,
-            representationName: RepresentationType$5,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$5, "WAVE", VERSION$l, RepresentationType$5, equals$l);
     return createLink(key);
 };
 function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
@@ -27243,13 +26036,12 @@ function createResourceRequest$5(config) {
     };
 }
 
-const getSecurityCoverageDatasetVersion_ConfigPropertyNames = {
-    displayName: 'getSecurityCoverageDatasetVersion',
-    parameters: {
-        required: ['datasetIdOrApiName', 'versionId'],
-        optional: []
-    }
-};
+const adapterName$5 = 'getSecurityCoverageDatasetVersion';
+const getSecurityCoverageDatasetVersion_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('datasetIdOrApiName', true),
+    generateParamConfigMetadata('versionId', true),
+];
+const getSecurityCoverageDatasetVersion_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getSecurityCoverageDatasetVersion_ConfigPropertyMetadata);
 function createResourceParams$5(config) {
     const resourceParams = {
         urlParams: {
@@ -27316,21 +26108,7 @@ function buildNetworkSnapshot$5(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$5(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
@@ -28504,26 +27282,8 @@ const ingest$4 = function TemplateRepresentationIngest(input, path, luvio, store
         }
     }
     const key = keyBuilderFromType$3(luvio, input);
-    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$e(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$e,
-            representationName: RepresentationType$4,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "WAVE", VERSION$e, RepresentationType$4, equals$e);
     return createLink(key);
 };
 function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
@@ -28574,7 +27334,7 @@ function normalize$3(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -28614,26 +27374,8 @@ const ingest$3 = function TemplateCollectionRepresentationIngest(input, path, lu
         }
     }
     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
-    }, luvio, store);
-    if (existingRecord === undefined || equals$d(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$d,
-            representationName: RepresentationType$3,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "WAVE", VERSION$d, RepresentationType$3, equals$d);
     return createLink(key);
 };
 function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
@@ -28702,13 +27444,12 @@ function createResourceRequest$4(config) {
     };
 }
 
-const getWaveTemplates_ConfigPropertyNames = {
-    displayName: 'getWaveTemplates',
-    parameters: {
-        required: [],
-        optional: ['options', 'type']
-    }
-};
+const adapterName$4 = 'getWaveTemplates';
+const getWaveTemplates_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('options', false),
+    generateParamConfigMetadata('type', false),
+];
+const getWaveTemplates_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getWaveTemplates_ConfigPropertyMetadata);
 function createResourceParams$4(config) {
     const resourceParams = {
         queryParams: {
@@ -28775,21 +27516,7 @@ function buildNetworkSnapshot$4(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$4(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
@@ -28910,13 +27637,12 @@ function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     return buildCachedSnapshotCachePolicy$4(context, storeLookup);
 }
 
-const getWaveTemplate_ConfigPropertyNames = {
-    displayName: 'getWaveTemplate',
-    parameters: {
-        required: ['templateIdOrApiName'],
-        optional: ['options']
-    }
-};
+const adapterName$3 = 'getWaveTemplate';
+const getWaveTemplate_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('templateIdOrApiName', true),
+    generateParamConfigMetadata('options', false),
+];
+const getWaveTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getWaveTemplate_ConfigPropertyMetadata);
 function createResourceParams$3(config) {
     const resourceParams = {
         urlParams: {
@@ -28986,21 +27712,7 @@ function buildNetworkSnapshot$3(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$3(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
@@ -30164,26 +28876,8 @@ const ingest$2 = function TemplateConfigurationRepresentationIngest(input, path,
         }
     }
     const key = keyBuilderFromType$2(luvio, input);
-    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$3(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$3,
-            representationName: RepresentationType$2,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "WAVE", VERSION$3, RepresentationType$2, equals$3);
     return createLink(key);
 };
 function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
@@ -30287,13 +28981,13 @@ function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     return buildCachedSnapshotCachePolicy$2(context, storeLookup);
 }
 
-const getWaveTemplateConfig_ConfigPropertyNames = {
-    displayName: 'getWaveTemplateConfig',
-    parameters: {
-        required: ['templateIdOrApiName'],
-        optional: ['disableApex', 'options']
-    }
-};
+const adapterName$2 = 'getWaveTemplateConfig';
+const getWaveTemplateConfig_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('templateIdOrApiName', true),
+    generateParamConfigMetadata('disableApex', false),
+    generateParamConfigMetadata('options', false),
+];
+const getWaveTemplateConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getWaveTemplateConfig_ConfigPropertyMetadata);
 function createResourceParams$2(config) {
     const resourceParams = {
         urlParams: {
@@ -30364,21 +29058,7 @@ function buildNetworkSnapshot$2(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$2(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
@@ -30544,26 +29224,8 @@ const ingest$1 = function TemplateReleaseNotesRepresentationIngest(input, path,
         }
     }
     const key = keyBuilderFromType$1(luvio, input);
-    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$2(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "WAVE",
-            version: VERSION$2,
-            representationName: RepresentationType$1,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "WAVE", VERSION$2, RepresentationType$1, equals$2);
     return createLink(key);
 };
 function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
@@ -30667,13 +29329,11 @@ function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     return buildCachedSnapshotCachePolicy(context, storeLookup);
 }
 
-const getWaveTemplateReleaseNotes_ConfigPropertyNames = {
-    displayName: 'getWaveTemplateReleaseNotes',
-    parameters: {
-        required: ['templateIdOrApiName'],
-        optional: []
-    }
-};
+const adapterName$1 = 'getWaveTemplateReleaseNotes';
+const getWaveTemplateReleaseNotes_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('templateIdOrApiName', true),
+];
+const getWaveTemplateReleaseNotes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getWaveTemplateReleaseNotes_ConfigPropertyMetadata);
 function createResourceParams$1(config) {
     const resourceParams = {
         urlParams: {
@@ -30739,21 +29399,7 @@ function buildNetworkSnapshot$1(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$1(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext, buildNetworkSnapshot$1, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
@@ -31125,26 +29771,8 @@ const ingest = function TemplateValidateRepresentationIngest(input, path, luvio,
         }
     }
     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: "WAVE",
-            version: VERSION,
-            representationName: RepresentationType,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "WAVE", VERSION, RepresentationType, equals);
     return createLink(key);
 };
 function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
@@ -31194,13 +29822,12 @@ function createResourceRequest(config) {
     };
 }
 
-const validateWaveTemplate_ConfigPropertyNames = {
-    displayName: 'validateWaveTemplate',
-    parameters: {
-        required: ['templateIdOrApiName', 'templateValidateParam'],
-        optional: []
-    }
-};
+const adapterName = 'validateWaveTemplate';
+const validateWaveTemplate_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('templateIdOrApiName', true),
+    generateParamConfigMetadata('templateValidateParam', true),
+];
+const validateWaveTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, validateWaveTemplate_ConfigPropertyMetadata);
 function createResourceParams(config) {
     const resourceParams = {
         urlParams: {