@salesforce/lds-adapters-platform-learning-content 1.212.1 → 1.213.1

package/sfdc/index.js

@@ -14,7 +14,7 @@
 /* proxy-compat-disable */
 import { createInstrumentedAdapter, createLDSAdapter, createWireAdapterConstructor, createImperativeAdapter } from 'force/ldsBindings';
 import { withDefaultLuvio } from 'force/ldsEngine';
-import { serializeStructuredKey, deepFreeze, StoreKeyMap, typeCheckScalars, typeCheckArrayOfScalars } from 'force/luvioEngine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$9, typeCheckScalars, typeCheckArrayOfScalars } from 'force/luvioEngine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -58,6 +58,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 = 'LearningContentPlatform';
 
 const { keys: ObjectKeys, create: ObjectCreate, assign: ObjectAssign } = Object;
@@ -272,26 +290,8 @@ const ingest$b = function LearningItemProgressRepresentationIngest(input, path,
         }
     }
     const key = keyBuilderFromType$6(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$6;
-    let incomingRecord = normalize$b(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: "LearningContentPlatform",
-            version: VERSION$e,
-            representationName: RepresentationType$b,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$b, "LearningContentPlatform", VERSION$e, RepresentationType$b, equals$e);
     return createLink(key);
 };
 function getTypeCacheKeys$b(rootKeySet, luvio, input, fullPathFactory) {
@@ -341,13 +341,11 @@ function createResourceRequest$9(config) {
     };
 }
 
-const evaluateLearningItem_ConfigPropertyNames = {
-    displayName: 'evaluateLearningItem',
-    parameters: {
-        required: ['payload'],
-        optional: []
-    }
-};
+const adapterName$9 = 'evaluateLearningItem';
+const evaluateLearningItem_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('payload', true),
+];
+const evaluateLearningItem_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, evaluateLearningItem_ConfigPropertyMetadata);
 function createResourceParams$9(config) {
     const resourceParams = {
         body: {
@@ -1010,26 +1008,8 @@ const ingest$a = function FeaturedItemRepresentationIngest(input, path, luvio, s
         }
     }
     const key = keyBuilderFromType$5(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$5;
-    let incomingRecord = normalize$a(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: "LearningContentPlatform",
-            version: VERSION$d,
-            representationName: RepresentationType$a,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$a, "LearningContentPlatform", VERSION$d, RepresentationType$a, equals$d);
     return createLink(key);
 };
 function getTypeCacheKeys$a(rootKeySet, luvio, input, fullPathFactory) {
@@ -1079,7 +1059,7 @@ function normalize$9(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -1119,26 +1099,8 @@ const ingest$9 = function FeaturedItemRecommendedListRepresentationIngest(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$c(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "LearningContentPlatform",
-            version: VERSION$c,
-            representationName: RepresentationType$9,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$9, "LearningContentPlatform", VERSION$c, RepresentationType$9, equals$c);
     return createLink(key);
 };
 function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
@@ -1201,13 +1163,12 @@ function createResourceRequest$8(config) {
     };
 }
 
-const getFeaturedItemsRecommendedList_ConfigPropertyNames = {
-    displayName: 'getFeaturedItemsRecommendedList',
-    parameters: {
-        required: ['appId', 'context'],
-        optional: []
-    }
-};
+const adapterName$8 = 'getFeaturedItemsRecommendedList';
+const getFeaturedItemsRecommendedList_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('appId', true),
+    generateParamConfigMetadata('context', true),
+];
+const getFeaturedItemsRecommendedList_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getFeaturedItemsRecommendedList_ConfigPropertyMetadata);
 function createResourceParams$8(config) {
     const resourceParams = {
         queryParams: {
@@ -1274,21 +1235,7 @@ function buildNetworkSnapshot$8(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$8(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
@@ -1350,7 +1297,7 @@ function normalize$8(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -1390,26 +1337,8 @@ const ingest$8 = function FeaturedItemRelatedListRepresentationIngest(input, pat
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$8(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$b(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "LearningContentPlatform",
-            version: VERSION$b,
-            representationName: RepresentationType$8,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$8, "LearningContentPlatform", VERSION$b, RepresentationType$8, equals$b);
     return createLink(key);
 };
 function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
@@ -1472,13 +1401,12 @@ function createResourceRequest$7(config) {
     };
 }
 
-const getFeaturedItemsRelatedList_ConfigPropertyNames = {
-    displayName: 'getFeaturedItemsRelatedList',
-    parameters: {
-        required: ['appId', 'pageRef'],
-        optional: []
-    }
-};
+const adapterName$7 = 'getFeaturedItemsRelatedList';
+const getFeaturedItemsRelatedList_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('appId', true),
+    generateParamConfigMetadata('pageRef', true),
+];
+const getFeaturedItemsRelatedList_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getFeaturedItemsRelatedList_ConfigPropertyMetadata);
 function createResourceParams$7(config) {
     const resourceParams = {
         queryParams: {
@@ -1545,21 +1473,7 @@ function buildNetworkSnapshot$7(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$7(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
@@ -1659,26 +1573,8 @@ const ingest$7 = function LearningConfigRepresentationIngest(input, path, luvio,
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$7(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: "LearningContentPlatform",
-            version: VERSION$a,
-            representationName: RepresentationType$7,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$7, "LearningContentPlatform", VERSION$a, RepresentationType$7, equals$a);
     return createLink(key);
 };
 function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
@@ -1737,13 +1633,9 @@ function createResourceRequest$6(config) {
     };
 }
 
-const getLearningConfig_ConfigPropertyNames = {
-    displayName: 'getLearningConfig',
-    parameters: {
-        required: [],
-        optional: []
-    }
-};
+const adapterName$6 = 'getLearningConfig';
+const getLearningConfig_ConfigPropertyMetadata = [];
+const getLearningConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getLearningConfig_ConfigPropertyMetadata);
 function createResourceParams$6(config) {
     const resourceParams = {};
     return resourceParams;
@@ -1800,21 +1692,7 @@ function buildNetworkSnapshot$6(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$6(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
@@ -1876,7 +1754,7 @@ function normalize$6(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -1916,26 +1794,8 @@ const ingest$6 = function LearningItemProgressListRepresentationIngest(input, pa
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$6(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$9(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "LearningContentPlatform",
-            version: VERSION$9,
-            representationName: RepresentationType$6,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$6, "LearningContentPlatform", VERSION$9, RepresentationType$6, equals$9);
     return createLink(key);
 };
 function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
@@ -1998,13 +1858,11 @@ function createResourceRequest$5(config) {
     };
 }
 
-const getLearningItemProgress_ConfigPropertyNames = {
-    displayName: 'getLearningItemProgress',
-    parameters: {
-        required: [],
-        optional: ['learningItemIds']
-    }
-};
+const adapterName$5 = 'getLearningItemProgress';
+const getLearningItemProgress_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('learningItemIds', false),
+];
+const getLearningItemProgress_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getLearningItemProgress_ConfigPropertyMetadata);
 function createResourceParams$5(config) {
     const resourceParams = {
         queryParams: {
@@ -2070,21 +1928,7 @@ function buildNetworkSnapshot$5(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$5(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
@@ -2547,26 +2391,8 @@ const ingest$5 = function LearningItemRepresentationIngest(input, path, luvio, s
         }
     }
     const key = keyBuilderFromType$4(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$4;
-    let incomingRecord = normalize$5(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: "LearningContentPlatform",
-            version: VERSION$8,
-            representationName: RepresentationType$5,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$5, "LearningContentPlatform", VERSION$8, RepresentationType$5, equals$8);
     return createLink(key);
 };
 function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
@@ -2616,7 +2442,7 @@ function normalize$4(input, existing, path, luvio, store, timestamp) {
                 existing: existing,
             },
             ttl: path.ttl
-        }, luvio, store);
+        }, luvio, store, timestamp);
     }
     return input;
 }
@@ -2656,26 +2482,8 @@ const ingest$4 = function LearningItemListRepresentationIngest(input, path, luvi
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$4(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$7(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "LearningContentPlatform",
-            version: VERSION$7,
-            representationName: RepresentationType$4,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "LearningContentPlatform", VERSION$7, RepresentationType$4, equals$7);
     return createLink(key);
 };
 function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
@@ -2738,13 +2546,11 @@ function createResourceRequest$4(config) {
     };
 }
 
-const getLearningItemsList_ConfigPropertyNames = {
-    displayName: 'getLearningItemsList',
-    parameters: {
-        required: [],
-        optional: ['learningItemIds']
-    }
-};
+const adapterName$4 = 'getLearningItemsList';
+const getLearningItemsList_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('learningItemIds', false),
+];
+const getLearningItemsList_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getLearningItemsList_ConfigPropertyMetadata);
 function createResourceParams$4(config) {
     const resourceParams = {
         queryParams: {
@@ -2810,21 +2616,7 @@ function buildNetworkSnapshot$4(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$4(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
@@ -3638,26 +3430,8 @@ const ingest$3 = function LearningModelOutputRepresentationIngest(input, path, l
         }
     }
     const key = keyBuilderFromType$3(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$5(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "LearningContentPlatform",
-            version: VERSION$5,
-            representationName: RepresentationType$3,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "LearningContentPlatform", VERSION$5, RepresentationType$3, equals$5);
     return createLink(key);
 };
 function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
@@ -3724,13 +3498,11 @@ function createResourceRequest$3(config) {
     };
 }
 
-const getLearningModel_ConfigPropertyNames = {
-    displayName: 'getLearningModel',
-    parameters: {
-        required: ['learningItemId'],
-        optional: []
-    }
-};
+const adapterName$3 = 'getLearningModel';
+const getLearningModel_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('learningItemId', true),
+];
+const getLearningModel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getLearningModel_ConfigPropertyMetadata);
 function createResourceParams$3(config) {
     const resourceParams = {
         urlParams: {
@@ -3796,21 +3568,7 @@ function buildNetworkSnapshot$3(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$3(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
@@ -3948,26 +3706,8 @@ const ingest$2 = function LearningPracticeRepresentationIngest(input, path, luvi
         }
     }
     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$4(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "LearningContentPlatform",
-            version: VERSION$4,
-            representationName: RepresentationType$2,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "LearningContentPlatform", VERSION$4, RepresentationType$2, equals$4);
     return createLink(key);
 };
 function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
@@ -4041,13 +3781,11 @@ function createResourceRequestFromRepresentation$2(representation) {
     return createResourceRequest$2(config);
 }
 
-const getLearningPractice_ConfigPropertyNames = {
-    displayName: 'getLearningPractice',
-    parameters: {
-        required: ['learningItemId'],
-        optional: []
-    }
-};
+const adapterName$2 = 'getLearningPractice';
+const getLearningPractice_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('learningItemId', true),
+];
+const getLearningPractice_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getLearningPractice_ConfigPropertyMetadata);
 function createResourceParams$2(config) {
     const resourceParams = {
         urlParams: {
@@ -4113,21 +3851,7 @@ function buildNetworkSnapshot$2(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$2(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
@@ -4724,26 +4448,8 @@ const ingest$1 = function TrailheadModuleRepresentationIngest(input, path, luvio
         }
     }
     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: "LearningContentPlatform",
-            version: VERSION$2,
-            representationName: RepresentationType$1,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "LearningContentPlatform", VERSION$2, RepresentationType$1, equals$2);
     return createLink(key);
 };
 function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
@@ -4817,13 +4523,11 @@ function createResourceRequestFromRepresentation$1(representation) {
     return createResourceRequest$1(config);
 }
 
-const getModule_ConfigPropertyNames = {
-    displayName: 'getModule',
-    parameters: {
-        required: ['moduleId'],
-        optional: []
-    }
-};
+const adapterName$1 = 'getModule';
+const getModule_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('moduleId', true),
+];
+const getModule_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getModule_ConfigPropertyMetadata);
 function createResourceParams$1(config) {
     const resourceParams = {
         urlParams: {
@@ -4889,21 +4593,7 @@ function buildNetworkSnapshot$1(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$1(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$1, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { luvio, config } = context;
@@ -5170,26 +4860,8 @@ const ingest = function LearningTextLessonRepresentationIngest(input, path, luvi
         }
     }
     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: "LearningContentPlatform",
-            version: VERSION,
-            representationName: RepresentationType,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "LearningContentPlatform", VERSION, RepresentationType, equals);
     return createLink(key);
 };
 function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
@@ -5263,13 +4935,11 @@ function createResourceRequestFromRepresentation(representation) {
     return createResourceRequest(config);
 }
 
-const getTextLesson_ConfigPropertyNames = {
-    displayName: 'getTextLesson',
-    parameters: {
-        required: ['learningItemId'],
-        optional: []
-    }
-};
+const adapterName = 'getTextLesson';
+const getTextLesson_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('learningItemId', true),
+];
+const getTextLesson_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getTextLesson_ConfigPropertyMetadata);
 function createResourceParams(config) {
     const resourceParams = {
         urlParams: {
@@ -5335,21 +5005,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$9(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
@@ -5509,4 +5165,4 @@ withDefaultLuvio((luvio) => {
 });
 
 export { evaluateLearningItem, getFeaturedItemsRecommendedList, getFeaturedItemsRecommendedList_imperative, getFeaturedItemsRelatedList, getFeaturedItemsRelatedList_imperative, getLearningConfig, getLearningConfig_imperative, getLearningItemProgress, getLearningItemProgress_imperative, getLearningItemsList, getLearningItemsList_imperative, getLearningModel, getLearningModel_imperative, getLearningPractice, getLearningPracticeNotifyChange, getLearningPractice_imperative, getModule, getModuleNotifyChange, getModule_imperative, getTextLesson, getTextLessonNotifyChange, getTextLesson_imperative };
-// version: 1.212.1-49679d2a7
+// version: 1.213.1-79de10fe1