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

package/dist/es/es2018/platform-learning-content.js

@@ -91,9 +91,9 @@ function createLink(ref) {
     };
 }
 
-const TTL$8 = 15000;
-const VERSION$h = "b489f9f2cbdc91a04dd15b4d467b6760";
-function validate$i(obj, path = 'FeaturedItemRepresentation') {
+const TTL$6 = 15000;
+const VERSION$e = "b489f9f2cbdc91a04dd15b4d467b6760";
+function validate$f(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 + '")');
@@ -490,23 +490,23 @@ function validate$i(obj, path = 'FeaturedItemRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$e = 'FeaturedItemRepresentation';
-function keyBuilder$u(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$e + ':' + config.id;
+const RepresentationType$b = 'FeaturedItemRepresentation';
+function keyBuilder$o(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$b + ':' + config.id;
 }
-function keyBuilderFromType$8(luvio, object) {
+function keyBuilderFromType$6(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    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 FeaturedItemRepresentationSelect() {
+const select$o = function FeaturedItemRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$h,
+        version: VERSION$e,
         private: [],
         selections: [
             {
@@ -588,7 +588,7 @@ const select$t = function FeaturedItemRepresentationSelect() {
         ]
     };
 };
-function equals$h(existing, incoming) {
+function equals$e(existing, incoming) {
     const existing_description = existing.description;
     const incoming_description = incoming.description;
     if (!(existing_description === incoming_description)) {
@@ -686,50 +686,50 @@ function equals$h(existing, incoming) {
     }
     return true;
 }
-const ingest$e = function FeaturedItemRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$b = function FeaturedItemRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$i(input);
+        const validateError = validate$f(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;
 }
 
-const VERSION$g = "94c7194d9578589364c6efd021226634";
-function validate$h(obj, path = 'FeaturedItemRecommendedListRepresentation') {
+const VERSION$d = "94c7194d9578589364c6efd021226634";
+function validate$e(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 + '")');
@@ -749,14 +749,14 @@ function validate$h(obj, path = 'FeaturedItemRecommendedListRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$d = 'FeaturedItemRecommendedListRepresentation';
-function normalize$d(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$a = 'FeaturedItemRecommendedListRepresentation';
+function normalize$a(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$e(input_recommendedList_item, {
+        input_recommendedList[i] = ingest$b(input_recommendedList_item, {
             fullPath: input_recommendedList_item_id,
             propertyName: i,
             parent: {
@@ -769,22 +769,22 @@ function normalize$d(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$s = function FeaturedItemRecommendedListRepresentationSelect() {
+const select$n = function FeaturedItemRecommendedListRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$g,
+        version: VERSION$d,
         private: [],
         selections: [
             {
                 name: 'recommendedList',
                 kind: 'Link',
                 plural: true,
-                fragment: select$t()
+                fragment: select$o()
             }
         ]
     };
 };
-function equals$g(existing, incoming) {
+function equals$d(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) => {
@@ -797,9 +797,9 @@ function equals$g(existing, incoming) {
     }
     return true;
 }
-const ingest$d = function FeaturedItemRecommendedListRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$a = function FeaturedItemRecommendedListRepresentationIngest(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;
         }
@@ -807,58 +807,58 @@ const ingest$d = function FeaturedItemRecommendedListRepresentationIngest(input,
     const key = path.fullPath;
     const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-    let incomingRecord = normalize$d(input, store.readEntry(key), {
+    let incomingRecord = normalize$a(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     }, luvio, store);
-    if (existingRecord === undefined || equals$g(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$d(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     if (ttlToUse !== undefined) {
         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 = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$d,
+        representationName: RepresentationType$a,
         mergeable: false
     });
     const input_recommendedList_length = input.recommendedList.length;
     for (let i = 0; i < input_recommendedList_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$e(luvio, input.recommendedList[i]));
+        rootKeySet.merge(getTypeCacheKeys$b(luvio, input.recommendedList[i]));
     }
     return rootKeySet;
 }
 
-function select$r(luvio, params) {
-    return select$s();
+function select$m(luvio, params) {
+    return select$n();
 }
-function keyBuilder$t(luvio, params) {
+function keyBuilder$n(luvio, params) {
     return keyPrefix + '::FeaturedItemRecommendedListRepresentation:(' + 'appId:' + params.queryParams.appId + ',' + 'context:' + params.queryParams.context + ')';
 }
-function getResponseCacheKeys$b(luvio, resourceParams, response) {
-    return getTypeCacheKeys$d(luvio, response, () => keyBuilder$t(luvio, resourceParams));
+function getResponseCacheKeys$9(luvio, resourceParams, response) {
+    return getTypeCacheKeys$a(luvio, response, () => keyBuilder$n(luvio, resourceParams));
 }
-function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$t(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$d, body);
+    const key = keyBuilder$n(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$a, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$r(),
+        node: select$m(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -869,13 +869,13 @@ function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$a(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$t(luvio, params);
+function ingestError$8(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$n(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$b(config) {
+function createResourceRequest$9(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -896,7 +896,7 @@ const getFeaturedItemsRecommendedList_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$b(config) {
+function createResourceParams$9(config) {
     const resourceParams = {
         queryParams: {
             appId: config.appId, context: config.context
@@ -904,11 +904,11 @@ function createResourceParams$b(config) {
     };
     return resourceParams;
 }
-function keyBuilder$s(luvio, config) {
-    const resourceParams = createResourceParams$b(config);
-    return keyBuilder$t(luvio, resourceParams);
+function keyBuilder$m(luvio, config) {
+    const resourceParams = createResourceParams$9(config);
+    return keyBuilder$n(luvio, resourceParams);
 }
-function typeCheckConfig$b(untrustedConfig) {
+function typeCheckConfig$9(untrustedConfig) {
     const config = {};
     const untrustedConfig_appId = untrustedConfig.appId;
     if (typeof untrustedConfig_appId === 'string') {
@@ -920,48 +920,48 @@ function typeCheckConfig$b(untrustedConfig) {
     }
     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 adapterFragment$a(luvio, config) {
-    createResourceParams$b(config);
-    return select$r();
+function adapterFragment$8(luvio, config) {
+    createResourceParams$9(config);
+    return select$m();
 }
-function onFetchResponseSuccess$a(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$b(luvio, resourceParams, response, {
+function onFetchResponseSuccess$8(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(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$b(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-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(() => onFetchResponseSuccess$a(luvio, config, resourceParams, response), () => getResponseCacheKeys$b(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$8(luvio, config, resourceParams, response), () => getResponseCacheKeys$9(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 = {
@@ -976,33 +976,33 @@ function buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$b(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$9(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$s(luvio, config),
-        node: adapterFragment$a(luvio, config),
+        recordId: keyBuilder$m(luvio, config),
+        node: adapterFragment$8(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getFeaturedItemsRecommendedListAdapterFactory = (luvio) => function LearningContentPlatform__getFeaturedItemsRecommendedList(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$b(untrustedConfig, getFeaturedItemsRecommendedList_ConfigPropertyNames);
+    const config = validateAdapterConfig$9(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$f = "5d7adb55f43466f61c4837ebf27eab61";
-function validate$g(obj, path = 'FeaturedItemRelatedListRepresentation') {
+const VERSION$c = "5d7adb55f43466f61c4837ebf27eab61";
+function validate$d(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 + '")');
@@ -1022,14 +1022,14 @@ function validate$g(obj, path = 'FeaturedItemRelatedListRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$c = 'FeaturedItemRelatedListRepresentation';
-function normalize$c(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$9 = 'FeaturedItemRelatedListRepresentation';
+function normalize$9(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$e(input_relatedList_item, {
+        input_relatedList[i] = ingest$b(input_relatedList_item, {
             fullPath: input_relatedList_item_id,
             propertyName: i,
             parent: {
@@ -1042,22 +1042,22 @@ function normalize$c(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$q = function FeaturedItemRelatedListRepresentationSelect() {
+const select$l = function FeaturedItemRelatedListRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$f,
+        version: VERSION$c,
         private: [],
         selections: [
             {
                 name: 'relatedList',
                 kind: 'Link',
                 plural: true,
-                fragment: select$t()
+                fragment: select$o()
             }
         ]
     };
 };
-function equals$f(existing, incoming) {
+function equals$c(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) => {
@@ -1070,9 +1070,9 @@ function equals$f(existing, incoming) {
     }
     return true;
 }
-const ingest$c = function FeaturedItemRelatedListRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$9 = function FeaturedItemRelatedListRepresentationIngest(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;
         }
@@ -1080,58 +1080,58 @@ const ingest$c = function FeaturedItemRelatedListRepresentationIngest(input, pat
     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_relatedList_length = input.relatedList.length;
     for (let i = 0; i < input_relatedList_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$e(luvio, input.relatedList[i]));
+        rootKeySet.merge(getTypeCacheKeys$b(luvio, input.relatedList[i]));
     }
     return rootKeySet;
 }
 
-function select$p(luvio, params) {
-    return select$q();
+function select$k(luvio, params) {
+    return select$l();
 }
-function keyBuilder$r(luvio, params) {
+function keyBuilder$l(luvio, params) {
     return keyPrefix + '::FeaturedItemRelatedListRepresentation:(' + 'appId:' + params.queryParams.appId + ',' + 'pageRef:' + params.queryParams.pageRef + ')';
 }
-function getResponseCacheKeys$a(luvio, resourceParams, response) {
-    return getTypeCacheKeys$c(luvio, response, () => keyBuilder$r(luvio, resourceParams));
+function getResponseCacheKeys$8(luvio, resourceParams, response) {
+    return getTypeCacheKeys$9(luvio, response, () => keyBuilder$l(luvio, resourceParams));
 }
-function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$r(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$c, body);
+    const key = keyBuilder$l(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') {
@@ -1142,13 +1142,13 @@ function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$9(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$r(luvio, params);
+function ingestError$7(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$l(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',
@@ -1169,7 +1169,7 @@ const getFeaturedItemsRelatedList_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$a(config) {
+function createResourceParams$8(config) {
     const resourceParams = {
         queryParams: {
             appId: config.appId, pageRef: config.pageRef
@@ -1177,11 +1177,11 @@ function createResourceParams$a(config) {
     };
     return resourceParams;
 }
-function keyBuilder$q(luvio, config) {
-    const resourceParams = createResourceParams$a(config);
-    return keyBuilder$r(luvio, resourceParams);
+function keyBuilder$k(luvio, config) {
+    const resourceParams = createResourceParams$8(config);
+    return keyBuilder$l(luvio, resourceParams);
 }
-function typeCheckConfig$a(untrustedConfig) {
+function typeCheckConfig$8(untrustedConfig) {
     const config = {};
     const untrustedConfig_appId = untrustedConfig.appId;
     if (typeof untrustedConfig_appId === 'string') {
@@ -1193,48 +1193,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$9(luvio, config) {
-    createResourceParams$a(config);
-    return select$p();
+function adapterFragment$7(luvio, config) {
+    createResourceParams$8(config);
+    return select$k();
 }
-function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
+function onFetchResponseSuccess$7(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$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$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$9(luvio, config, resourceParams, response), () => getResponseCacheKeys$a(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$7(luvio, config, resourceParams, response), () => getResponseCacheKeys$8(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 = {
@@ -1249,713 +1249,23 @@ function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$a(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$8(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$q(luvio, config),
-        node: adapterFragment$9(luvio, config),
+        recordId: keyBuilder$k(luvio, config),
+        node: adapterFragment$7(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getFeaturedItemsRelatedListAdapterFactory = (luvio) => function LearningContentPlatform__getFeaturedItemsRelatedList(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$a(untrustedConfig, getFeaturedItemsRelatedList_ConfigPropertyNames);
-    // Invalid or incomplete config
-    if (config === null) {
-        return null;
-    }
-    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$9, buildNetworkSnapshotCachePolicy$9);
-};
-
-const TTL$7 = 21600000;
-const VERSION$e = "c365cdb9357c26a64f8a92d93a07daea";
-function validate$f(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$b = 'LearningSearchDescribeContentRepresentation';
-function keyBuilder$p(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$b + ':' + config.type;
-}
-function keyBuilderFromType$7(luvio, object) {
-    const keyParams = {
-        type: object.type
-    };
-    return keyBuilder$p(luvio, keyParams);
-}
-function normalize$b(input, existing, path, luvio, store, timestamp) {
-    return input;
-}
-const select$o = function LearningSearchDescribeContentRepresentationSelect() {
-    return {
-        kind: 'Fragment',
-        version: VERSION$e,
-        private: [],
-        selections: [
-            {
-                name: 'title',
-                kind: 'Scalar'
-            },
-            {
-                name: 'type',
-                kind: 'Scalar'
-            }
-        ]
-    };
-};
-function equals$e(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$b = function LearningSearchDescribeContentRepresentationIngest(input, path, luvio, store, timestamp) {
-    if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$f(input);
-        if (validateError !== null) {
-            throw validateError;
-        }
-    }
-    const key = keyBuilderFromType$7(luvio, input);
-    const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$7;
-    let incomingRecord = normalize$b(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$e(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "LearningContentPlatform",
-            version: VERSION$e,
-            representationName: RepresentationType$b,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
-    return createLink(key);
-};
-function getTypeCacheKeys$b(luvio, input, fullPathFactory) {
-    const rootKeySet = new StoreKeyMap();
-    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$7(luvio, input);
-    rootKeySet.set(rootKey, {
-        namespace: keyPrefix,
-        representationName: RepresentationType$b,
-        mergeable: false
-    });
-    return rootKeySet;
-}
-
-const VERSION$d = "efe7f2c47826ec8055be54360b646e19";
-function validate$e(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$a = 'LearningSearchDescribeRepresentation';
-function normalize$a(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$b(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$n = function LearningSearchDescribeRepresentationSelect() {
-    return {
-        kind: 'Fragment',
-        version: VERSION$d,
-        private: [],
-        selections: [
-            {
-                name: 'contentTypes',
-                kind: 'Link',
-                plural: true,
-                fragment: select$o()
-            }
-        ]
-    };
-};
-function equals$d(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$a = function LearningSearchDescribeRepresentationIngest(input, path, luvio, store, timestamp) {
-    if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$e(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$a(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$d(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "LearningContentPlatform",
-            version: VERSION$d,
-            representationName: RepresentationType$a,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
-    return createLink(key);
-};
-function getTypeCacheKeys$a(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,
-        mergeable: false
-    });
-    const input_contentTypes_length = input.contentTypes.length;
-    for (let i = 0; i < input_contentTypes_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$b(luvio, input.contentTypes[i]));
-    }
-    return rootKeySet;
-}
-
-function select$m(luvio, params) {
-    return select$n();
-}
-function keyBuilder$o(luvio, params) {
-    return keyPrefix + '::LearningSearchDescribeRepresentation:(' + ')';
-}
-function getResponseCacheKeys$9(luvio, resourceParams, response) {
-    return getTypeCacheKeys$a(luvio, response, () => keyBuilder$o());
-}
-function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
-    const { body } = response;
-    const key = keyBuilder$o();
-    luvio.storeIngest(key, ingest$a, body);
-    const snapshot = luvio.storeLookup({
-        recordId: key,
-        node: select$m(),
-        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$8(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$o();
-    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
-    luvio.storeIngestError(key, errorSnapshot);
-    return errorSnapshot;
-}
-function createResourceRequest$9(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$9(config) {
-    const resourceParams = {};
-    return resourceParams;
-}
-function keyBuilder$n(luvio, config) {
-    return keyBuilder$o();
-}
-function typeCheckConfig$9(untrustedConfig) {
-    const config = {};
-    return config;
-}
-function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
-    if (!untrustedIsObject(untrustedConfig)) {
-        return null;
-    }
-    if (process.env.NODE_ENV !== 'production') {
-        validateConfig(untrustedConfig, configPropertyNames);
-    }
-    const config = typeCheckConfig$9();
-    if (!areRequiredParametersPresent(config, configPropertyNames)) {
-        return null;
-    }
-    return config;
-}
-function adapterFragment$8(luvio, config) {
-    return select$m();
-}
-function onFetchResponseSuccess$8(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function onFetchResponseError$8(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$8(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function buildNetworkSnapshot$9(luvio, config, options) {
-    const resourceParams = createResourceParams$9();
-    const request = createResourceRequest$9();
-    return luvio.dispatchResourceRequest(request, options)
-        .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$8(luvio, config, resourceParams, response), () => getResponseCacheKeys$9(luvio, resourceParams, response.body));
-    }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$8(luvio, config, resourceParams, response));
-    });
-}
-function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$9(luvio, config, dispatchOptions);
-}
-function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
-    const { luvio, config } = context;
-    const selector = {
-        recordId: keyBuilder$n(),
-        node: adapterFragment$8(),
-        variables: {},
-    };
-    const cacheSnapshot = storeLookup(selector, {
-        config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
-    });
-    return cacheSnapshot;
-}
-const getLearningSearchDescribeAdapterFactory = (luvio) => function LearningContentPlatform__getLearningSearchDescribe(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$9(untrustedConfig, getLearningSearchDescribe_ConfigPropertyNames);
-    // Invalid or incomplete config
-    if (config === null) {
-        return null;
-    }
-    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$8, buildNetworkSnapshotCachePolicy$8);
-};
-
-const TTL$6 = 21600000;
-const VERSION$c = "6f068b7b81d41fa29feab5d1ac9f9cb8";
-function validate$d(obj, path = 'LearningSearchResultsRepresentation') {
-    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 + '")');
-        }
-        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_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_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$9 = 'LearningSearchResultsRepresentation';
-function keyBuilder$m(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$9 + ':' + config.type;
-}
-function keyBuilderFromType$6(luvio, object) {
-    const keyParams = {
-        type: object.type
-    };
-    return keyBuilder$m(luvio, keyParams);
-}
-function normalize$9(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$e(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$l = function LearningSearchResultsRepresentationSelect() {
-    return {
-        kind: 'Fragment',
-        version: VERSION$c,
-        private: [],
-        selections: [
-            {
-                name: 'results',
-                kind: 'Link',
-                plural: true,
-                fragment: select$t()
-            },
-            {
-                name: 'totalResults',
-                kind: 'Scalar'
-            },
-            {
-                name: 'type',
-                kind: 'Scalar'
-            }
-        ]
-    };
-};
-function equals$c(existing, incoming) {
-    const existing_totalResults = existing.totalResults;
-    const incoming_totalResults = incoming.totalResults;
-    if (!(existing_totalResults === incoming_totalResults)) {
-        return false;
-    }
-    const existing_type = existing.type;
-    const incoming_type = incoming.type;
-    if (!(existing_type === incoming_type)) {
-        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) {
-        return false;
-    }
-    return true;
-}
-const ingest$9 = function LearningSearchResultsRepresentationIngest(input, path, luvio, store, timestamp) {
-    if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$d(input);
-        if (validateError !== null) {
-            throw validateError;
-        }
-    }
-    const key = keyBuilderFromType$6(luvio, input);
-    const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$6;
-    let incomingRecord = normalize$9(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    }, luvio, store);
-    if (existingRecord === undefined || equals$c(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "LearningContentPlatform",
-            version: VERSION$c,
-            representationName: RepresentationType$9,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
-    return createLink(key);
-};
-function getTypeCacheKeys$9(luvio, input, fullPathFactory) {
-    const rootKeySet = new StoreKeyMap();
-    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$6(luvio, input);
-    rootKeySet.set(rootKey, {
-        namespace: keyPrefix,
-        representationName: RepresentationType$9,
-        mergeable: false
-    });
-    const input_results_length = input.results.length;
-    for (let i = 0; i < input_results_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$e(luvio, input.results[i]));
-    }
-    return rootKeySet;
-}
-
-function select$k(luvio, params) {
-    return select$l();
-}
-function keyBuilder$l(luvio, params) {
-    return keyBuilder$m(luvio, {
-        type: params.urlParams.contentType
-    });
-}
-function getResponseCacheKeys$8(luvio, resourceParams, response) {
-    return getTypeCacheKeys$9(luvio, response);
-}
-function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
-    const { body } = response;
-    const key = keyBuilder$l(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$9, body);
-    const snapshot = luvio.storeLookup({
-        recordId: key,
-        node: select$k(),
-        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$7(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$l(luvio, params);
-    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
-    const storeMetadataParams = {
-        ttl: TTL$6,
-        namespace: keyPrefix,
-        version: VERSION$c,
-        representationName: RepresentationType$9
-    };
-    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
-    return errorSnapshot;
-}
-function createResourceRequest$8(config) {
-    const headers = {};
-    return {
-        baseUri: '/services/data/v59.0',
-        basePath: '/learning-content-platform/learning/search/type/' + config.urlParams.contentType + '',
-        method: 'get',
-        body: null,
-        urlParams: config.urlParams,
-        queryParams: config.queryParams,
-        headers,
-        priority: 'normal',
-    };
-}
-
-const getLearningSearchResults_ConfigPropertyNames = {
-    displayName: 'getLearningSearchResults',
-    parameters: {
-        required: ['contentType', 'limit', 'q'],
-        optional: []
-    }
-};
-function createResourceParams$8(config) {
-    const resourceParams = {
-        urlParams: {
-            contentType: config.contentType
-        },
-        queryParams: {
-            limit: config.limit, q: config.q
-        }
-    };
-    return resourceParams;
-}
-function keyBuilder$k(luvio, config) {
-    const resourceParams = createResourceParams$8(config);
-    return keyBuilder$l(luvio, resourceParams);
-}
-function typeCheckConfig$8(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;
-    }
-    return config;
-}
-function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
-    if (!untrustedIsObject(untrustedConfig)) {
-        return null;
-    }
-    if (process.env.NODE_ENV !== 'production') {
-        validateConfig(untrustedConfig, configPropertyNames);
-    }
-    const config = typeCheckConfig$8(untrustedConfig);
-    if (!areRequiredParametersPresent(config, configPropertyNames)) {
-        return null;
-    }
-    return config;
-}
-function adapterFragment$7(luvio, config) {
-    createResourceParams$8(config);
-    return select$k();
-}
-function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function onFetchResponseError$7(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$7(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-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$7(luvio, config, resourceParams, response), () => getResponseCacheKeys$8(luvio, resourceParams, response.body));
-    }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$7(luvio, config, resourceParams, response));
-    });
-}
-function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$8(luvio, config, dispatchOptions);
-}
-function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
-    const { luvio, config } = context;
-    const selector = {
-        recordId: keyBuilder$k(luvio, config),
-        node: adapterFragment$7(luvio, config),
-        variables: {},
-    };
-    const cacheSnapshot = storeLookup(selector, {
-        config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
-    });
-    return cacheSnapshot;
-}
-const getLearningSearchResultsAdapterFactory = (luvio) => function LearningContentPlatform__getLearningSearchResults(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$8(untrustedConfig, getLearningSearchResults_ConfigPropertyNames);
+    const config = validateAdapterConfig$8(untrustedConfig, getFeaturedItemsRelatedList_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -5977,4 +5287,4 @@ const getTextLessonAdapterFactory = (luvio) => function LearningContentPlatform_
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
-export { evaluateLearningItemAdapterFactory, getFeaturedItemsRecommendedListAdapterFactory, getFeaturedItemsRelatedListAdapterFactory, getLearningConfigAdapterFactory, getLearningItemProgressAdapterFactory, getLearningItemsListAdapterFactory, getLearningModelAdapterFactory, getLearningPracticeAdapterFactory, getLearningSearchDescribeAdapterFactory, getLearningSearchResultsAdapterFactory, getModuleAdapterFactory, getTextLessonAdapterFactory };
+export { evaluateLearningItemAdapterFactory, getFeaturedItemsRecommendedListAdapterFactory, getFeaturedItemsRelatedListAdapterFactory, getLearningConfigAdapterFactory, getLearningItemProgressAdapterFactory, getLearningItemsListAdapterFactory, getLearningModelAdapterFactory, getLearningPracticeAdapterFactory, getModuleAdapterFactory, getTextLessonAdapterFactory };