@salesforce/lds-adapters-cms-authoring 1.213.0 → 1.213.1

package/dist/es/es2018/cms-authoring.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$i, typeCheckScalars, StoreKeyMap, typeCheckArrayOfScalars } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -48,6 +48,24 @@ const snapshotRefreshOptions = {
         },
     }
 };
+function generateParamConfigMetadata(name, required, coerceFn) {
+    return {
+        name,
+        required,
+        coerceFn,
+    };
+}
+function buildAdapterValidationConfig(displayName, paramsMeta) {
+    const required = paramsMeta.filter(p => p.required).map(p => p.name);
+    const optional = paramsMeta.filter(p => !p.required).map(p => p.name);
+    return {
+        displayName,
+        parameters: {
+            required,
+            optional,
+        }
+    };
+}
 const keyPrefix = 'CMSAuthoring';
 
 const { keys: ObjectKeys, create: ObjectCreate, assign: ObjectAssign } = Object;
@@ -348,26 +366,8 @@ const ingest$m = function ManagedContentDeploymentRepresentationIngest(input, pa
         }
     }
     const key = keyBuilderFromType$b(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$m;
-    let incomingRecord = normalize$m(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);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$q,
-            representationName: RepresentationType$m,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$m, "CMSAuthoring", VERSION$q, RepresentationType$m, equals$q);
     return createLink(key);
 };
 function getTypeCacheKeys$m(rootKeySet, luvio, input, fullPathFactory) {
@@ -475,7 +475,7 @@ function normalize$l(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -542,26 +542,8 @@ const ingest$l = function ManagedContentDeploymentCollectionRepresentationIngest
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$l;
-    let incomingRecord = normalize$l(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$p(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$p,
-            representationName: RepresentationType$l,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$l, "CMSAuthoring", VERSION$p, RepresentationType$l, equals$p);
     return createLink(key);
 };
 function getTypeCacheKeys$l(rootKeySet, luvio, input, fullPathFactory) {
@@ -630,13 +612,17 @@ function createResourceRequest$t(config) {
     };
 }
 
-const getDeploymentById_ConfigPropertyNames = {
-    displayName: 'getDeploymentById',
-    parameters: {
-        required: [],
-        optional: ['contentSpaceId', 'deploymentId', 'deploymentStatus', 'deploymentType', 'managedContentVersionId', 'page', 'pageSize']
-    }
-};
+const adapterName$t = 'getDeploymentById';
+const getDeploymentById_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentSpaceId', false),
+    generateParamConfigMetadata('deploymentId', false),
+    generateParamConfigMetadata('deploymentStatus', false),
+    generateParamConfigMetadata('deploymentType', false),
+    generateParamConfigMetadata('managedContentVersionId', false),
+    generateParamConfigMetadata('page', false),
+    generateParamConfigMetadata('pageSize', false),
+];
+const getDeploymentById_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$t, getDeploymentById_ConfigPropertyMetadata);
 function createResourceParams$t(config) {
     const resourceParams = {
         queryParams: {
@@ -708,21 +694,7 @@ function buildNetworkSnapshot$t(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$t(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$t, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$h(context, storeLookup) {
     const { luvio, config } = context;
@@ -868,13 +840,11 @@ function createResourceRequest$s(config) {
     };
 }
 
-const createDeployment_ConfigPropertyNames = {
-    displayName: 'createDeployment',
-    parameters: {
-        required: ['DeploymentInput'],
-        optional: []
-    }
-};
+const adapterName$s = 'createDeployment';
+const createDeployment_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('DeploymentInput', true),
+];
+const createDeployment_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$s, createDeployment_ConfigPropertyMetadata);
 function createResourceParams$s(config) {
     const resourceParams = {
         body: {
@@ -1300,26 +1270,8 @@ const ingest$k = function ManagedContentV2JobDetailRepresentationIngest(input, p
         }
     }
     const key = keyBuilderFromType$a(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$k;
-    let incomingRecord = normalize$k(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$m(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$m,
-            representationName: RepresentationType$k,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$k, "CMSAuthoring", VERSION$m, RepresentationType$k, equals$m);
     return createLink(key);
 };
 function getTypeCacheKeys$k(rootKeySet, luvio, input, fullPathFactory) {
@@ -1427,7 +1379,7 @@ function normalize$j(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -1494,26 +1446,8 @@ const ingest$j = function ManagedContentJobCollectionRepresentationIngest(input,
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$j;
-    let incomingRecord = normalize$j(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$l(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$l,
-            representationName: RepresentationType$j,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$j, "CMSAuthoring", VERSION$l, RepresentationType$j, equals$l);
     return createLink(key);
 };
 function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
@@ -1582,13 +1516,14 @@ function createResourceRequest$r(config) {
     };
 }
 
-const getAllCMSJobsForSpace_ConfigPropertyNames = {
-    displayName: 'getAllCMSJobsForSpace',
-    parameters: {
-        required: ['contentSpaceId'],
-        optional: ['jobType', 'page', 'pageSize']
-    }
-};
+const adapterName$r = 'getAllCMSJobsForSpace';
+const getAllCMSJobsForSpace_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentSpaceId', true),
+    generateParamConfigMetadata('jobType', false),
+    generateParamConfigMetadata('page', false),
+    generateParamConfigMetadata('pageSize', false),
+];
+const getAllCMSJobsForSpace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$r, getAllCMSJobsForSpace_ConfigPropertyMetadata);
 function createResourceParams$r(config) {
     const resourceParams = {
         urlParams: {
@@ -1660,21 +1595,7 @@ function buildNetworkSnapshot$r(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$r(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$r, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$g(context, storeLookup) {
     const { luvio, config } = context;
@@ -1753,13 +1674,12 @@ function createResourceRequest$q(config) {
     };
 }
 
-const getCMSJobForSpace_ConfigPropertyNames = {
-    displayName: 'getCMSJobForSpace',
-    parameters: {
-        required: ['contentSpaceId', 'jobId'],
-        optional: []
-    }
-};
+const adapterName$q = 'getCMSJobForSpace';
+const getCMSJobForSpace_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentSpaceId', true),
+    generateParamConfigMetadata('jobId', true),
+];
+const getCMSJobForSpace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$q, getCMSJobForSpace_ConfigPropertyMetadata);
 function createResourceParams$q(config) {
     const resourceParams = {
         urlParams: {
@@ -1826,21 +1746,7 @@ function buildNetworkSnapshot$q(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$q(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$q, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$f(context, storeLookup) {
     const { luvio, config } = context;
@@ -2035,26 +1941,8 @@ const ingest$i = function ManagedContentSpaceFolderItemV1CollectionRepresentatio
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$i;
-    let incomingRecord = normalize$i(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$k(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$k,
-            representationName: RepresentationType$i,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$i, "CMSAuthoring", VERSION$k, RepresentationType$i, equals$k);
     return createLink(key);
 };
 function getTypeCacheKeys$i(rootKeySet, luvio, input, fullPathFactory) {
@@ -2119,13 +2007,21 @@ function createResourceRequest$p(config) {
     };
 }
 
-const getManagedContentSpaceFolderItemsV1_ConfigPropertyNames = {
-    displayName: 'getManagedContentSpaceFolderItemsV1',
-    parameters: {
-        required: ['folderId'],
-        optional: ['contentTypeFilter', 'contentTypes', 'filter', 'managedContentType', 'page', 'pageSize', 'queryTerm', 'showPublishedOnly', 'sortBy', 'sortOrder']
-    }
-};
+const adapterName$p = 'getManagedContentSpaceFolderItemsV1';
+const getManagedContentSpaceFolderItemsV1_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('folderId', true),
+    generateParamConfigMetadata('contentTypeFilter', false),
+    generateParamConfigMetadata('contentTypes', false),
+    generateParamConfigMetadata('filter', false),
+    generateParamConfigMetadata('managedContentType', false),
+    generateParamConfigMetadata('page', false),
+    generateParamConfigMetadata('pageSize', false),
+    generateParamConfigMetadata('queryTerm', false),
+    generateParamConfigMetadata('showPublishedOnly', false),
+    generateParamConfigMetadata('sortBy', false),
+    generateParamConfigMetadata('sortOrder', false),
+];
+const getManagedContentSpaceFolderItemsV1_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$p, getManagedContentSpaceFolderItemsV1_ConfigPropertyMetadata);
 function createResourceParams$p(config) {
     const resourceParams = {
         urlParams: {
@@ -2206,21 +2102,7 @@ function buildNetworkSnapshot$p(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$p(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$p, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
     const { luvio, config } = context;
@@ -2476,26 +2358,8 @@ const ingest$h = function ManagedContentCollectionDetailRepresentationIngest(inp
         }
     }
     const key = keyBuilderFromType$9(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$h;
-    let incomingRecord = normalize$h(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$i(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$i,
-            representationName: RepresentationType$h,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$h, "CMSAuthoring", VERSION$i, RepresentationType$h, equals$i);
     return createLink(key);
 };
 function getTypeCacheKeys$h(rootKeySet, luvio, input, fullPathFactory) {
@@ -2579,13 +2443,13 @@ function onFetchResponseSuccess$f(luvio, config, resourceParams, response) {
     return onFetchResponseSuccess$e(luvio, config, updatedResourceParams, response);
 }
 
-const getCollectionItems_ConfigPropertyNames = {
-    displayName: 'getCollectionItems',
-    parameters: {
-        required: ['collectionKeyOrId'],
-        optional: ['language', 'version']
-    }
-};
+const adapterName$o = 'getCollectionItems';
+const getCollectionItems_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('collectionKeyOrId', true),
+    generateParamConfigMetadata('language', false),
+    generateParamConfigMetadata('version', false),
+];
+const getCollectionItems_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$o, getCollectionItems_ConfigPropertyMetadata);
 function createResourceParams$o(config) {
     const resourceParams = {
         urlParams: {
@@ -2656,21 +2520,7 @@ function buildNetworkSnapshot$o(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$o(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$o, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$d(context, storeLookup) {
     const { luvio, config } = context;
@@ -2959,26 +2809,8 @@ const ingest$g = function ManagedContentTranslationV2RepresentationIngest(input,
         }
     }
     const key = keyBuilderFromType$8(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$g;
-    let incomingRecord = normalize$g(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$h(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$h,
-            representationName: RepresentationType$g,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$g, "CMSAuthoring", VERSION$h, RepresentationType$g, equals$h);
     return createLink(key);
 };
 function getTypeCacheKeys$g(rootKeySet, luvio, input, fullPathFactory) {
@@ -3028,13 +2860,12 @@ function createResourceRequest$n(config) {
     };
 }
 
-const createTranslationV2Job_ConfigPropertyNames = {
-    displayName: 'createTranslationV2Job',
-    parameters: {
-        required: ['contentSpaceId', 'translationV2Request'],
-        optional: []
-    }
-};
+const adapterName$n = 'createTranslationV2Job';
+const createTranslationV2Job_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentSpaceId', true),
+    generateParamConfigMetadata('translationV2Request', true),
+];
+const createTranslationV2Job_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$n, createTranslationV2Job_ConfigPropertyMetadata);
 function createResourceParams$n(config) {
     const resourceParams = {
         urlParams: {
@@ -3530,26 +3361,8 @@ const ingest$f = function ManagedContentDocumentRepresentationIngest(input, path
         }
     }
     const key = keyBuilderFromType$7(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$f;
-    let incomingRecord = normalize$f(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$g(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$g,
-            representationName: RepresentationType$f,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$f, "CMSAuthoring", VERSION$g, RepresentationType$f, equals$g);
     return createLink(key);
 };
 function getTypeCacheKeys$f(rootKeySet, luvio, input, fullPathFactory) {
@@ -3606,13 +3419,11 @@ function ingestSuccess$l(luvio, resourceParams, response) {
     return ingestSuccess$m(luvio, resourceParams, response);
 }
 
-const createManagedContent_ConfigPropertyNames = {
-    displayName: 'createManagedContent',
-    parameters: {
-        required: ['ManagedContentInputParam'],
-        optional: []
-    }
-};
+const adapterName$m = 'createManagedContent';
+const createManagedContent_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('ManagedContentInputParam', true),
+];
+const createManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$m, createManagedContent_ConfigPropertyMetadata);
 function createResourceParams$m(config) {
     const resourceParams = {
         body: {
@@ -3825,26 +3636,8 @@ const ingest$e = function ManagedContentPublishOutputRepresentationIngest(input,
         }
     }
     const key = keyBuilderFromType$6(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$e;
-    let incomingRecord = normalize$e(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$f(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$f,
-            representationName: RepresentationType$e,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$e, "CMSAuthoring", VERSION$f, RepresentationType$e, equals$f);
     return createLink(key);
 };
 function getTypeCacheKeys$e(rootKeySet, luvio, input, fullPathFactory) {
@@ -3894,13 +3687,11 @@ function createResourceRequest$l(config) {
     };
 }
 
-const publishManagedContent_ConfigPropertyNames = {
-    displayName: 'publishManagedContent',
-    parameters: {
-        required: ['publishInput'],
-        optional: []
-    }
-};
+const adapterName$l = 'publishManagedContent';
+const publishManagedContent_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('publishInput', true),
+];
+const publishManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$l, publishManagedContent_ConfigPropertyMetadata);
 function createResourceParams$l(config) {
     const resourceParams = {
         body: {
@@ -4106,26 +3897,8 @@ const ingest$d = function ManagedContentUnpublishOutputRepresentationIngest(inpu
         }
     }
     const key = keyBuilderFromType$5(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$d;
-    let incomingRecord = normalize$d(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: "CMSAuthoring",
-            version: VERSION$e,
-            representationName: RepresentationType$d,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$d, "CMSAuthoring", VERSION$e, RepresentationType$d, equals$e);
     return createLink(key);
 };
 function getTypeCacheKeys$d(rootKeySet, luvio, input, fullPathFactory) {
@@ -4175,13 +3948,11 @@ function createResourceRequest$k(config) {
     };
 }
 
-const unpublishManagedContent_ConfigPropertyNames = {
-    displayName: 'unpublishManagedContent',
-    parameters: {
-        required: ['unpublishInput'],
-        optional: []
-    }
-};
+const adapterName$k = 'unpublishManagedContent';
+const unpublishManagedContent_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('unpublishInput', true),
+];
+const unpublishManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$k, unpublishManagedContent_ConfigPropertyMetadata);
 function createResourceParams$k(config) {
     const resourceParams = {
         body: {
@@ -4445,26 +4216,8 @@ const ingest$c = function ManagedContentVariantRepresentationIngest(input, path,
         }
     }
     const key = keyBuilderFromType$4(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$c;
-    let incomingRecord = normalize$c(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$d(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$d,
-            representationName: RepresentationType$c,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$c, "CMSAuthoring", VERSION$d, RepresentationType$c, equals$d);
     return createLink(key);
 };
 function getTypeCacheKeys$c(rootKeySet, luvio, input, fullPathFactory) {
@@ -4514,13 +4267,11 @@ function createResourceRequest$j(config) {
     };
 }
 
-const createManagedContentVariant_ConfigPropertyNames = {
-    displayName: 'createManagedContentVariant',
-    parameters: {
-        required: ['managedContentVariantInputParam'],
-        optional: []
-    }
-};
+const adapterName$j = 'createManagedContentVariant';
+const createManagedContentVariant_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('managedContentVariantInputParam', true),
+];
+const createManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$j, createManagedContentVariant_ConfigPropertyMetadata);
 function createResourceParams$j(config) {
     const resourceParams = {
         body: {
@@ -4611,14 +4362,11 @@ function createResourceRequest$i(config) {
     };
 }
 
-const adapterName = 'deleteManagedContentVariant';
-const deleteManagedContentVariant_ConfigPropertyNames = {
-    displayName: 'deleteManagedContentVariant',
-    parameters: {
-        required: ['variantId'],
-        optional: []
-    }
-};
+const adapterName$i = 'deleteManagedContentVariant';
+const deleteManagedContentVariant_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('variantId', true),
+];
+const deleteManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$i, deleteManagedContentVariant_ConfigPropertyMetadata);
 function createResourceParams$i(config) {
     const resourceParams = {
         urlParams: {
@@ -4670,7 +4418,7 @@ const deleteManagedContentVariantAdapterFactory = (luvio) => {
         const config = validateAdapterConfig$i(untrustedConfig, deleteManagedContentVariant_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName}"`);
+            throw new Error(`Invalid config for "${adapterName$i}"`);
         }
         return buildNetworkSnapshot$i(luvio, config);
     };
@@ -4730,13 +4478,11 @@ function createResourceRequest$h(config) {
     };
 }
 
-const getManagedContentVariant_ConfigPropertyNames = {
-    displayName: 'getManagedContentVariant',
-    parameters: {
-        required: ['variantId'],
-        optional: []
-    }
-};
+const adapterName$h = 'getManagedContentVariant';
+const getManagedContentVariant_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('variantId', true),
+];
+const getManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$h, getManagedContentVariant_ConfigPropertyMetadata);
 function createResourceParams$h(config) {
     const resourceParams = {
         urlParams: {
@@ -4802,21 +4548,7 @@ function buildNetworkSnapshot$h(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$c(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$h(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$h, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$c(context, storeLookup) {
     const { luvio, config } = context;
@@ -4911,13 +4643,12 @@ function createResourceRequest$g(config) {
     };
 }
 
-const replaceManagedContentVariant_ConfigPropertyNames = {
-    displayName: 'replaceManagedContentVariant',
-    parameters: {
-        required: ['variantId', 'ManagedContentVariantInputParam'],
-        optional: []
-    }
-};
+const adapterName$g = 'replaceManagedContentVariant';
+const replaceManagedContentVariant_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('variantId', true),
+    generateParamConfigMetadata('ManagedContentVariantInputParam', true),
+];
+const replaceManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$g, replaceManagedContentVariant_ConfigPropertyMetadata);
 function createResourceParams$g(config) {
     const resourceParams = {
         urlParams: {
@@ -5118,26 +4849,8 @@ const ingest$b = function ManagedContentVariantVersionCollectionRepresentationIn
         }
     }
     const key = keyBuilderFromType$3(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$b;
-    let incomingRecord = normalize$b(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$c(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$c,
-            representationName: RepresentationType$b,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$b, "CMSAuthoring", VERSION$c, RepresentationType$b, equals$c);
     return createLink(key);
 };
 function getTypeCacheKeys$b(rootKeySet, luvio, input, fullPathFactory) {
@@ -5204,13 +4917,14 @@ function createResourceRequest$f(config) {
     };
 }
 
-const getManagedContentVariantVersions_ConfigPropertyNames = {
-    displayName: 'getManagedContentVariantVersions',
-    parameters: {
-        required: ['variantId'],
-        optional: ['page', 'pageSize', 'status']
-    }
-};
+const adapterName$f = 'getManagedContentVariantVersions';
+const getManagedContentVariantVersions_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('variantId', true),
+    generateParamConfigMetadata('page', false),
+    generateParamConfigMetadata('pageSize', false),
+    generateParamConfigMetadata('status', false),
+];
+const getManagedContentVariantVersions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, getManagedContentVariantVersions_ConfigPropertyMetadata);
 function createResourceParams$f(config) {
     const resourceParams = {
         urlParams: {
@@ -5284,21 +4998,7 @@ function buildNetworkSnapshot$f(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$b(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$f(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$f, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$b(context, storeLookup) {
     const { luvio, config } = context;
@@ -5431,13 +5131,13 @@ function onFetchResponseSuccess$b(luvio, config, resourceParams, response) {
     return onFetchResponseSuccess$a(luvio, config, resourceParams, response);
 }
 
-const getManagedContent_ConfigPropertyNames = {
-    displayName: 'getManagedContent',
-    parameters: {
-        required: ['contentKeyOrId'],
-        optional: ['language', 'version']
-    }
-};
+const adapterName$e = 'getManagedContent';
+const getManagedContent_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentKeyOrId', true),
+    generateParamConfigMetadata('language', false),
+    generateParamConfigMetadata('version', false),
+];
+const getManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, getManagedContent_ConfigPropertyMetadata);
 function createResourceParams$e(config) {
     const resourceParams = {
         urlParams: {
@@ -5508,21 +5208,7 @@ function buildNetworkSnapshot$e(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$e(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$e, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     const { luvio, config } = context;
@@ -5626,26 +5312,8 @@ const ingest$a = function ManagedContentRenditionRepresentationIngest(input, pat
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$a;
-    let incomingRecord = normalize$a(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: "CMSAuthoring",
-            version: VERSION$b,
-            representationName: RepresentationType$a,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$a, "CMSAuthoring", VERSION$b, RepresentationType$a, equals$b);
     return createLink(key);
 };
 function getTypeCacheKeys$a(rootKeySet, luvio, input, fullPathFactory) {
@@ -5710,13 +5378,15 @@ function createResourceRequest$d(config) {
     };
 }
 
-const getManagedContentVariantRendition_ConfigPropertyNames = {
-    displayName: 'getManagedContentVariantRendition',
-    parameters: {
-        required: ['contentKeyOrId', 'renditionType'],
-        optional: ['channelIdOrApiName', 'language', 'version']
-    }
-};
+const adapterName$d = 'getManagedContentVariantRendition';
+const getManagedContentVariantRendition_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentKeyOrId', true),
+    generateParamConfigMetadata('renditionType', true),
+    generateParamConfigMetadata('channelIdOrApiName', false),
+    generateParamConfigMetadata('language', false),
+    generateParamConfigMetadata('version', false),
+];
+const getManagedContentVariantRendition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, getManagedContentVariantRendition_ConfigPropertyMetadata);
 function createResourceParams$d(config) {
     const resourceParams = {
         urlParams: {
@@ -5789,21 +5459,7 @@ function buildNetworkSnapshot$d(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$d(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$d, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
     const { luvio, config } = context;
@@ -5982,26 +5638,8 @@ const ingest$9 = function ManagedContentReferencedByCollectionRepresentationInge
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$9;
-    let incomingRecord = normalize$9(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$a(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$a,
-            representationName: RepresentationType$9,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$9, "CMSAuthoring", VERSION$a, RepresentationType$9, equals$a);
     return createLink(key);
 };
 function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
@@ -6066,13 +5704,15 @@ function createResourceRequest$c(config) {
     };
 }
 
-const getManagedContentReferencedBy_ConfigPropertyNames = {
-    displayName: 'getManagedContentReferencedBy',
-    parameters: {
-        required: ['contentKeyOrId'],
-        optional: ['includeReferenceDetails', 'page', 'pageSize', 'referenceType']
-    }
-};
+const adapterName$c = 'getManagedContentReferencedBy';
+const getManagedContentReferencedBy_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentKeyOrId', true),
+    generateParamConfigMetadata('includeReferenceDetails', false),
+    generateParamConfigMetadata('page', false),
+    generateParamConfigMetadata('pageSize', false),
+    generateParamConfigMetadata('referenceType', false),
+];
+const getManagedContentReferencedBy_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, getManagedContentReferencedBy_ConfigPropertyMetadata);
 function createResourceParams$c(config) {
     const resourceParams = {
         urlParams: {
@@ -6145,21 +5785,7 @@ function buildNetworkSnapshot$c(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$c(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$c, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
@@ -6347,26 +5973,8 @@ const ingest$8 = function ManagedContentVariantReferencesCollectionRepresentatio
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$8;
-    let incomingRecord = normalize$8(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$9(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$9,
-            representationName: RepresentationType$8,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$8, "CMSAuthoring", VERSION$9, RepresentationType$8, equals$9);
     return createLink(key);
 };
 function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
@@ -6431,13 +6039,12 @@ function createResourceRequest$b(config) {
     };
 }
 
-const getManagedContentVariantReferences_ConfigPropertyNames = {
-    displayName: 'getManagedContentVariantReferences',
-    parameters: {
-        required: ['contentKeyOrId'],
-        optional: ['variantIds']
-    }
-};
+const adapterName$b = 'getManagedContentVariantReferences';
+const getManagedContentVariantReferences_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentKeyOrId', true),
+    generateParamConfigMetadata('variantIds', false),
+];
+const getManagedContentVariantReferences_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, getManagedContentVariantReferences_ConfigPropertyMetadata);
 function createResourceParams$b(config) {
     const resourceParams = {
         urlParams: {
@@ -6509,21 +6116,7 @@ function buildNetworkSnapshot$b(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$b(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$b, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
@@ -6739,26 +6332,8 @@ const ingest$7 = function ManagedContentSpaceFolderItemCollectionRepresentationI
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$7;
-    let incomingRecord = normalize$7(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$8(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$8,
-            representationName: RepresentationType$7,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$7, "CMSAuthoring", VERSION$8, RepresentationType$7, equals$8);
     return createLink(key);
 };
 function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
@@ -6823,13 +6398,21 @@ function createResourceRequest$a(config) {
     };
 }
 
-const getManagedContentByFolderId_ConfigPropertyNames = {
-    displayName: 'getManagedContentByFolderId',
-    parameters: {
-        required: ['folderId'],
-        optional: ['contentType', 'contentTypeFilter', 'contentTypes', 'filter', 'page', 'pageSize', 'queryTerm', 'showPublishedOnly', 'sortBy', 'sortOrder']
-    }
-};
+const adapterName$a = 'getManagedContentByFolderId';
+const getManagedContentByFolderId_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('folderId', true),
+    generateParamConfigMetadata('contentType', false),
+    generateParamConfigMetadata('contentTypeFilter', false),
+    generateParamConfigMetadata('contentTypes', false),
+    generateParamConfigMetadata('filter', false),
+    generateParamConfigMetadata('page', false),
+    generateParamConfigMetadata('pageSize', false),
+    generateParamConfigMetadata('queryTerm', false),
+    generateParamConfigMetadata('showPublishedOnly', false),
+    generateParamConfigMetadata('sortBy', false),
+    generateParamConfigMetadata('sortOrder', false),
+];
+const getManagedContentByFolderId_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, getManagedContentByFolderId_ConfigPropertyMetadata);
 function createResourceParams$a(config) {
     const resourceParams = {
         urlParams: {
@@ -6910,21 +6493,7 @@ function buildNetworkSnapshot$a(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$a(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$a, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
@@ -7073,26 +6642,8 @@ const ingest$6 = function ManagedContentSearchResultItemsCollectionRepresentatio
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$6;
-    let incomingRecord = normalize$6(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$7(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$7,
-            representationName: RepresentationType$6,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$6, "CMSAuthoring", VERSION$7, RepresentationType$6, equals$7);
     return createLink(key);
 };
 function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
@@ -7157,13 +6708,17 @@ function createResourceRequest$9(config) {
     };
 }
 
-const getSearchResults_ConfigPropertyNames = {
-    displayName: 'getSearchResults',
-    parameters: {
-        required: ['queryTerm'],
-        optional: ['contentSpaceOrFolderIds', 'contentTypeFQN', 'languages', 'page', 'pageSize', 'scope']
-    }
-};
+const adapterName$9 = 'getSearchResults';
+const getSearchResults_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentSpaceOrFolderIds', false),
+    generateParamConfigMetadata('contentTypeFQN', false),
+    generateParamConfigMetadata('languages', false),
+    generateParamConfigMetadata('page', false),
+    generateParamConfigMetadata('pageSize', false),
+    generateParamConfigMetadata('queryTerm', true),
+    generateParamConfigMetadata('scope', false),
+];
+const getSearchResults_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getSearchResults_ConfigPropertyMetadata);
 function createResourceParams$9(config) {
     const resourceParams = {
         queryParams: {
@@ -7237,21 +6792,7 @@ function buildNetworkSnapshot$9(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$9(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
@@ -7500,26 +7041,8 @@ const ingest$5 = function ManagedContentSpaceRepresentationIngest(input, path, l
         }
     }
     const key = keyBuilderFromType$2(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$5;
-    let incomingRecord = normalize$5(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$6(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$6,
-            representationName: RepresentationType$5,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$5, "CMSAuthoring", VERSION$6, RepresentationType$5, equals$6);
     return createLink(key);
 };
 function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
@@ -7583,26 +7106,8 @@ const ingest$4 = function ManagedContentSpaceCollectionRepresentationIngest(inpu
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$4;
-    let incomingRecord = normalize$4(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$5(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$5,
-            representationName: RepresentationType$4,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "CMSAuthoring", VERSION$5, RepresentationType$4, equals$5);
     return createLink(key);
 };
 function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
@@ -7667,13 +7172,13 @@ function createResourceRequest$8(config) {
     };
 }
 
-const getManagedContentSpaces_ConfigPropertyNames = {
-    displayName: 'getManagedContentSpaces',
-    parameters: {
-        required: [],
-        optional: ['page', 'pageSize', 'nameFragment']
-    }
-};
+const adapterName$8 = 'getManagedContentSpaces';
+const getManagedContentSpaces_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('page', false),
+    generateParamConfigMetadata('pageSize', false),
+    generateParamConfigMetadata('nameFragment', false),
+];
+const getManagedContentSpaces_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getManagedContentSpaces_ConfigPropertyMetadata);
 function createResourceParams$8(config) {
     const resourceParams = {
         queryParams: {
@@ -7741,21 +7246,7 @@ function buildNetworkSnapshot$8(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$8(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
@@ -7834,13 +7325,11 @@ function createResourceRequest$7(config) {
     };
 }
 
-const getManagedContentSpace_ConfigPropertyNames = {
-    displayName: 'getManagedContentSpace',
-    parameters: {
-        required: ['contentSpaceId'],
-        optional: []
-    }
-};
+const adapterName$7 = 'getManagedContentSpace';
+const getManagedContentSpace_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentSpaceId', true),
+];
+const getManagedContentSpace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getManagedContentSpace_ConfigPropertyMetadata);
 function createResourceParams$7(config) {
     const resourceParams = {
         urlParams: {
@@ -7906,21 +7395,7 @@ function buildNetworkSnapshot$7(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$7(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
@@ -8075,13 +7550,12 @@ function createResourceRequest$6(config) {
     };
 }
 
-const patchManagedContentSpace_ConfigPropertyNames = {
-    displayName: 'patchManagedContentSpace',
-    parameters: {
-        required: ['contentSpaceId', 'ManagedContentSpaceInput'],
-        optional: []
-    }
-};
+const adapterName$6 = 'patchManagedContentSpace';
+const patchManagedContentSpace_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentSpaceId', true),
+    generateParamConfigMetadata('ManagedContentSpaceInput', true),
+];
+const patchManagedContentSpace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, patchManagedContentSpace_ConfigPropertyMetadata);
 function createResourceParams$6(config) {
     const resourceParams = {
         urlParams: {
@@ -8248,26 +7722,8 @@ const ingest$3 = function ManagedContentOrchestratorConfigRepresentationIngest(i
         }
     }
     const key = keyBuilderFromType$1(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$3;
-    let incomingRecord = normalize$3(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$4(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$4,
-            representationName: RepresentationType$3,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "CMSAuthoring", VERSION$4, RepresentationType$3, equals$4);
     return createLink(key);
 };
 function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
@@ -8334,13 +7790,11 @@ function createResourceRequest$5(config) {
     };
 }
 
-const getManagedContentSpaceOrchestratorConfig_ConfigPropertyNames = {
-    displayName: 'getManagedContentSpaceOrchestratorConfig',
-    parameters: {
-        required: ['contentSpaceId'],
-        optional: []
-    }
-};
+const adapterName$5 = 'getManagedContentSpaceOrchestratorConfig';
+const getManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentSpaceId', true),
+];
+const getManagedContentSpaceOrchestratorConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata);
 function createResourceParams$5(config) {
     const resourceParams = {
         urlParams: {
@@ -8406,21 +7860,7 @@ function buildNetworkSnapshot$5(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$5(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
@@ -8503,13 +7943,12 @@ function createResourceRequest$4(config) {
     };
 }
 
-const putManagedContentSpaceOrchestratorConfig_ConfigPropertyNames = {
-    displayName: 'putManagedContentSpaceOrchestratorConfig',
-    parameters: {
-        required: ['contentSpaceId', 'mContentOrchConfigInput'],
-        optional: []
-    }
-};
+const adapterName$4 = 'putManagedContentSpaceOrchestratorConfig';
+const putManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentSpaceId', true),
+    generateParamConfigMetadata('mContentOrchConfigInput', true),
+];
+const putManagedContentSpaceOrchestratorConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, putManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata);
 function createResourceParams$4(config) {
     const resourceParams = {
         urlParams: {
@@ -8655,26 +8094,8 @@ const ingest$2 = function ManagedContentTypeSummaryCollectionRepresentationInges
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$2;
-    let incomingRecord = normalize$2(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$3(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "CMSAuthoring",
-            version: VERSION$3,
-            representationName: RepresentationType$2,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "CMSAuthoring", VERSION$3, RepresentationType$2, equals$3);
     return createLink(key);
 };
 function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
@@ -8739,13 +8160,12 @@ function createResourceRequest$3(config) {
     };
 }
 
-const getManagedContentTypesForMixin_ConfigPropertyNames = {
-    displayName: 'getManagedContentTypesForMixin',
-    parameters: {
-        required: ['contentSpaceId'],
-        optional: ['mixinFQN']
-    }
-};
+const adapterName$3 = 'getManagedContentTypesForMixin';
+const getManagedContentTypesForMixin_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentSpaceId', true),
+    generateParamConfigMetadata('mixinFQN', false),
+];
+const getManagedContentTypesForMixin_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getManagedContentTypesForMixin_ConfigPropertyMetadata);
 function createResourceParams$3(config) {
     const resourceParams = {
         urlParams: {
@@ -8815,21 +8235,7 @@ function buildNetworkSnapshot$3(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$3(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { luvio, config } = context;
@@ -9096,26 +8502,8 @@ const ingest$1 = function ManagedContentV2JobRepresentationIngest(input, path, l
         }
     }
     const key = keyBuilderFromType(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: "CMSAuthoring",
-            version: VERSION$2,
-            representationName: RepresentationType$1,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "CMSAuthoring", VERSION$2, RepresentationType$1, equals$2);
     return createLink(key);
 };
 function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
@@ -9165,13 +8553,12 @@ function createResourceRequest$2(config) {
     };
 }
 
-const createManagedContentExportV2Job_ConfigPropertyNames = {
-    displayName: 'createManagedContentExportV2Job',
-    parameters: {
-        required: ['contentSpaceId', 'managedContentV2JobRequest'],
-        optional: []
-    }
-};
+const adapterName$2 = 'createManagedContentExportV2Job';
+const createManagedContentExportV2Job_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentSpaceId', true),
+    generateParamConfigMetadata('managedContentV2JobRequest', true),
+];
+const createManagedContentExportV2Job_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, createManagedContentExportV2Job_ConfigPropertyMetadata);
 function createResourceParams$2(config) {
     const resourceParams = {
         urlParams: {
@@ -9298,13 +8685,12 @@ function createResourceRequest$1(config) {
     };
 }
 
-const createManagedContentImportV2Job_ConfigPropertyNames = {
-    displayName: 'createManagedContentImportV2Job',
-    parameters: {
-        required: ['contentSpaceId', 'managedContentV2JobRequest'],
-        optional: []
-    }
-};
+const adapterName$1 = 'createManagedContentImportV2Job';
+const createManagedContentImportV2Job_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentSpaceId', true),
+    generateParamConfigMetadata('managedContentV2JobRequest', true),
+];
+const createManagedContentImportV2Job_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, createManagedContentImportV2Job_ConfigPropertyMetadata);
 function createResourceParams$1(config) {
     const resourceParams = {
         urlParams: {
@@ -9528,26 +8914,8 @@ const ingest = function ManagedContentPreviewCollectionRepresentationIngest(inpu
         }
     }
     const key = path.fullPath;
-    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: "CMSAuthoring",
-            version: VERSION,
-            representationName: RepresentationType,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "CMSAuthoring", VERSION, RepresentationType, equals);
     return createLink(key);
 };
 function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
@@ -9612,13 +8980,13 @@ function createResourceRequest(config) {
     };
 }
 
-const getManagedContentPreviews_ConfigPropertyNames = {
-    displayName: 'getManagedContentPreviews',
-    parameters: {
-        required: ['contentSpaceId'],
-        optional: ['isPreviewable', 'managedContentTypeName']
-    }
-};
+const adapterName = 'getManagedContentPreviews';
+const getManagedContentPreviews_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentSpaceId', true),
+    generateParamConfigMetadata('isPreviewable', false),
+    generateParamConfigMetadata('managedContentTypeName', false),
+];
+const getManagedContentPreviews_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getManagedContentPreviews_ConfigPropertyMetadata);
 function createResourceParams(config) {
     const resourceParams = {
         urlParams: {
@@ -9689,21 +9057,7 @@ function buildNetworkSnapshot(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(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;