@salesforce/lds-adapters-platform-learning-content 1.149.0 → 1.150.0

package/sfdc/index.js

@@ -101,7 +101,7 @@ function createLink(ref) {
     };
 }
 
-function validate$i(obj, path = 'EvaluateLearningItemInputRepresentation') {
+function validate$f(obj, path = 'EvaluateLearningItemInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -131,9 +131,9 @@ function validate$i(obj, path = 'EvaluateLearningItemInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$8 = 15000;
-const VERSION$h = "ef3b97b73983e10731031f11a195bba6";
-function validate$h(obj, path = 'LearningItemProgressRepresentation') {
+const TTL$6 = 15000;
+const VERSION$e = "ef3b97b73983e10731031f11a195bba6";
+function validate$e(obj, path = 'LearningItemProgressRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -203,23 +203,23 @@ function validate$h(obj, path = 'LearningItemProgressRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$e = 'LearningItemProgressRepresentation';
-function keyBuilder$u(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$e + ':' + config.learning_item_id;
+const RepresentationType$b = 'LearningItemProgressRepresentation';
+function keyBuilder$o(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$b + ':' + config.learning_item_id;
 }
-function keyBuilderFromType$8(luvio, object) {
+function keyBuilderFromType$6(luvio, object) {
     const keyParams = {
         learning_item_id: object.learningItemId
     };
-    return keyBuilder$u(luvio, keyParams);
+    return keyBuilder$o(luvio, keyParams);
 }
-function normalize$e(input, existing, path, luvio, store, timestamp) {
+function normalize$b(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$t = function LearningItemProgressRepresentationSelect() {
+const select$o = function LearningItemProgressRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$h,
+        version: VERSION$e,
         private: [],
         selections: [
             {
@@ -241,7 +241,7 @@ const select$t = function LearningItemProgressRepresentationSelect() {
         ]
     };
 };
-function equals$h(existing, incoming) {
+function equals$e(existing, incoming) {
     const existing_isCompleted = existing.isCompleted;
     const incoming_isCompleted = incoming.isCompleted;
     if (!(existing_isCompleted === incoming_isCompleted)) {
@@ -264,61 +264,61 @@ function equals$h(existing, incoming) {
     }
     return true;
 }
-const ingest$e = function LearningItemProgressRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$b = function LearningItemProgressRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$h(input);
+        const validateError = validate$e(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$8(luvio, input);
+    const key = keyBuilderFromType$6(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$8;
-    let incomingRecord = normalize$e(input, 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$h(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$e(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "LearningContentPlatform",
-            version: VERSION$h,
-            representationName: RepresentationType$e,
+            version: VERSION$e,
+            representationName: RepresentationType$b,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$e(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$b(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$8(luvio, input);
+    const rootKey = keyBuilderFromType$6(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$e,
+        representationName: RepresentationType$b,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$s(luvio, params) {
-    return select$t();
+function select$n(luvio, params) {
+    return select$o();
 }
-function getResponseCacheKeys$b(luvio, resourceParams, response) {
-    return getTypeCacheKeys$e(luvio, response);
+function getResponseCacheKeys$9(luvio, resourceParams, response) {
+    return getTypeCacheKeys$b(luvio, response);
 }
-function ingestSuccess$b(luvio, resourceParams, response) {
+function ingestSuccess$9(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$8(luvio, body);
-    luvio.storeIngest(key, ingest$e, body);
+    const key = keyBuilderFromType$6(luvio, body);
+    luvio.storeIngest(key, ingest$b, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$s(),
+        node: select$n(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -329,7 +329,7 @@ function ingestSuccess$b(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$b(config) {
+function createResourceRequest$9(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -350,7 +350,7 @@ const evaluateLearningItem_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$b(config) {
+function createResourceParams$9(config) {
     const resourceParams = {
         body: {
             payload: config.payload
@@ -358,37 +358,37 @@ function createResourceParams$b(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$b(untrustedConfig) {
+function typeCheckConfig$9(untrustedConfig) {
     const config = {};
     const untrustedConfig_payload = untrustedConfig.payload;
-    const referenceEvaluateLearningItemInputRepresentationValidationError = validate$i(untrustedConfig_payload);
+    const referenceEvaluateLearningItemInputRepresentationValidationError = validate$f(untrustedConfig_payload);
     if (referenceEvaluateLearningItemInputRepresentationValidationError === null) {
         config.payload = untrustedConfig_payload;
     }
     return config;
 }
-function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$b(untrustedConfig);
+    const config = typeCheckConfig$9(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$b(luvio, config, options) {
-    const resourceParams = createResourceParams$b(config);
-    const request = createResourceRequest$b(resourceParams);
+function buildNetworkSnapshot$9(luvio, config, options) {
+    const resourceParams = createResourceParams$9(config);
+    const request = createResourceRequest$9(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$b(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$9(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
-        }, () => getResponseCacheKeys$b(luvio, resourceParams, response.body));
+        }, () => getResponseCacheKeys$9(luvio, resourceParams, response.body));
     }, (response) => {
         deepFreeze(response);
         throw response;
@@ -396,18 +396,18 @@ function buildNetworkSnapshot$b(luvio, config, options) {
 }
 const evaluateLearningItemAdapterFactory = (luvio) => {
     return function evaluateLearningItem(untrustedConfig) {
-        const config = validateAdapterConfig$b(untrustedConfig, evaluateLearningItem_ConfigPropertyNames);
+        const config = validateAdapterConfig$9(untrustedConfig, evaluateLearningItem_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "evaluateLearningItem"');
         }
-        return buildNetworkSnapshot$b(luvio, config);
+        return buildNetworkSnapshot$9(luvio, config);
     };
 };
 
-const TTL$7 = 15000;
-const VERSION$g = "b489f9f2cbdc91a04dd15b4d467b6760";
-function validate$g(obj, path = 'FeaturedItemRepresentation') {
+const TTL$5 = 15000;
+const VERSION$d = "b489f9f2cbdc91a04dd15b4d467b6760";
+function validate$d(obj, path = 'FeaturedItemRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -804,23 +804,23 @@ function validate$g(obj, path = 'FeaturedItemRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$d = 'FeaturedItemRepresentation';
-function keyBuilder$t(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$d + ':' + config.id;
+const RepresentationType$a = 'FeaturedItemRepresentation';
+function keyBuilder$n(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$a + ':' + config.id;
 }
-function keyBuilderFromType$7(luvio, object) {
+function keyBuilderFromType$5(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$t(luvio, keyParams);
+    return keyBuilder$n(luvio, keyParams);
 }
-function normalize$d(input, existing, path, luvio, store, timestamp) {
+function normalize$a(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$r = function FeaturedItemRepresentationSelect() {
+const select$m = function FeaturedItemRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$g,
+        version: VERSION$d,
         private: [],
         selections: [
             {
@@ -902,7 +902,7 @@ const select$r = function FeaturedItemRepresentationSelect() {
         ]
     };
 };
-function equals$g(existing, incoming) {
+function equals$d(existing, incoming) {
     const existing_description = existing.description;
     const incoming_description = incoming.description;
     if (!(existing_description === incoming_description)) {
@@ -1000,50 +1000,50 @@ function equals$g(existing, incoming) {
     }
     return true;
 }
-const ingest$d = function FeaturedItemRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$a = function FeaturedItemRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$g(input);
+        const validateError = validate$d(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$7(luvio, input);
+    const key = keyBuilderFromType$5(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$7;
-    let incomingRecord = normalize$d(input, 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$g(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$d(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "LearningContentPlatform",
-            version: VERSION$g,
-            representationName: RepresentationType$d,
+            version: VERSION$d,
+            representationName: RepresentationType$a,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$d(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$a(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$7(luvio, input);
+    const rootKey = keyBuilderFromType$5(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$d,
+        representationName: RepresentationType$a,
         mergeable: false
     });
     return rootKeySet;
 }
 
-const VERSION$f = "94c7194d9578589364c6efd021226634";
-function validate$f(obj, path = 'FeaturedItemRecommendedListRepresentation') {
+const VERSION$c = "94c7194d9578589364c6efd021226634";
+function validate$c(obj, path = 'FeaturedItemRecommendedListRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1063,14 +1063,14 @@ function validate$f(obj, path = 'FeaturedItemRecommendedListRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$c = 'FeaturedItemRecommendedListRepresentation';
-function normalize$c(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$9 = 'FeaturedItemRecommendedListRepresentation';
+function normalize$9(input, existing, path, luvio, store, timestamp) {
     const input_recommendedList = input.recommendedList;
     const input_recommendedList_id = path.fullPath + '__recommendedList';
     for (let i = 0; i < input_recommendedList.length; i++) {
         const input_recommendedList_item = input_recommendedList[i];
         let input_recommendedList_item_id = input_recommendedList_id + '__' + i;
-        input_recommendedList[i] = ingest$d(input_recommendedList_item, {
+        input_recommendedList[i] = ingest$a(input_recommendedList_item, {
             fullPath: input_recommendedList_item_id,
             propertyName: i,
             parent: {
@@ -1083,22 +1083,22 @@ function normalize$c(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$q = function FeaturedItemRecommendedListRepresentationSelect() {
+const select$l = function FeaturedItemRecommendedListRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$f,
+        version: VERSION$c,
         private: [],
         selections: [
             {
                 name: 'recommendedList',
                 kind: 'Link',
                 plural: true,
-                fragment: select$r()
+                fragment: select$m()
             }
         ]
     };
 };
-function equals$f(existing, incoming) {
+function equals$c(existing, incoming) {
     const existing_recommendedList = existing.recommendedList;
     const incoming_recommendedList = incoming.recommendedList;
     const equals_recommendedList_items = equalsArray(existing_recommendedList, incoming_recommendedList, (existing_recommendedList_item, incoming_recommendedList_item) => {
@@ -1111,9 +1111,9 @@ function equals$f(existing, incoming) {
     }
     return true;
 }
-const ingest$c = function FeaturedItemRecommendedListRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$9 = function FeaturedItemRecommendedListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$f(input);
+        const validateError = validate$c(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -1121,58 +1121,58 @@ const ingest$c = function FeaturedItemRecommendedListRepresentationIngest(input,
     const key = path.fullPath;
     const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$c(input, store.readEntry(key), {
+    let incomingRecord = normalize$9(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     }, luvio, store);
-    if (existingRecord === undefined || equals$f(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$c(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     if (ttlToUse !== undefined) {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "LearningContentPlatform",
-            version: VERSION$f,
-            representationName: RepresentationType$c,
+            version: VERSION$c,
+            representationName: RepresentationType$9,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$c(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$9(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$c,
+        representationName: RepresentationType$9,
         mergeable: false
     });
     const input_recommendedList_length = input.recommendedList.length;
     for (let i = 0; i < input_recommendedList_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$d(luvio, input.recommendedList[i]));
+        rootKeySet.merge(getTypeCacheKeys$a(luvio, input.recommendedList[i]));
     }
     return rootKeySet;
 }
 
-function select$p(luvio, params) {
-    return select$q();
+function select$k(luvio, params) {
+    return select$l();
 }
-function keyBuilder$s(luvio, params) {
+function keyBuilder$m(luvio, params) {
     return keyPrefix + '::FeaturedItemRecommendedListRepresentation:(' + 'appId:' + params.queryParams.appId + ',' + 'context:' + params.queryParams.context + ')';
 }
-function getResponseCacheKeys$a(luvio, resourceParams, response) {
-    return getTypeCacheKeys$c(luvio, response, () => keyBuilder$s(luvio, resourceParams));
+function getResponseCacheKeys$8(luvio, resourceParams, response) {
+    return getTypeCacheKeys$9(luvio, response, () => keyBuilder$m(luvio, resourceParams));
 }
-function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$s(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$c, body);
+    const key = keyBuilder$m(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$p(),
+        node: select$k(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1183,13 +1183,13 @@ function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$a(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$s(luvio, params);
+function ingestError$8(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$m(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$a(config) {
+function createResourceRequest$8(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -1210,7 +1210,7 @@ const getFeaturedItemsRecommendedList_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$a(config) {
+function createResourceParams$8(config) {
     const resourceParams = {
         queryParams: {
             appId: config.appId, context: config.context
@@ -1218,11 +1218,11 @@ function createResourceParams$a(config) {
     };
     return resourceParams;
 }
-function keyBuilder$r(luvio, config) {
-    const resourceParams = createResourceParams$a(config);
-    return keyBuilder$s(luvio, resourceParams);
+function keyBuilder$l(luvio, config) {
+    const resourceParams = createResourceParams$8(config);
+    return keyBuilder$m(luvio, resourceParams);
 }
-function typeCheckConfig$a(untrustedConfig) {
+function typeCheckConfig$8(untrustedConfig) {
     const config = {};
     const untrustedConfig_appId = untrustedConfig.appId;
     if (typeof untrustedConfig_appId === 'string') {
@@ -1234,48 +1234,48 @@ function typeCheckConfig$a(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$a(untrustedConfig);
+    const config = typeCheckConfig$8(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$a(luvio, config) {
-    createResourceParams$a(config);
-    return select$p();
+function adapterFragment$8(luvio, config) {
+    createResourceParams$8(config);
+    return select$k();
 }
-function onFetchResponseSuccess$a(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
+function onFetchResponseSuccess$8(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$a(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$a(luvio, resourceParams, response, {
+function onFetchResponseError$8(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$a(luvio, config, options) {
-    const resourceParams = createResourceParams$a(config);
-    const request = createResourceRequest$a(resourceParams);
+function buildNetworkSnapshot$8(luvio, config, options) {
+    const resourceParams = createResourceParams$8(config);
+    const request = createResourceRequest$8(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$a(luvio, config, resourceParams, response), () => getResponseCacheKeys$a(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$8(luvio, config, resourceParams, response), () => getResponseCacheKeys$8(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$a(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$8(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -1290,33 +1290,33 @@ function buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$a(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$8(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$r(luvio, config),
-        node: adapterFragment$a(luvio, config),
+        recordId: keyBuilder$l(luvio, config),
+        node: adapterFragment$8(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getFeaturedItemsRecommendedListAdapterFactory = (luvio) => function LearningContentPlatform__getFeaturedItemsRecommendedList(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$a(untrustedConfig, getFeaturedItemsRecommendedList_ConfigPropertyNames);
+    const config = validateAdapterConfig$8(untrustedConfig, getFeaturedItemsRecommendedList_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$a, buildNetworkSnapshotCachePolicy$a);
+    buildCachedSnapshotCachePolicy$8, buildNetworkSnapshotCachePolicy$8);
 };
 
-const VERSION$e = "5d7adb55f43466f61c4837ebf27eab61";
-function validate$e(obj, path = 'FeaturedItemRelatedListRepresentation') {
+const VERSION$b = "5d7adb55f43466f61c4837ebf27eab61";
+function validate$b(obj, path = 'FeaturedItemRelatedListRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1336,14 +1336,14 @@ function validate$e(obj, path = 'FeaturedItemRelatedListRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$b = 'FeaturedItemRelatedListRepresentation';
-function normalize$b(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$8 = 'FeaturedItemRelatedListRepresentation';
+function normalize$8(input, existing, path, luvio, store, timestamp) {
     const input_relatedList = input.relatedList;
     const input_relatedList_id = path.fullPath + '__relatedList';
     for (let i = 0; i < input_relatedList.length; i++) {
         const input_relatedList_item = input_relatedList[i];
         let input_relatedList_item_id = input_relatedList_id + '__' + i;
-        input_relatedList[i] = ingest$d(input_relatedList_item, {
+        input_relatedList[i] = ingest$a(input_relatedList_item, {
             fullPath: input_relatedList_item_id,
             propertyName: i,
             parent: {
@@ -1356,22 +1356,22 @@ function normalize$b(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$o = function FeaturedItemRelatedListRepresentationSelect() {
+const select$j = function FeaturedItemRelatedListRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$e,
+        version: VERSION$b,
         private: [],
         selections: [
             {
                 name: 'relatedList',
                 kind: 'Link',
                 plural: true,
-                fragment: select$r()
+                fragment: select$m()
             }
         ]
     };
 };
-function equals$e(existing, incoming) {
+function equals$b(existing, incoming) {
     const existing_relatedList = existing.relatedList;
     const incoming_relatedList = incoming.relatedList;
     const equals_relatedList_items = equalsArray(existing_relatedList, incoming_relatedList, (existing_relatedList_item, incoming_relatedList_item) => {
@@ -1384,9 +1384,9 @@ function equals$e(existing, incoming) {
     }
     return true;
 }
-const ingest$b = function FeaturedItemRelatedListRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$8 = function FeaturedItemRelatedListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$e(input);
+        const validateError = validate$b(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -1394,58 +1394,58 @@ const ingest$b = function FeaturedItemRelatedListRepresentationIngest(input, pat
     const key = path.fullPath;
     const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$b(input, store.readEntry(key), {
+    let incomingRecord = normalize$8(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     }, luvio, store);
-    if (existingRecord === undefined || equals$e(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$b(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     if (ttlToUse !== undefined) {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "LearningContentPlatform",
-            version: VERSION$e,
-            representationName: RepresentationType$b,
+            version: VERSION$b,
+            representationName: RepresentationType$8,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$b(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$8(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$b,
+        representationName: RepresentationType$8,
         mergeable: false
     });
     const input_relatedList_length = input.relatedList.length;
     for (let i = 0; i < input_relatedList_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$d(luvio, input.relatedList[i]));
+        rootKeySet.merge(getTypeCacheKeys$a(luvio, input.relatedList[i]));
     }
     return rootKeySet;
 }
 
-function select$n(luvio, params) {
-    return select$o();
+function select$i(luvio, params) {
+    return select$j();
 }
-function keyBuilder$q(luvio, params) {
+function keyBuilder$k(luvio, params) {
     return keyPrefix + '::FeaturedItemRelatedListRepresentation:(' + 'appId:' + params.queryParams.appId + ',' + 'pageRef:' + params.queryParams.pageRef + ')';
 }
-function getResponseCacheKeys$9(luvio, resourceParams, response) {
-    return getTypeCacheKeys$b(luvio, response, () => keyBuilder$q(luvio, resourceParams));
+function getResponseCacheKeys$7(luvio, resourceParams, response) {
+    return getTypeCacheKeys$8(luvio, response, () => keyBuilder$k(luvio, resourceParams));
 }
-function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$q(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$b, body);
+    const key = keyBuilder$k(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$n(),
+        node: select$i(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1456,13 +1456,13 @@ function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$9(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$q(luvio, params);
+function ingestError$7(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$k(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$9(config) {
+function createResourceRequest$7(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -1483,7 +1483,7 @@ const getFeaturedItemsRelatedList_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$9(config) {
+function createResourceParams$7(config) {
     const resourceParams = {
         queryParams: {
             appId: config.appId, pageRef: config.pageRef
@@ -1491,11 +1491,11 @@ function createResourceParams$9(config) {
     };
     return resourceParams;
 }
-function keyBuilder$p(luvio, config) {
-    const resourceParams = createResourceParams$9(config);
-    return keyBuilder$q(luvio, resourceParams);
+function keyBuilder$j(luvio, config) {
+    const resourceParams = createResourceParams$7(config);
+    return keyBuilder$k(luvio, resourceParams);
 }
-function typeCheckConfig$9(untrustedConfig) {
+function typeCheckConfig$7(untrustedConfig) {
     const config = {};
     const untrustedConfig_appId = untrustedConfig.appId;
     if (typeof untrustedConfig_appId === 'string') {
@@ -1507,48 +1507,48 @@ function typeCheckConfig$9(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$9(untrustedConfig);
+    const config = typeCheckConfig$7(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$9(luvio, config) {
-    createResourceParams$9(config);
-    return select$n();
+function adapterFragment$7(luvio, config) {
+    createResourceParams$7(config);
+    return select$i();
 }
-function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
+function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$9(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$9(luvio, resourceParams, response, {
+function onFetchResponseError$7(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$9(luvio, config, options) {
-    const resourceParams = createResourceParams$9(config);
-    const request = createResourceRequest$9(resourceParams);
+function buildNetworkSnapshot$7(luvio, config, options) {
+    const resourceParams = createResourceParams$7(config);
+    const request = createResourceRequest$7(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$9(luvio, config, resourceParams, response), () => getResponseCacheKeys$9(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$7(luvio, config, resourceParams, response), () => getResponseCacheKeys$7(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$9(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$7(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -1563,33 +1563,33 @@ function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$9(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$7(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$p(luvio, config),
-        node: adapterFragment$9(luvio, config),
+        recordId: keyBuilder$j(luvio, config),
+        node: adapterFragment$7(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getFeaturedItemsRelatedListAdapterFactory = (luvio) => function LearningContentPlatform__getFeaturedItemsRelatedList(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$9(untrustedConfig, getFeaturedItemsRelatedList_ConfigPropertyNames);
+    const config = validateAdapterConfig$7(untrustedConfig, getFeaturedItemsRelatedList_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$9, buildNetworkSnapshotCachePolicy$9);
+    buildCachedSnapshotCachePolicy$7, buildNetworkSnapshotCachePolicy$7);
 };
 
-const VERSION$d = "8471031fcff953c83f350a0f66b60ddb";
-function validate$d(obj, path = 'LearningConfigRepresentation') {
+const VERSION$a = "8471031fcff953c83f350a0f66b60ddb";
+function validate$a(obj, path = 'LearningConfigRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1612,14 +1612,14 @@ function validate$d(obj, path = 'LearningConfigRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$a = 'LearningConfigRepresentation';
-function normalize$a(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$7 = 'LearningConfigRepresentation';
+function normalize$7(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$m = function LearningConfigRepresentationSelect() {
+const select$h = function LearningConfigRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$d,
+        version: VERSION$a,
         private: [],
         selections: [
             {
@@ -1637,7 +1637,7 @@ const select$m = function LearningConfigRepresentationSelect() {
         ]
     };
 };
-function equals$d(existing, incoming) {
+function equals$a(existing, incoming) {
     const existing_hasElevatedLearningAccess = existing.hasElevatedLearningAccess;
     const incoming_hasElevatedLearningAccess = incoming.hasElevatedLearningAccess;
     if (!(existing_hasElevatedLearningAccess === incoming_hasElevatedLearningAccess)) {
@@ -1655,9 +1655,9 @@ function equals$d(existing, incoming) {
     }
     return true;
 }
-const ingest$a = function LearningConfigRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$7 = function LearningConfigRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$d(input);
+        const validateError = validate$a(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -1665,54 +1665,54 @@ const ingest$a = 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$a(input, store.readEntry(key), {
+    let incomingRecord = normalize$7(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     });
-    if (existingRecord === undefined || equals$d(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$a(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     if (ttlToUse !== undefined) {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "LearningContentPlatform",
-            version: VERSION$d,
-            representationName: RepresentationType$a,
+            version: VERSION$a,
+            representationName: RepresentationType$7,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$a(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$7(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$a,
+        representationName: RepresentationType$7,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$l(luvio, params) {
-    return select$m();
+function select$g(luvio, params) {
+    return select$h();
 }
-function keyBuilder$o(luvio, params) {
+function keyBuilder$i(luvio, params) {
     return keyPrefix + '::LearningConfigRepresentation:(' + ')';
 }
-function getResponseCacheKeys$8(luvio, resourceParams, response) {
-    return getTypeCacheKeys$a(luvio, response, () => keyBuilder$o());
+function getResponseCacheKeys$6(luvio, resourceParams, response) {
+    return getTypeCacheKeys$7(luvio, response, () => keyBuilder$i());
 }
-function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$o();
-    luvio.storeIngest(key, ingest$a, body);
+    const key = keyBuilder$i();
+    luvio.storeIngest(key, ingest$7, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$l(),
+        node: select$g(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1723,13 +1723,13 @@ function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$8(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$o();
+function ingestError$6(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$i();
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$8(config) {
+function createResourceRequest$6(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -1750,58 +1750,58 @@ const getLearningConfig_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$8(config) {
+function createResourceParams$6(config) {
     const resourceParams = {};
     return resourceParams;
 }
-function keyBuilder$n(luvio, config) {
-    return keyBuilder$o();
+function keyBuilder$h(luvio, config) {
+    return keyBuilder$i();
 }
-function typeCheckConfig$8(untrustedConfig) {
+function typeCheckConfig$6(untrustedConfig) {
     const config = {};
     return config;
 }
-function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$8();
+    const config = typeCheckConfig$6();
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$8(luvio, config) {
-    return select$l();
+function adapterFragment$6(luvio, config) {
+    return select$g();
 }
-function onFetchResponseSuccess$8(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
+function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$8(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$8(luvio, resourceParams, response, {
+function onFetchResponseError$6(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$8(luvio, config, options) {
-    const resourceParams = createResourceParams$8();
-    const request = createResourceRequest$8();
+function buildNetworkSnapshot$6(luvio, config, options) {
+    const resourceParams = createResourceParams$6();
+    const request = createResourceRequest$6();
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$8(luvio, config, resourceParams, response), () => getResponseCacheKeys$8(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => getResponseCacheKeys$6(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$8(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$6(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -1816,33 +1816,33 @@ function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$8(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$6(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$n(),
-        node: adapterFragment$8(),
+        recordId: keyBuilder$h(),
+        node: adapterFragment$6(),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getLearningConfigAdapterFactory = (luvio) => function LearningContentPlatform__getLearningConfig(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$8(untrustedConfig, getLearningConfig_ConfigPropertyNames);
+    const config = validateAdapterConfig$6(untrustedConfig, getLearningConfig_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$8, buildNetworkSnapshotCachePolicy$8);
+    buildCachedSnapshotCachePolicy$6, buildNetworkSnapshotCachePolicy$6);
 };
 
-const VERSION$c = "1292f1a549c777c6586cca649e823737";
-function validate$c(obj, path = 'LearningItemProgressListRepresentation') {
+const VERSION$9 = "1292f1a549c777c6586cca649e823737";
+function validate$9(obj, path = 'LearningItemProgressListRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1862,14 +1862,14 @@ function validate$c(obj, path = 'LearningItemProgressListRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$9 = 'LearningItemProgressListRepresentation';
-function normalize$9(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$6 = 'LearningItemProgressListRepresentation';
+function normalize$6(input, existing, path, luvio, store, timestamp) {
     const input_list = input.list;
     const input_list_id = path.fullPath + '__list';
     for (let i = 0; i < input_list.length; i++) {
         const input_list_item = input_list[i];
         let input_list_item_id = input_list_id + '__' + i;
-        input_list[i] = ingest$e(input_list_item, {
+        input_list[i] = ingest$b(input_list_item, {
             fullPath: input_list_item_id,
             propertyName: i,
             parent: {
@@ -1882,22 +1882,22 @@ function normalize$9(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$k = function LearningItemProgressListRepresentationSelect() {
+const select$f = function LearningItemProgressListRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$c,
+        version: VERSION$9,
         private: [],
         selections: [
             {
                 name: 'list',
                 kind: 'Link',
                 plural: true,
-                fragment: select$t()
+                fragment: select$o()
             }
         ]
     };
 };
-function equals$c(existing, incoming) {
+function equals$9(existing, incoming) {
     const existing_list = existing.list;
     const incoming_list = incoming.list;
     const equals_list_items = equalsArray(existing_list, incoming_list, (existing_list_item, incoming_list_item) => {
@@ -1910,9 +1910,9 @@ function equals$c(existing, incoming) {
     }
     return true;
 }
-const ingest$9 = function LearningItemProgressListRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$6 = function LearningItemProgressListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$c(input);
+        const validateError = validate$9(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -1920,58 +1920,58 @@ const ingest$9 = function LearningItemProgressListRepresentationIngest(input, pa
     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), {
+    let incomingRecord = normalize$6(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     }, luvio, store);
-    if (existingRecord === undefined || equals$c(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$9(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     if (ttlToUse !== undefined) {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "LearningContentPlatform",
-            version: VERSION$c,
-            representationName: RepresentationType$9,
+            version: VERSION$9,
+            representationName: RepresentationType$6,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$9(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$6(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$9,
+        representationName: RepresentationType$6,
         mergeable: false
     });
     const input_list_length = input.list.length;
     for (let i = 0; i < input_list_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$e(luvio, input.list[i]));
+        rootKeySet.merge(getTypeCacheKeys$b(luvio, input.list[i]));
     }
     return rootKeySet;
 }
 
-function select$j(luvio, params) {
-    return select$k();
+function select$e(luvio, params) {
+    return select$f();
 }
-function keyBuilder$m(luvio, params) {
+function keyBuilder$g(luvio, params) {
     return keyPrefix + '::LearningItemProgressListRepresentation:(' + 'learningItemIds:' + params.queryParams.learningItemIds + ')';
 }
-function getResponseCacheKeys$7(luvio, resourceParams, response) {
-    return getTypeCacheKeys$9(luvio, response, () => keyBuilder$m(luvio, resourceParams));
+function getResponseCacheKeys$5(luvio, resourceParams, response) {
+    return getTypeCacheKeys$6(luvio, response, () => keyBuilder$g(luvio, resourceParams));
 }
-function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$m(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$9, body);
+    const key = keyBuilder$g(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$6, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$j(),
+        node: select$e(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1982,13 +1982,13 @@ function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$7(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$m(luvio, params);
+function ingestError$5(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$g(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$7(config) {
+function createResourceRequest$5(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -2009,7 +2009,7 @@ const getLearningItemProgress_ConfigPropertyNames = {
         optional: ['learningItemIds']
     }
 };
-function createResourceParams$7(config) {
+function createResourceParams$5(config) {
     const resourceParams = {
         queryParams: {
             learningItemIds: config.learningItemIds
@@ -2017,11 +2017,11 @@ function createResourceParams$7(config) {
     };
     return resourceParams;
 }
-function keyBuilder$l(luvio, config) {
-    const resourceParams = createResourceParams$7(config);
-    return keyBuilder$m(luvio, resourceParams);
+function keyBuilder$f(luvio, config) {
+    const resourceParams = createResourceParams$5(config);
+    return keyBuilder$g(luvio, resourceParams);
 }
-function typeCheckConfig$7(untrustedConfig) {
+function typeCheckConfig$5(untrustedConfig) {
     const config = {};
     const untrustedConfig_learningItemIds = untrustedConfig.learningItemIds;
     if (ArrayIsArray$1(untrustedConfig_learningItemIds)) {
@@ -2036,48 +2036,48 @@ function typeCheckConfig$7(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$7(untrustedConfig);
+    const config = typeCheckConfig$5(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$7(luvio, config) {
-    createResourceParams$7(config);
-    return select$j();
+function adapterFragment$5(luvio, config) {
+    createResourceParams$5(config);
+    return select$e();
 }
-function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
+function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$7(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$7(luvio, resourceParams, response, {
+function onFetchResponseError$5(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$7(luvio, config, options) {
-    const resourceParams = createResourceParams$7(config);
-    const request = createResourceRequest$7(resourceParams);
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$7(luvio, config, resourceParams, response), () => getResponseCacheKeys$7(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => getResponseCacheKeys$5(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$7(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$5(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -2092,34 +2092,34 @@ function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$7(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$5(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$l(luvio, config),
-        node: adapterFragment$7(luvio, config),
+        recordId: keyBuilder$f(luvio, config),
+        node: adapterFragment$5(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getLearningItemProgressAdapterFactory = (luvio) => function LearningContentPlatform__getLearningItemProgress(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$7(untrustedConfig, getLearningItemProgress_ConfigPropertyNames);
+    const config = validateAdapterConfig$5(untrustedConfig, getLearningItemProgress_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$7, buildNetworkSnapshotCachePolicy$7);
+    buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
 };
 
-const TTL$6 = 60000;
-const VERSION$b = "1832481a3fe10deeb9c5dddba933f3da";
-function validate$b(obj, path = 'LearningItemRepresentation') {
+const TTL$4 = 60000;
+const VERSION$8 = "1832481a3fe10deeb9c5dddba933f3da";
+function validate$8(obj, path = 'LearningItemRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2414,23 +2414,23 @@ function validate$b(obj, path = 'LearningItemRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$8 = 'LearningItemRepresentation';
-function keyBuilder$k(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$8 + ':' + (config.learning_item_id === null ? '' : config.learning_item_id);
+const RepresentationType$5 = 'LearningItemRepresentation';
+function keyBuilder$e(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$5 + ':' + (config.learning_item_id === null ? '' : config.learning_item_id);
 }
-function keyBuilderFromType$6(luvio, object) {
+function keyBuilderFromType$4(luvio, object) {
     const keyParams = {
         learning_item_id: object.id
     };
-    return keyBuilder$k(luvio, keyParams);
+    return keyBuilder$e(luvio, keyParams);
 }
-function normalize$8(input, existing, path, luvio, store, timestamp) {
+function normalize$5(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$i = function LearningItemRepresentationSelect() {
+const select$d = function LearningItemRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$b,
+        version: VERSION$8,
         private: [],
         selections: [
             {
@@ -2484,7 +2484,7 @@ const select$i = function LearningItemRepresentationSelect() {
         ]
     };
 };
-function equals$b(existing, incoming) {
+function equals$8(existing, incoming) {
     const existing_completionRate = existing.completionRate;
     const incoming_completionRate = incoming.completionRate;
     if (!(existing_completionRate === incoming_completionRate)) {
@@ -2547,50 +2547,50 @@ function equals$b(existing, incoming) {
     }
     return true;
 }
-const ingest$8 = function LearningItemRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$5 = function LearningItemRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$b(input);
+        const validateError = validate$8(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$6(luvio, input);
+    const key = keyBuilderFromType$4(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$6;
-    let incomingRecord = normalize$8(input, 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$b(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$8(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "LearningContentPlatform",
-            version: VERSION$b,
-            representationName: RepresentationType$8,
+            version: VERSION$8,
+            representationName: RepresentationType$5,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$8(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$5(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$6(luvio, input);
+    const rootKey = keyBuilderFromType$4(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$8,
+        representationName: RepresentationType$5,
         mergeable: false
     });
     return rootKeySet;
 }
 
-const VERSION$a = "cd4c27f064c3139aef14a6ef22627c0f";
-function validate$a(obj, path = 'LearningItemListRepresentation') {
+const VERSION$7 = "cd4c27f064c3139aef14a6ef22627c0f";
+function validate$7(obj, path = 'LearningItemListRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2610,14 +2610,14 @@ function validate$a(obj, path = 'LearningItemListRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$7 = 'LearningItemListRepresentation';
-function normalize$7(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$4 = 'LearningItemListRepresentation';
+function normalize$4(input, existing, path, luvio, store, timestamp) {
     const input_list = input.list;
     const input_list_id = path.fullPath + '__list';
     for (let i = 0; i < input_list.length; i++) {
         const input_list_item = input_list[i];
         let input_list_item_id = input_list_id + '__' + i;
-        input_list[i] = ingest$8(input_list_item, {
+        input_list[i] = ingest$5(input_list_item, {
             fullPath: input_list_item_id,
             propertyName: i,
             parent: {
@@ -2630,22 +2630,22 @@ function normalize$7(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$h = function LearningItemListRepresentationSelect() {
+const select$c = function LearningItemListRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$a,
+        version: VERSION$7,
         private: [],
         selections: [
             {
                 name: 'list',
                 kind: 'Link',
                 plural: true,
-                fragment: select$i()
+                fragment: select$d()
             }
         ]
     };
 };
-function equals$a(existing, incoming) {
+function equals$7(existing, incoming) {
     const existing_list = existing.list;
     const incoming_list = incoming.list;
     const equals_list_items = equalsArray(existing_list, incoming_list, (existing_list_item, incoming_list_item) => {
@@ -2658,9 +2658,9 @@ function equals$a(existing, incoming) {
     }
     return true;
 }
-const ingest$7 = function LearningItemListRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$4 = function LearningItemListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$a(input);
+        const validateError = validate$7(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -2668,58 +2668,58 @@ const ingest$7 = 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$7(input, store.readEntry(key), {
+    let incomingRecord = normalize$4(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     }, luvio, store);
-    if (existingRecord === undefined || equals$a(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$7(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     if (ttlToUse !== undefined) {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "LearningContentPlatform",
-            version: VERSION$a,
-            representationName: RepresentationType$7,
+            version: VERSION$7,
+            representationName: RepresentationType$4,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$7(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$4(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$7,
+        representationName: RepresentationType$4,
         mergeable: false
     });
     const input_list_length = input.list.length;
     for (let i = 0; i < input_list_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$8(luvio, input.list[i]));
+        rootKeySet.merge(getTypeCacheKeys$5(luvio, input.list[i]));
     }
     return rootKeySet;
 }
 
-function select$g(luvio, params) {
-    return select$h();
+function select$b(luvio, params) {
+    return select$c();
 }
-function keyBuilder$j(luvio, params) {
+function keyBuilder$d(luvio, params) {
     return keyPrefix + '::LearningItemListRepresentation:(' + 'learningItemIds:' + params.queryParams.learningItemIds + ')';
 }
-function getResponseCacheKeys$6(luvio, resourceParams, response) {
-    return getTypeCacheKeys$7(luvio, response, () => keyBuilder$j(luvio, resourceParams));
+function getResponseCacheKeys$4(luvio, resourceParams, response) {
+    return getTypeCacheKeys$4(luvio, response, () => keyBuilder$d(luvio, resourceParams));
 }
-function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$j(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$7, body);
+    const key = keyBuilder$d(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$4, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$g(),
+        node: select$b(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2730,13 +2730,13 @@ function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$6(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$j(luvio, params);
+function ingestError$4(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$d(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$6(config) {
+function createResourceRequest$4(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -2757,7 +2757,7 @@ const getLearningItemsList_ConfigPropertyNames = {
         optional: ['learningItemIds']
     }
 };
-function createResourceParams$6(config) {
+function createResourceParams$4(config) {
     const resourceParams = {
         queryParams: {
             learningItemIds: config.learningItemIds
@@ -2765,11 +2765,11 @@ function createResourceParams$6(config) {
     };
     return resourceParams;
 }
-function keyBuilder$i(luvio, config) {
-    const resourceParams = createResourceParams$6(config);
-    return keyBuilder$j(luvio, resourceParams);
+function keyBuilder$c(luvio, config) {
+    const resourceParams = createResourceParams$4(config);
+    return keyBuilder$d(luvio, resourceParams);
 }
-function typeCheckConfig$6(untrustedConfig) {
+function typeCheckConfig$4(untrustedConfig) {
     const config = {};
     const untrustedConfig_learningItemIds = untrustedConfig.learningItemIds;
     if (ArrayIsArray$1(untrustedConfig_learningItemIds)) {
@@ -2784,48 +2784,48 @@ function typeCheckConfig$6(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$6(untrustedConfig);
+    const config = typeCheckConfig$4(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$6(luvio, config) {
-    createResourceParams$6(config);
-    return select$g();
+function adapterFragment$4(luvio, config) {
+    createResourceParams$4(config);
+    return select$b();
 }
-function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
+function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$6(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$6(luvio, resourceParams, response, {
+function onFetchResponseError$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$6(luvio, config, options) {
-    const resourceParams = createResourceParams$6(config);
-    const request = createResourceRequest$6(resourceParams);
+function buildNetworkSnapshot$4(luvio, config, options) {
+    const resourceParams = createResourceParams$4(config);
+    const request = createResourceRequest$4(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => getResponseCacheKeys$6(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => getResponseCacheKeys$4(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$6(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -2840,33 +2840,33 @@ function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$6(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$4(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$i(luvio, config),
-        node: adapterFragment$6(luvio, config),
+        recordId: keyBuilder$c(luvio, config),
+        node: adapterFragment$4(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getLearningItemsListAdapterFactory = (luvio) => function LearningContentPlatform__getLearningItemsList(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$6(untrustedConfig, getLearningItemsList_ConfigPropertyNames);
+    const config = validateAdapterConfig$4(untrustedConfig, getLearningItemsList_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$6, buildNetworkSnapshotCachePolicy$6);
+    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
 };
 
-const VERSION$9 = "5d4f9c65c714a3f1ef57de5a211599fb";
-function validate$9(obj, path = 'LearningAssignmentRepresentation') {
+const VERSION$6 = "5d4f9c65c714a3f1ef57de5a211599fb";
+function validate$6(obj, path = 'LearningAssignmentRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3118,10 +3118,10 @@ function validate$9(obj, path = 'LearningAssignmentRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$f = function LearningAssignmentRepresentationSelect() {
+const select$a = function LearningAssignmentRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$9,
+        version: VERSION$6,
         private: [],
         selections: [
             {
@@ -3171,7 +3171,7 @@ const select$f = function LearningAssignmentRepresentationSelect() {
         ]
     };
 };
-function equals$9(existing, incoming) {
+function equals$6(existing, incoming) {
     const existing_id = existing.id;
     const incoming_id = incoming.id;
     if (!(existing_id === incoming_id)) {
@@ -3230,9 +3230,9 @@ function equals$9(existing, incoming) {
     return true;
 }
 
-const TTL$5 = 15000;
-const VERSION$8 = "3ae4e1d57057645da8f2613fbdc5e245";
-function validate$8(obj, path = 'LearningModelOutputRepresentation') {
+const TTL$3 = 15000;
+const VERSION$5 = "3ae4e1d57057645da8f2613fbdc5e245";
+function validate$5(obj, path = 'LearningModelOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3271,7 +3271,7 @@ function validate$8(obj, path = 'LearningModelOutputRepresentation') {
         for (let i = 0; i < obj_assignments.length; i++) {
             const obj_assignments_item = obj_assignments[i];
             const path_assignments_item = path_assignments + '[' + i + ']';
-            const referencepath_assignments_itemValidationError = validate$9(obj_assignments_item, path_assignments_item);
+            const referencepath_assignments_itemValidationError = validate$6(obj_assignments_item, path_assignments_item);
             if (referencepath_assignments_itemValidationError !== null) {
                 let message = 'Object doesn\'t match LearningAssignmentRepresentation (at "' + path_assignments_item + '")\n';
                 message += referencepath_assignments_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3494,24 +3494,24 @@ function validate$8(obj, path = 'LearningModelOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$6 = 'LearningModelOutputRepresentation';
-function keyBuilder$h(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$6 + ':' + (config.learning_item_id === null ? '' : config.learning_item_id);
+const RepresentationType$3 = 'LearningModelOutputRepresentation';
+function keyBuilder$b(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$3 + ':' + (config.learning_item_id === null ? '' : config.learning_item_id);
 }
-function keyBuilderFromType$5(luvio, object) {
+function keyBuilderFromType$3(luvio, object) {
     const keyParams = {
         learning_item_id: object.id
     };
-    return keyBuilder$h(luvio, keyParams);
+    return keyBuilder$b(luvio, keyParams);
 }
-function normalize$6(input, existing, path, luvio, store, timestamp) {
+function normalize$3(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$e = function LearningModelOutputRepresentationSelect() {
-    const { selections: LearningAssignmentRepresentation__selections, opaque: LearningAssignmentRepresentation__opaque, } = select$f();
+const select$9 = function LearningModelOutputRepresentationSelect() {
+    const { selections: LearningAssignmentRepresentation__selections, opaque: LearningAssignmentRepresentation__opaque, } = select$a();
     return {
         kind: 'Fragment',
-        version: VERSION$8,
+        version: VERSION$5,
         private: [],
         selections: [
             {
@@ -3568,7 +3568,7 @@ const select$e = function LearningModelOutputRepresentationSelect() {
         ]
     };
 };
-function equals$8(existing, incoming) {
+function equals$5(existing, incoming) {
     const existing_description = existing.description;
     const incoming_description = incoming.description;
     if (!(existing_description === incoming_description)) {
@@ -3587,7 +3587,7 @@ function equals$8(existing, incoming) {
     const existing_assignments = existing.assignments;
     const incoming_assignments = incoming.assignments;
     const equals_assignments_items = equalsArray(existing_assignments, incoming_assignments, (existing_assignments_item, incoming_assignments_item) => {
-        if (!(equals$9(existing_assignments_item, incoming_assignments_item))) {
+        if (!(equals$6(existing_assignments_item, incoming_assignments_item))) {
             return false;
         }
     });
@@ -3646,66 +3646,66 @@ function equals$8(existing, incoming) {
     }
     return true;
 }
-const ingest$6 = function LearningModelOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$3 = function LearningModelOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$8(input);
+        const validateError = validate$5(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$5(luvio, input);
+    const key = keyBuilderFromType$3(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$5;
-    let incomingRecord = normalize$6(input, 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$8(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$5(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "LearningContentPlatform",
-            version: VERSION$8,
-            representationName: RepresentationType$6,
+            version: VERSION$5,
+            representationName: RepresentationType$3,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$6(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$3(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$5(luvio, input);
+    const rootKey = keyBuilderFromType$3(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$6,
+        representationName: RepresentationType$3,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$d(luvio, params) {
-    return select$e();
+function select$8(luvio, params) {
+    return select$9();
 }
-function keyBuilder$g(luvio, params) {
-    return keyBuilder$h(luvio, {
+function keyBuilder$a(luvio, params) {
+    return keyBuilder$b(luvio, {
         learning_item_id: params.urlParams.learningItemId
     });
 }
-function getResponseCacheKeys$5(luvio, resourceParams, response) {
-    return getTypeCacheKeys$6(luvio, response);
+function getResponseCacheKeys$3(luvio, resourceParams, response) {
+    return getTypeCacheKeys$3(luvio, response);
 }
-function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$g(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$6, body);
+    const key = keyBuilder$a(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$3, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$d(),
+        node: select$8(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -3716,19 +3716,19 @@ function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$5(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$g(luvio, params);
+function ingestError$3(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$a(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$5,
+        ttl: TTL$3,
         namespace: keyPrefix,
-        version: VERSION$8,
-        representationName: RepresentationType$6
+        version: VERSION$5,
+        representationName: RepresentationType$3
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$5(config) {
+function createResourceRequest$3(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -3749,7 +3749,7 @@ const getLearningModel_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$5(config) {
+function createResourceParams$3(config) {
     const resourceParams = {
         urlParams: {
             learningItemId: config.learningItemId
@@ -3757,11 +3757,11 @@ function createResourceParams$5(config) {
     };
     return resourceParams;
 }
-function keyBuilder$f(luvio, config) {
-    const resourceParams = createResourceParams$5(config);
-    return keyBuilder$g(luvio, resourceParams);
+function keyBuilder$9(luvio, config) {
+    const resourceParams = createResourceParams$3(config);
+    return keyBuilder$a(luvio, resourceParams);
 }
-function typeCheckConfig$5(untrustedConfig) {
+function typeCheckConfig$3(untrustedConfig) {
     const config = {};
     const untrustedConfig_learningItemId = untrustedConfig.learningItemId;
     if (typeof untrustedConfig_learningItemId === 'string') {
@@ -3769,750 +3769,40 @@ function typeCheckConfig$5(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$5(untrustedConfig);
+    const config = typeCheckConfig$3(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$5(luvio, config) {
-    createResourceParams$5(config);
-    return select$d();
+function adapterFragment$3(luvio, config) {
+    createResourceParams$3(config);
+    return select$8();
 }
-function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$5(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$5(luvio, resourceParams, response, {
+function onFetchResponseError$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function buildNetworkSnapshot$5(luvio, config, options) {
-    const resourceParams = createResourceParams$5(config);
-    const request = createResourceRequest$5(resourceParams);
-    return luvio.dispatchResourceRequest(request, options)
-        .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => getResponseCacheKeys$5(luvio, resourceParams, response.body));
-    }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$5(luvio, config, resourceParams, response));
-    });
-}
-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);
-}
-function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
-    const { luvio, config } = context;
-    const selector = {
-        recordId: keyBuilder$f(luvio, config),
-        node: adapterFragment$5(luvio, config),
-        variables: {},
-    };
-    const cacheSnapshot = storeLookup(selector, {
-        config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
-    });
-    return cacheSnapshot;
-}
-const getLearningModelAdapterFactory = (luvio) => function LearningContentPlatform__getLearningModel(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$5(untrustedConfig, getLearningModel_ConfigPropertyNames);
-    // Invalid or incomplete config
-    if (config === null) {
-        return null;
-    }
-    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
-};
-
-const TTL$4 = 60000;
-const VERSION$7 = "44b044bb4e3eff4d2c834cdb80b9a043";
-function validate$7(obj, path = 'LearningPracticeRepresentation') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        const obj_description = obj.description;
-        const path_description = path + '.description';
-        if (typeof obj_description !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
-        }
-        const obj_learningItemId = obj.learningItemId;
-        const path_learningItemId = path + '.learningItemId';
-        if (typeof obj_learningItemId !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_learningItemId + '" (at "' + path_learningItemId + '")');
-        }
-        const obj_minimumInviteeQuantity = obj.minimumInviteeQuantity;
-        const path_minimumInviteeQuantity = path + '.minimumInviteeQuantity';
-        if (typeof obj_minimumInviteeQuantity !== 'number' || (typeof obj_minimumInviteeQuantity === 'number' && Math.floor(obj_minimumInviteeQuantity) !== obj_minimumInviteeQuantity)) {
-            return new TypeError('Expected "integer" but received "' + typeof obj_minimumInviteeQuantity + '" (at "' + path_minimumInviteeQuantity + '")');
-        }
-        const obj_surveyId = obj.surveyId;
-        const path_surveyId = path + '.surveyId';
-        if (typeof obj_surveyId !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_surveyId + '" (at "' + path_surveyId + '")');
-        }
-        const obj_title = obj.title;
-        const path_title = path + '.title';
-        if (typeof obj_title !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-const RepresentationType$5 = 'LearningPracticeRepresentation';
-function keyBuilder$e(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$5 + ':' + config.learning_item_id;
-}
-function keyBuilderFromType$4(luvio, object) {
-    const keyParams = {
-        learning_item_id: object.learningItemId
-    };
-    return keyBuilder$e(luvio, keyParams);
-}
-function normalize$5(input, existing, path, luvio, store, timestamp) {
-    return input;
-}
-const select$c = function LearningPracticeRepresentationSelect() {
-    return {
-        kind: 'Fragment',
-        version: VERSION$7,
-        private: [],
-        selections: [
-            {
-                name: 'description',
-                kind: 'Scalar'
-            },
-            {
-                name: 'learningItemId',
-                kind: 'Scalar'
-            },
-            {
-                name: 'minimumInviteeQuantity',
-                kind: 'Scalar'
-            },
-            {
-                name: 'surveyId',
-                kind: 'Scalar'
-            },
-            {
-                name: 'title',
-                kind: 'Scalar'
-            }
-        ]
-    };
-};
-function equals$7(existing, incoming) {
-    const existing_minimumInviteeQuantity = existing.minimumInviteeQuantity;
-    const incoming_minimumInviteeQuantity = incoming.minimumInviteeQuantity;
-    if (!(existing_minimumInviteeQuantity === incoming_minimumInviteeQuantity)) {
-        return false;
-    }
-    const existing_description = existing.description;
-    const incoming_description = incoming.description;
-    if (!(existing_description === incoming_description)) {
-        return false;
-    }
-    const existing_learningItemId = existing.learningItemId;
-    const incoming_learningItemId = incoming.learningItemId;
-    if (!(existing_learningItemId === incoming_learningItemId)) {
-        return false;
-    }
-    const existing_surveyId = existing.surveyId;
-    const incoming_surveyId = incoming.surveyId;
-    if (!(existing_surveyId === incoming_surveyId)) {
-        return false;
-    }
-    const existing_title = existing.title;
-    const incoming_title = incoming.title;
-    if (!(existing_title === incoming_title)) {
-        return false;
-    }
-    return true;
-}
-const ingest$5 = function LearningPracticeRepresentationIngest(input, path, luvio, store, timestamp) {
-    if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$7(input);
-        if (validateError !== null) {
-            throw validateError;
-        }
-    }
-    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$7(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "LearningContentPlatform",
-            version: VERSION$7,
-            representationName: RepresentationType$5,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
-    return createLink(key);
-};
-function getTypeCacheKeys$5(luvio, input, fullPathFactory) {
-    const rootKeySet = new StoreKeyMap();
-    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$4(luvio, input);
-    rootKeySet.set(rootKey, {
-        namespace: keyPrefix,
-        representationName: RepresentationType$5,
-        mergeable: false
-    });
-    return rootKeySet;
-}
-
-function select$b(luvio, params) {
-    return select$c();
-}
-function keyBuilder$d(luvio, params) {
-    return keyBuilder$e(luvio, {
-        learning_item_id: params.urlParams.learningItemId
-    });
-}
-function getResponseCacheKeys$4(luvio, resourceParams, response) {
-    return getTypeCacheKeys$5(luvio, response);
-}
-function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
-    const { body } = response;
-    const key = keyBuilder$d(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$5, body);
-    const snapshot = luvio.storeLookup({
-        recordId: key,
-        node: select$b(),
-        variables: {},
-    }, snapshotRefresh);
-    if (process.env.NODE_ENV !== 'production') {
-        if (snapshot.state !== 'Fulfilled') {
-            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
-        }
-    }
-    deepFreeze(snapshot.data);
-    return snapshot;
-}
-function ingestError$4(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$d(luvio, params);
-    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
-    const storeMetadataParams = {
-        ttl: TTL$4,
-        namespace: keyPrefix,
-        version: VERSION$7,
-        representationName: RepresentationType$5
-    };
-    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
-    return errorSnapshot;
-}
-function createResourceRequest$4(config) {
-    const headers = {};
-    return {
-        baseUri: '/services/data/v59.0',
-        basePath: '/learning-content-platform/learning/practice/' + config.urlParams.learningItemId + '',
-        method: 'get',
-        body: null,
-        urlParams: config.urlParams,
-        queryParams: {},
-        headers,
-        priority: 'normal',
-    };
-}
-function createResourceRequestFromRepresentation$3(representation) {
-    const config = {
-        urlParams: {},
-    };
-    config.urlParams.learningItemId = representation.learningItemId;
-    return createResourceRequest$4(config);
-}
-
-const getLearningPractice_ConfigPropertyNames = {
-    displayName: 'getLearningPractice',
-    parameters: {
-        required: ['learningItemId'],
-        optional: []
-    }
-};
-function createResourceParams$4(config) {
-    const resourceParams = {
-        urlParams: {
-            learningItemId: config.learningItemId
-        }
-    };
-    return resourceParams;
-}
-function keyBuilder$c(luvio, config) {
-    const resourceParams = createResourceParams$4(config);
-    return keyBuilder$d(luvio, resourceParams);
-}
-function typeCheckConfig$4(untrustedConfig) {
-    const config = {};
-    const untrustedConfig_learningItemId = untrustedConfig.learningItemId;
-    if (typeof untrustedConfig_learningItemId === 'string') {
-        config.learningItemId = untrustedConfig_learningItemId;
-    }
-    return config;
-}
-function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
-    if (!untrustedIsObject(untrustedConfig)) {
-        return null;
-    }
-    if (process.env.NODE_ENV !== 'production') {
-        validateConfig(untrustedConfig, configPropertyNames);
-    }
-    const config = typeCheckConfig$4(untrustedConfig);
-    if (!areRequiredParametersPresent(config, configPropertyNames)) {
-        return null;
-    }
-    return config;
-}
-function adapterFragment$4(luvio, config) {
-    createResourceParams$4(config);
-    return select$b();
-}
-function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function onFetchResponseError$4(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$4(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function buildNetworkSnapshot$4(luvio, config, options) {
-    const resourceParams = createResourceParams$4(config);
-    const request = createResourceRequest$4(resourceParams);
-    return luvio.dispatchResourceRequest(request, options)
-        .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => getResponseCacheKeys$4(luvio, resourceParams, response.body));
-    }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
-    });
-}
-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);
-}
-function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
-    const { luvio, config } = context;
-    const selector = {
-        recordId: keyBuilder$c(luvio, config),
-        node: adapterFragment$4(luvio, config),
-        variables: {},
-    };
-    const cacheSnapshot = storeLookup(selector, {
-        config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
-    });
-    return cacheSnapshot;
-}
-const getLearningPracticeAdapterFactory = (luvio) => function LearningContentPlatform__getLearningPractice(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$4(untrustedConfig, getLearningPractice_ConfigPropertyNames);
-    // Invalid or incomplete config
-    if (config === null) {
-        return null;
-    }
-    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
-};
-const notifyChangeFactory$3 = (luvio, options) => {
-    return function getLearningContentPlatformLearningPracticeByLearningItemIdNotifyChange(configs) {
-        const keys = configs.map(c => keyBuilder$e(luvio, c));
-        luvio.getNotifyChangeStoreEntries(keys).then(entries => {
-            for (let i = 0, len = entries.length; i < len; i++) {
-                const { key, record: val } = entries[i];
-                const refreshRequest = createResourceRequestFromRepresentation$3(val);
-                luvio.dispatchResourceRequest(refreshRequest, options)
-                    .then((response) => {
-                    return luvio.handleSuccessResponse(() => {
-                        const { body } = response;
-                        luvio.storeIngest(key, ingest$5, body);
-                        return luvio.storeBroadcast();
-                    }, () => getTypeCacheKeys$5(luvio, response.body));
-                }, (error) => {
-                    return luvio.handleErrorResponse(() => {
-                        const errorSnapshot = luvio.errorSnapshot(error);
-                        luvio.storeIngestError(key, errorSnapshot, {
-                            ttl: TTL$4,
-                            namespace: keyPrefix,
-                            version: VERSION$7,
-                            representationName: RepresentationType$5
-                        });
-                        return luvio.storeBroadcast().then(() => errorSnapshot);
-                    });
-                });
-            }
-        });
-    };
-};
-
-const TTL$3 = 21600000;
-const VERSION$6 = "c365cdb9357c26a64f8a92d93a07daea";
-function validate$6(obj, path = 'LearningSearchDescribeContentRepresentation') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        const obj_title = obj.title;
-        const path_title = path + '.title';
-        if (typeof obj_title !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
-        }
-        const obj_type = obj.type;
-        const path_type = path + '.type';
-        if (typeof obj_type !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-const RepresentationType$4 = 'LearningSearchDescribeContentRepresentation';
-function keyBuilder$b(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$4 + ':' + config.type;
-}
-function keyBuilderFromType$3(luvio, object) {
-    const keyParams = {
-        type: object.type
-    };
-    return keyBuilder$b(luvio, keyParams);
-}
-function normalize$4(input, existing, path, luvio, store, timestamp) {
-    return input;
-}
-const select$a = function LearningSearchDescribeContentRepresentationSelect() {
-    return {
-        kind: 'Fragment',
-        version: VERSION$6,
-        private: [],
-        selections: [
-            {
-                name: 'title',
-                kind: 'Scalar'
-            },
-            {
-                name: 'type',
-                kind: 'Scalar'
-            }
-        ]
-    };
-};
-function equals$6(existing, incoming) {
-    const existing_title = existing.title;
-    const incoming_title = incoming.title;
-    if (!(existing_title === incoming_title)) {
-        return false;
-    }
-    const existing_type = existing.type;
-    const incoming_type = incoming.type;
-    if (!(existing_type === incoming_type)) {
-        return false;
-    }
-    return true;
-}
-const ingest$4 = function LearningSearchDescribeContentRepresentationIngest(input, path, luvio, store, timestamp) {
-    if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$6(input);
-        if (validateError !== null) {
-            throw validateError;
-        }
-    }
-    const key = keyBuilderFromType$3(luvio, input);
-    const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$3;
-    let incomingRecord = normalize$4(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: "LearningContentPlatform",
-            version: VERSION$6,
-            representationName: RepresentationType$4,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
-    return createLink(key);
-};
-function getTypeCacheKeys$4(luvio, input, fullPathFactory) {
-    const rootKeySet = new StoreKeyMap();
-    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$3(luvio, input);
-    rootKeySet.set(rootKey, {
-        namespace: keyPrefix,
-        representationName: RepresentationType$4,
-        mergeable: false
-    });
-    return rootKeySet;
-}
-
-const VERSION$5 = "efe7f2c47826ec8055be54360b646e19";
-function validate$5(obj, path = 'LearningSearchDescribeRepresentation') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        const obj_contentTypes = obj.contentTypes;
-        const path_contentTypes = path + '.contentTypes';
-        if (!ArrayIsArray(obj_contentTypes)) {
-            return new TypeError('Expected "array" but received "' + typeof obj_contentTypes + '" (at "' + path_contentTypes + '")');
-        }
-        for (let i = 0; i < obj_contentTypes.length; i++) {
-            const obj_contentTypes_item = obj_contentTypes[i];
-            const path_contentTypes_item = path_contentTypes + '[' + i + ']';
-            if (typeof obj_contentTypes_item !== 'object') {
-                return new TypeError('Expected "object" but received "' + typeof obj_contentTypes_item + '" (at "' + path_contentTypes_item + '")');
-            }
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-const RepresentationType$3 = 'LearningSearchDescribeRepresentation';
-function normalize$3(input, existing, path, luvio, store, timestamp) {
-    const input_contentTypes = input.contentTypes;
-    const input_contentTypes_id = path.fullPath + '__contentTypes';
-    for (let i = 0; i < input_contentTypes.length; i++) {
-        const input_contentTypes_item = input_contentTypes[i];
-        let input_contentTypes_item_id = input_contentTypes_id + '__' + i;
-        input_contentTypes[i] = ingest$4(input_contentTypes_item, {
-            fullPath: input_contentTypes_item_id,
-            propertyName: i,
-            parent: {
-                data: input,
-                key: path.fullPath,
-                existing: existing,
-            },
-            ttl: path.ttl
-        }, luvio, store);
-    }
-    return input;
-}
-const select$9 = function LearningSearchDescribeRepresentationSelect() {
-    return {
-        kind: 'Fragment',
-        version: VERSION$5,
-        private: [],
-        selections: [
-            {
-                name: 'contentTypes',
-                kind: 'Link',
-                plural: true,
-                fragment: select$a()
-            }
-        ]
-    };
-};
-function equals$5(existing, incoming) {
-    const existing_contentTypes = existing.contentTypes;
-    const incoming_contentTypes = incoming.contentTypes;
-    const equals_contentTypes_items = equalsArray(existing_contentTypes, incoming_contentTypes, (existing_contentTypes_item, incoming_contentTypes_item) => {
-        if (!(existing_contentTypes_item.__ref === incoming_contentTypes_item.__ref)) {
-            return false;
-        }
-    });
-    if (equals_contentTypes_items === false) {
-        return false;
-    }
-    return true;
-}
-const ingest$3 = function LearningSearchDescribeRepresentationIngest(input, path, luvio, store, timestamp) {
-    if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$5(input);
-        if (validateError !== null) {
-            throw validateError;
-        }
-    }
-    const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
-    const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$3(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$5(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "LearningContentPlatform",
-            version: VERSION$5,
-            representationName: RepresentationType$3,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
-    return createLink(key);
-};
-function getTypeCacheKeys$3(luvio, input, fullPathFactory) {
-    const rootKeySet = new StoreKeyMap();
-    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = fullPathFactory();
-    rootKeySet.set(rootKey, {
-        namespace: keyPrefix,
-        representationName: RepresentationType$3,
-        mergeable: false
-    });
-    const input_contentTypes_length = input.contentTypes.length;
-    for (let i = 0; i < input_contentTypes_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$4(luvio, input.contentTypes[i]));
-    }
-    return rootKeySet;
-}
-
-function select$8(luvio, params) {
-    return select$9();
-}
-function keyBuilder$a(luvio, params) {
-    return keyPrefix + '::LearningSearchDescribeRepresentation:(' + ')';
-}
-function getResponseCacheKeys$3(luvio, resourceParams, response) {
-    return getTypeCacheKeys$3(luvio, response, () => keyBuilder$a());
-}
-function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
-    const { body } = response;
-    const key = keyBuilder$a();
-    luvio.storeIngest(key, ingest$3, body);
-    const snapshot = luvio.storeLookup({
-        recordId: key,
-        node: select$8(),
-        variables: {},
-    }, snapshotRefresh);
-    if (process.env.NODE_ENV !== 'production') {
-        if (snapshot.state !== 'Fulfilled') {
-            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
-        }
-    }
-    deepFreeze(snapshot.data);
-    return snapshot;
-}
-function ingestError$3(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$a();
-    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
-    luvio.storeIngestError(key, errorSnapshot);
-    return errorSnapshot;
-}
-function createResourceRequest$3(config) {
-    const headers = {};
-    return {
-        baseUri: '/services/data/v59.0',
-        basePath: '/learning-content-platform/learning/search/describe',
-        method: 'get',
-        body: null,
-        urlParams: {},
-        queryParams: {},
-        headers,
-        priority: 'normal',
-    };
-}
-
-const getLearningSearchDescribe_ConfigPropertyNames = {
-    displayName: 'getLearningSearchDescribe',
-    parameters: {
-        required: [],
-        optional: []
-    }
-};
-function createResourceParams$3(config) {
-    const resourceParams = {};
-    return resourceParams;
-}
-function keyBuilder$9(luvio, config) {
-    return keyBuilder$a();
-}
-function typeCheckConfig$3(untrustedConfig) {
-    const config = {};
-    return config;
-}
-function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
-    if (!untrustedIsObject(untrustedConfig)) {
-        return null;
-    }
-    if (process.env.NODE_ENV !== 'production') {
-        validateConfig(untrustedConfig, configPropertyNames);
-    }
-    const config = typeCheckConfig$3();
-    if (!areRequiredParametersPresent(config, configPropertyNames)) {
-        return null;
-    }
-    return config;
-}
-function adapterFragment$3(luvio, config) {
-    return select$8();
-}
-function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function onFetchResponseError$3(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$3(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function buildNetworkSnapshot$3(luvio, config, options) {
-    const resourceParams = createResourceParams$3();
-    const request = createResourceRequest$3();
+    const resourceParams = createResourceParams$3(config);
+    const request = createResourceRequest$3(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => getResponseCacheKeys$3(luvio, resourceParams, response.body));
@@ -4540,8 +3830,8 @@ function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$9(),
-        node: adapterFragment$3(),
+        recordId: keyBuilder$9(luvio, config),
+        node: adapterFragment$3(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
@@ -4550,8 +3840,8 @@ function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     });
     return cacheSnapshot;
 }
-const getLearningSearchDescribeAdapterFactory = (luvio) => function LearningContentPlatform__getLearningSearchDescribe(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$3(untrustedConfig, getLearningSearchDescribe_ConfigPropertyNames);
+const getLearningModelAdapterFactory = (luvio) => function LearningContentPlatform__getLearningModel(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$3(untrustedConfig, getLearningModel_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -4560,114 +3850,112 @@ const getLearningSearchDescribeAdapterFactory = (luvio) => function LearningCont
     buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
 };
 
-const TTL$2 = 21600000;
-const VERSION$4 = "6f068b7b81d41fa29feab5d1ac9f9cb8";
-function validate$4(obj, path = 'LearningSearchResultsRepresentation') {
+const TTL$2 = 60000;
+const VERSION$4 = "44b044bb4e3eff4d2c834cdb80b9a043";
+function validate$4(obj, path = 'LearningPracticeRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-        const obj_results = obj.results;
-        const path_results = path + '.results';
-        if (!ArrayIsArray(obj_results)) {
-            return new TypeError('Expected "array" but received "' + typeof obj_results + '" (at "' + path_results + '")');
+        const obj_description = obj.description;
+        const path_description = path + '.description';
+        if (typeof obj_description !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+        }
+        const obj_learningItemId = obj.learningItemId;
+        const path_learningItemId = path + '.learningItemId';
+        if (typeof obj_learningItemId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_learningItemId + '" (at "' + path_learningItemId + '")');
         }
-        for (let i = 0; i < obj_results.length; i++) {
-            const obj_results_item = obj_results[i];
-            const path_results_item = path_results + '[' + i + ']';
-            if (typeof obj_results_item !== 'object') {
-                return new TypeError('Expected "object" but received "' + typeof obj_results_item + '" (at "' + path_results_item + '")');
-            }
+        const obj_minimumInviteeQuantity = obj.minimumInviteeQuantity;
+        const path_minimumInviteeQuantity = path + '.minimumInviteeQuantity';
+        if (typeof obj_minimumInviteeQuantity !== 'number' || (typeof obj_minimumInviteeQuantity === 'number' && Math.floor(obj_minimumInviteeQuantity) !== obj_minimumInviteeQuantity)) {
+            return new TypeError('Expected "integer" but received "' + typeof obj_minimumInviteeQuantity + '" (at "' + path_minimumInviteeQuantity + '")');
         }
-        const obj_totalResults = obj.totalResults;
-        const path_totalResults = path + '.totalResults';
-        if (typeof obj_totalResults !== 'number' || (typeof obj_totalResults === 'number' && Math.floor(obj_totalResults) !== obj_totalResults)) {
-            return new TypeError('Expected "integer" but received "' + typeof obj_totalResults + '" (at "' + path_totalResults + '")');
+        const obj_surveyId = obj.surveyId;
+        const path_surveyId = path + '.surveyId';
+        if (typeof obj_surveyId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_surveyId + '" (at "' + path_surveyId + '")');
         }
-        const obj_type = obj.type;
-        const path_type = path + '.type';
-        if (typeof obj_type !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+        const obj_title = obj.title;
+        const path_title = path + '.title';
+        if (typeof obj_title !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
         }
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$2 = 'LearningSearchResultsRepresentation';
+const RepresentationType$2 = 'LearningPracticeRepresentation';
 function keyBuilder$8(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$2 + ':' + config.type;
+    return keyPrefix + '::' + RepresentationType$2 + ':' + config.learning_item_id;
 }
 function keyBuilderFromType$2(luvio, object) {
     const keyParams = {
-        type: object.type
+        learning_item_id: object.learningItemId
     };
     return keyBuilder$8(luvio, keyParams);
 }
 function normalize$2(input, existing, path, luvio, store, timestamp) {
-    const input_results = input.results;
-    const input_results_id = path.fullPath + '__results';
-    for (let i = 0; i < input_results.length; i++) {
-        const input_results_item = input_results[i];
-        let input_results_item_id = input_results_id + '__' + i;
-        input_results[i] = ingest$d(input_results_item, {
-            fullPath: input_results_item_id,
-            propertyName: i,
-            parent: {
-                data: input,
-                key: path.fullPath,
-                existing: existing,
-            },
-            ttl: path.ttl
-        }, luvio, store);
-    }
     return input;
 }
-const select$7 = function LearningSearchResultsRepresentationSelect() {
+const select$7 = function LearningPracticeRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$4,
         private: [],
         selections: [
             {
-                name: 'results',
-                kind: 'Link',
-                plural: true,
-                fragment: select$r()
+                name: 'description',
+                kind: 'Scalar'
             },
             {
-                name: 'totalResults',
+                name: 'learningItemId',
                 kind: 'Scalar'
             },
             {
-                name: 'type',
+                name: 'minimumInviteeQuantity',
+                kind: 'Scalar'
+            },
+            {
+                name: 'surveyId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'title',
                 kind: 'Scalar'
             }
         ]
     };
 };
 function equals$4(existing, incoming) {
-    const existing_totalResults = existing.totalResults;
-    const incoming_totalResults = incoming.totalResults;
-    if (!(existing_totalResults === incoming_totalResults)) {
+    const existing_minimumInviteeQuantity = existing.minimumInviteeQuantity;
+    const incoming_minimumInviteeQuantity = incoming.minimumInviteeQuantity;
+    if (!(existing_minimumInviteeQuantity === incoming_minimumInviteeQuantity)) {
         return false;
     }
-    const existing_type = existing.type;
-    const incoming_type = incoming.type;
-    if (!(existing_type === incoming_type)) {
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
         return false;
     }
-    const existing_results = existing.results;
-    const incoming_results = incoming.results;
-    const equals_results_items = equalsArray(existing_results, incoming_results, (existing_results_item, incoming_results_item) => {
-        if (!(existing_results_item.__ref === incoming_results_item.__ref)) {
-            return false;
-        }
-    });
-    if (equals_results_items === false) {
+    const existing_learningItemId = existing.learningItemId;
+    const incoming_learningItemId = incoming.learningItemId;
+    if (!(existing_learningItemId === incoming_learningItemId)) {
+        return false;
+    }
+    const existing_surveyId = existing.surveyId;
+    const incoming_surveyId = incoming.surveyId;
+    if (!(existing_surveyId === incoming_surveyId)) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
         return false;
     }
     return true;
 }
-const ingest$2 = function LearningSearchResultsRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$2 = function LearningPracticeRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$4(input);
         if (validateError !== null) {
@@ -4682,7 +3970,7 @@ const ingest$2 = function LearningSearchResultsRepresentationIngest(input, path,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
-    }, luvio, store);
+    });
     if (existingRecord === undefined || equals$4(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
@@ -4706,10 +3994,6 @@ function getTypeCacheKeys$2(luvio, input, fullPathFactory) {
         representationName: RepresentationType$2,
         mergeable: false
     });
-    const input_results_length = input.results.length;
-    for (let i = 0; i < input_results_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$d(luvio, input.results[i]));
-    }
     return rootKeySet;
 }
 
@@ -4718,7 +4002,7 @@ function select$6(luvio, params) {
 }
 function keyBuilder$7(luvio, params) {
     return keyBuilder$8(luvio, {
-        type: params.urlParams.contentType
+        learning_item_id: params.urlParams.learningItemId
     });
 }
 function getResponseCacheKeys$2(luvio, resourceParams, response) {
@@ -4757,11 +4041,11 @@ function createResourceRequest$2(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
-        basePath: '/learning-content-platform/learning/search/type/' + config.urlParams.contentType + '',
+        basePath: '/learning-content-platform/learning/practice/' + config.urlParams.learningItemId + '',
         method: 'get',
         body: null,
         urlParams: config.urlParams,
-        queryParams: config.queryParams,
+        queryParams: {},
         headers,
         priority: 'normal',
     };
@@ -4769,26 +4053,22 @@ function createResourceRequest$2(config) {
 function createResourceRequestFromRepresentation$2(representation) {
     const config = {
         urlParams: {},
-        queryParams: {},
     };
-    config.urlParams.contentType = representation.type;
+    config.urlParams.learningItemId = representation.learningItemId;
     return createResourceRequest$2(config);
 }
 
-const getLearningSearchResults_ConfigPropertyNames = {
-    displayName: 'getLearningSearchResults',
+const getLearningPractice_ConfigPropertyNames = {
+    displayName: 'getLearningPractice',
     parameters: {
-        required: ['contentType', 'limit', 'q'],
+        required: ['learningItemId'],
         optional: []
     }
 };
 function createResourceParams$2(config) {
     const resourceParams = {
         urlParams: {
-            contentType: config.contentType
-        },
-        queryParams: {
-            limit: config.limit, q: config.q
+            learningItemId: config.learningItemId
         }
     };
     return resourceParams;
@@ -4799,17 +4079,9 @@ function keyBuilder$6(luvio, config) {
 }
 function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    const untrustedConfig_contentType = untrustedConfig.contentType;
-    if (typeof untrustedConfig_contentType === 'string') {
-        config.contentType = untrustedConfig_contentType;
-    }
-    const untrustedConfig_limit = untrustedConfig.limit;
-    if (typeof untrustedConfig_limit === 'number' && Math.floor(untrustedConfig_limit) === untrustedConfig_limit) {
-        config.limit = untrustedConfig_limit;
-    }
-    const untrustedConfig_q = untrustedConfig.q;
-    if (typeof untrustedConfig_q === 'string') {
-        config.q = untrustedConfig_q;
+    const untrustedConfig_learningItemId = untrustedConfig.learningItemId;
+    if (typeof untrustedConfig_learningItemId === 'string') {
+        config.learningItemId = untrustedConfig_learningItemId;
     }
     return config;
 }
@@ -4884,8 +4156,8 @@ function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     });
     return cacheSnapshot;
 }
-const getLearningSearchResultsAdapterFactory = (luvio) => function LearningContentPlatform__getLearningSearchResults(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$2(untrustedConfig, getLearningSearchResults_ConfigPropertyNames);
+const getLearningPracticeAdapterFactory = (luvio) => function LearningContentPlatform__getLearningPractice(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$2(untrustedConfig, getLearningPractice_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -4894,7 +4166,7 @@ const getLearningSearchResultsAdapterFactory = (luvio) => function LearningConte
     buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
 };
 const notifyChangeFactory$2 = (luvio, options) => {
-    return function getLearningContentPlatformLearningSearchTypeByContentTypeNotifyChange(configs) {
+    return function getLearningContentPlatformLearningPracticeByLearningItemIdNotifyChange(configs) {
         const keys = configs.map(c => keyBuilder$8(luvio, c));
         luvio.getNotifyChangeStoreEntries(keys).then(entries => {
             for (let i = 0, len = entries.length; i < len; i++) {
@@ -6145,9 +5417,6 @@ let getLearningItemsList;
 let getLearningModel;
 let getLearningPractice;
 let getLearningPracticeNotifyChange;
-let getLearningSearchDescribe;
-let getLearningSearchResults;
-let getLearningSearchResultsNotifyChange;
 let getModule;
 let getModuleNotifyChange;
 let getTextLesson;
@@ -6160,8 +5429,6 @@ let getLearningItemProgress_imperative;
 let getLearningItemsList_imperative;
 let getLearningModel_imperative;
 let getLearningPractice_imperative;
-let getLearningSearchDescribe_imperative;
-let getLearningSearchResults_imperative;
 let getModule_imperative;
 let getTextLesson_imperative;
 const getFeaturedItemsRecommendedListMetadata = { apiFamily: 'LearningContentPlatform', name: 'getFeaturedItemsRecommendedList' };
@@ -6171,8 +5438,6 @@ const getLearningItemProgressMetadata = { apiFamily: 'LearningContentPlatform',
 const getLearningItemsListMetadata = { apiFamily: 'LearningContentPlatform', name: 'getLearningItemsList' };
 const getLearningModelMetadata = { apiFamily: 'LearningContentPlatform', name: 'getLearningModel', ttl: 15000 };
 const getLearningPracticeMetadata = { apiFamily: 'LearningContentPlatform', name: 'getLearningPractice', ttl: 60000 };
-const getLearningSearchDescribeMetadata = { apiFamily: 'LearningContentPlatform', name: 'getLearningSearchDescribe' };
-const getLearningSearchResultsMetadata = { apiFamily: 'LearningContentPlatform', name: 'getLearningSearchResults', ttl: 21600000 };
 const getModuleMetadata = { apiFamily: 'LearningContentPlatform', name: 'getModule', ttl: 21600000 };
 const getTextLessonMetadata = { apiFamily: 'LearningContentPlatform', name: 'getTextLesson', ttl: 60000 };
 function bindExportsTo(luvio) {
@@ -6184,8 +5449,6 @@ function bindExportsTo(luvio) {
     const getLearningItemsList_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getLearningItemsList', getLearningItemsListAdapterFactory), getLearningItemsListMetadata);
     const getLearningModel_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getLearningModel', getLearningModelAdapterFactory), getLearningModelMetadata);
     const getLearningPractice_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getLearningPractice', getLearningPracticeAdapterFactory), getLearningPracticeMetadata);
-    const getLearningSearchDescribe_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getLearningSearchDescribe', getLearningSearchDescribeAdapterFactory), getLearningSearchDescribeMetadata);
-    const getLearningSearchResults_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getLearningSearchResults', getLearningSearchResultsAdapterFactory), getLearningSearchResultsMetadata);
     const getModule_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getModule', getModuleAdapterFactory), getModuleMetadata);
     const getTextLesson_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getTextLesson', getTextLessonAdapterFactory), getTextLessonMetadata);
     function unwrapSnapshotData(factory) {
@@ -6201,10 +5464,7 @@ function bindExportsTo(luvio) {
         getLearningItemsList: createWireAdapterConstructor(luvio, getLearningItemsList_ldsAdapter, getLearningItemsListMetadata),
         getLearningModel: createWireAdapterConstructor(luvio, getLearningModel_ldsAdapter, getLearningModelMetadata),
         getLearningPractice: createWireAdapterConstructor(luvio, getLearningPractice_ldsAdapter, getLearningPracticeMetadata),
-        getLearningPracticeNotifyChange: createLDSAdapter(luvio, 'getLearningPracticeNotifyChange', notifyChangeFactory$3),
-        getLearningSearchDescribe: createWireAdapterConstructor(luvio, getLearningSearchDescribe_ldsAdapter, getLearningSearchDescribeMetadata),
-        getLearningSearchResults: createWireAdapterConstructor(luvio, getLearningSearchResults_ldsAdapter, getLearningSearchResultsMetadata),
-        getLearningSearchResultsNotifyChange: createLDSAdapter(luvio, 'getLearningSearchResultsNotifyChange', notifyChangeFactory$2),
+        getLearningPracticeNotifyChange: createLDSAdapter(luvio, 'getLearningPracticeNotifyChange', notifyChangeFactory$2),
         getModule: createWireAdapterConstructor(luvio, getModule_ldsAdapter, getModuleMetadata),
         getModuleNotifyChange: createLDSAdapter(luvio, 'getModuleNotifyChange', notifyChangeFactory$1),
         getTextLesson: createWireAdapterConstructor(luvio, getTextLesson_ldsAdapter, getTextLessonMetadata),
@@ -6217,8 +5477,6 @@ function bindExportsTo(luvio) {
         getLearningItemsList_imperative: createImperativeAdapter(luvio, getLearningItemsList_ldsAdapter, getLearningItemsListMetadata),
         getLearningModel_imperative: createImperativeAdapter(luvio, getLearningModel_ldsAdapter, getLearningModelMetadata),
         getLearningPractice_imperative: createImperativeAdapter(luvio, getLearningPractice_ldsAdapter, getLearningPracticeMetadata),
-        getLearningSearchDescribe_imperative: createImperativeAdapter(luvio, getLearningSearchDescribe_ldsAdapter, getLearningSearchDescribeMetadata),
-        getLearningSearchResults_imperative: createImperativeAdapter(luvio, getLearningSearchResults_ldsAdapter, getLearningSearchResultsMetadata),
         getModule_imperative: createImperativeAdapter(luvio, getModule_ldsAdapter, getModuleMetadata),
         getTextLesson_imperative: createImperativeAdapter(luvio, getTextLesson_ldsAdapter, getTextLessonMetadata)
     };
@@ -6234,9 +5492,6 @@ withDefaultLuvio((luvio) => {
         getLearningModel,
         getLearningPractice,
         getLearningPracticeNotifyChange,
-        getLearningSearchDescribe,
-        getLearningSearchResults,
-        getLearningSearchResultsNotifyChange,
         getModule,
         getModuleNotifyChange,
         getTextLesson,
@@ -6248,12 +5503,10 @@ withDefaultLuvio((luvio) => {
         getLearningItemsList_imperative,
         getLearningModel_imperative,
         getLearningPractice_imperative,
-        getLearningSearchDescribe_imperative,
-        getLearningSearchResults_imperative,
         getModule_imperative,
         getTextLesson_imperative
     } = bindExportsTo(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, getLearningSearchDescribe, getLearningSearchDescribe_imperative, getLearningSearchResults, getLearningSearchResultsNotifyChange, getLearningSearchResults_imperative, getModule, getModuleNotifyChange, getModule_imperative, getTextLesson, getTextLessonNotifyChange, getTextLesson_imperative };
-// version: 1.149.0-69a6ce242
+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.150.0-d3d5689fc