@salesforce/lds-adapters-platform-learning-content 1.274.0 → 1.275.0

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

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$9, typeCheckConfig as typeCheckConfig$a, StoreKeyMap, createResourceParams as createResourceParams$a } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$c, typeCheckConfig as typeCheckConfig$c, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$a } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -112,6 +112,495 @@ function createLink(ref) {
     };
 }
 
+const VERSION$h = "7877f5d0382a35ed103b8a91ff54fa47";
+function validate$i(obj, path = 'CoachingAICriteriaBasedFeedbackRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_criteriaName = obj.criteriaName;
+        const path_criteriaName = path + '.criteriaName';
+        if (typeof obj_criteriaName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_criteriaName + '" (at "' + path_criteriaName + '")');
+        }
+        obj.criteriaScore;
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$t = function CoachingAICriteriaBasedFeedbackRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$h,
+        private: [],
+        selections: [
+            {
+                name: 'criteriaName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'criteriaScore',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$h(existing, incoming) {
+    const existing_criteriaName = existing.criteriaName;
+    const incoming_criteriaName = incoming.criteriaName;
+    if (!(existing_criteriaName === incoming_criteriaName)) {
+        return false;
+    }
+    const existing_criteriaScore = existing.criteriaScore;
+    const incoming_criteriaScore = incoming.criteriaScore;
+    if (!(existing_criteriaScore === incoming_criteriaScore)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$g = "ce799f65b2acf684ff815d1c883d123e";
+function validate$h(obj, path = 'CoachingAIFeedbackRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_additionalFeedback = obj.additionalFeedback;
+        const path_additionalFeedback = path + '.additionalFeedback';
+        if (!ArrayIsArray(obj_additionalFeedback)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_additionalFeedback + '" (at "' + path_additionalFeedback + '")');
+        }
+        for (let i = 0; i < obj_additionalFeedback.length; i++) {
+            const obj_additionalFeedback_item = obj_additionalFeedback[i];
+            const path_additionalFeedback_item = path_additionalFeedback + '[' + i + ']';
+            if (obj_additionalFeedback_item === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_additionalFeedback_item + '" (at "' + path_additionalFeedback_item + '")');
+            }
+        }
+        const obj_conversationSummaryId = obj.conversationSummaryId;
+        const path_conversationSummaryId = path + '.conversationSummaryId';
+        if (typeof obj_conversationSummaryId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_conversationSummaryId + '" (at "' + path_conversationSummaryId + '")');
+        }
+        const obj_criteriaBasedScores = obj.criteriaBasedScores;
+        const path_criteriaBasedScores = path + '.criteriaBasedScores';
+        if (!ArrayIsArray(obj_criteriaBasedScores)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_criteriaBasedScores + '" (at "' + path_criteriaBasedScores + '")');
+        }
+        for (let i = 0; i < obj_criteriaBasedScores.length; i++) {
+            const obj_criteriaBasedScores_item = obj_criteriaBasedScores[i];
+            const path_criteriaBasedScores_item = path_criteriaBasedScores + '[' + i + ']';
+            const referencepath_criteriaBasedScores_itemValidationError = validate$i(obj_criteriaBasedScores_item, path_criteriaBasedScores_item);
+            if (referencepath_criteriaBasedScores_itemValidationError !== null) {
+                let message = 'Object doesn\'t match CoachingAICriteriaBasedFeedbackRepresentation (at "' + path_criteriaBasedScores_item + '")\n';
+                message += referencepath_criteriaBasedScores_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        obj.score;
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$d = 'CoachingAIFeedbackRepresentation';
+function normalize$d(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$s = function CoachingAIFeedbackRepresentationSelect() {
+    const { selections: CoachingAICriteriaBasedFeedbackRepresentation__selections, opaque: CoachingAICriteriaBasedFeedbackRepresentation__opaque, } = select$t();
+    return {
+        kind: 'Fragment',
+        version: VERSION$g,
+        private: [],
+        selections: [
+            {
+                name: 'additionalFeedback',
+                kind: 'Object',
+                // any
+            },
+            {
+                name: 'conversationSummaryId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'criteriaBasedScores',
+                kind: 'Object',
+                plural: true,
+                selections: CoachingAICriteriaBasedFeedbackRepresentation__selections
+            },
+            {
+                name: 'score',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$g(existing, incoming) {
+    const existing_conversationSummaryId = existing.conversationSummaryId;
+    const incoming_conversationSummaryId = incoming.conversationSummaryId;
+    if (!(existing_conversationSummaryId === incoming_conversationSummaryId)) {
+        return false;
+    }
+    const existing_score = existing.score;
+    const incoming_score = incoming.score;
+    if (!(existing_score === incoming_score)) {
+        return false;
+    }
+    const existing_additionalFeedback = existing.additionalFeedback;
+    const incoming_additionalFeedback = incoming.additionalFeedback;
+    const equals_additionalFeedback_items = equalsArray(existing_additionalFeedback, incoming_additionalFeedback, (existing_additionalFeedback_item, incoming_additionalFeedback_item) => {
+        if (JSONStringify(incoming_additionalFeedback_item) !== JSONStringify(existing_additionalFeedback_item)) {
+            return false;
+        }
+    });
+    if (equals_additionalFeedback_items === false) {
+        return false;
+    }
+    const existing_criteriaBasedScores = existing.criteriaBasedScores;
+    const incoming_criteriaBasedScores = incoming.criteriaBasedScores;
+    const equals_criteriaBasedScores_items = equalsArray(existing_criteriaBasedScores, incoming_criteriaBasedScores, (existing_criteriaBasedScores_item, incoming_criteriaBasedScores_item) => {
+        if (!(equals$h(existing_criteriaBasedScores_item, incoming_criteriaBasedScores_item))) {
+            return false;
+        }
+    });
+    if (equals_criteriaBasedScores_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$d = function CoachingAIFeedbackRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$h(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$d, "LearningContentPlatform", VERSION$g, RepresentationType$d, equals$g);
+    return createLink(key);
+};
+function getTypeCacheKeys$d(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$d,
+        mergeable: false
+    });
+}
+
+const TTL$7 = 15000;
+const VERSION$f = "d63f1d6a2345db84136a6263f8d81080";
+function validate$g(obj, path = 'CoachingAICallSubmissionOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_coachingAIFeedback = obj.coachingAIFeedback;
+        const path_coachingAIFeedback = path + '.coachingAIFeedback';
+        const referencepath_coachingAIFeedbackValidationError = validate$h(obj_coachingAIFeedback, path_coachingAIFeedback);
+        if (referencepath_coachingAIFeedbackValidationError !== null) {
+            let message = 'Object doesn\'t match CoachingAIFeedbackRepresentation (at "' + path_coachingAIFeedback + '")\n';
+            message += referencepath_coachingAIFeedbackValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_generationId = obj.generationId;
+        const path_generationId = path + '.generationId';
+        if (typeof obj_generationId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_generationId + '" (at "' + path_generationId + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$c = 'CoachingAICallSubmissionOutputRepresentation';
+function keyBuilder$r(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$c + ':' + config.generation_id;
+}
+function keyBuilderFromType$7(luvio, object) {
+    const keyParams = {
+        generation_id: object.generationId
+    };
+    return keyBuilder$r(luvio, keyParams);
+}
+function normalize$c(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$r = function CoachingAICallSubmissionOutputRepresentationSelect() {
+    const { selections: CoachingAIFeedbackRepresentation__selections, opaque: CoachingAIFeedbackRepresentation__opaque, } = select$s();
+    return {
+        kind: 'Fragment',
+        version: VERSION$f,
+        private: [],
+        selections: [
+            {
+                name: 'coachingAIFeedback',
+                kind: 'Object',
+                selections: CoachingAIFeedbackRepresentation__selections
+            },
+            {
+                name: 'generationId',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$f(existing, incoming) {
+    const existing_generationId = existing.generationId;
+    const incoming_generationId = incoming.generationId;
+    if (!(existing_generationId === incoming_generationId)) {
+        return false;
+    }
+    const existing_coachingAIFeedback = existing.coachingAIFeedback;
+    const incoming_coachingAIFeedback = incoming.coachingAIFeedback;
+    if (!(equals$g(existing_coachingAIFeedback, incoming_coachingAIFeedback))) {
+        return false;
+    }
+    return true;
+}
+const ingest$c = function CoachingAICallSubmissionOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$g(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$7(luvio, input);
+    const ttlToUse = TTL$7;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$c, "LearningContentPlatform", VERSION$f, RepresentationType$c, equals$f);
+    return createLink(key);
+};
+function getTypeCacheKeys$c(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$7(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$c,
+        mergeable: false
+    });
+}
+
+function select$q(luvio, params) {
+    return select$r();
+}
+function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$c(storeKeyMap, luvio, response);
+}
+function ingestSuccess$b(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$7(luvio, body);
+    luvio.storeIngest(key, ingest$c, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$q(),
+        variables: {},
+    });
+    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 createResourceRequest$b(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v61.0',
+        basePath: '/learning-content-platform/coaching/ai-feedback',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$b = 'submitForCoachingAIFeedback';
+const submitForCoachingAIFeedback_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('callId', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('learningItemId', true, 2 /* Body */, 0 /* String */),
+];
+const submitForCoachingAIFeedback_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, submitForCoachingAIFeedback_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$c(submitForCoachingAIFeedback_ConfigPropertyMetadata);
+function typeCheckConfig$b(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$c(untrustedConfig, config, submitForCoachingAIFeedback_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$b(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);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$b(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$b(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const submitForCoachingAIFeedbackAdapterFactory = (luvio) => {
+    return function submitForCoachingAIFeedback(untrustedConfig) {
+        const config = validateAdapterConfig$b(untrustedConfig, submitForCoachingAIFeedback_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "submitForCoachingAIFeedback"');
+        }
+        return buildNetworkSnapshot$b(luvio, config);
+    };
+};
+
+function select$p(luvio, params) {
+    return select$s();
+}
+function keyBuilder$q(luvio, params) {
+    return keyPrefix + '::CoachingAIFeedbackRepresentation:(' + 'learningItemSubmissionId:' + params.urlParams.learningItemSubmissionId + ')';
+}
+function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$d(storeKeyMap, luvio, response, () => keyBuilder$q(luvio, resourceParams));
+}
+function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$q(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$d, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$p(),
+        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$9(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$q(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$a(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v61.0',
+        basePath: '/learning-content-platform/coaching/' + config.urlParams.learningItemSubmissionId + '/ai-feedback',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$a = 'getCoachingAIFeedback';
+const getCoachingAIFeedback_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('learningItemSubmissionId', true, 0 /* UrlParameter */, 0 /* String */),
+];
+const getCoachingAIFeedback_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, getCoachingAIFeedback_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$c(getCoachingAIFeedback_ConfigPropertyMetadata);
+function keyBuilder$p(luvio, config) {
+    const resourceParams = createResourceParams$a(config);
+    return keyBuilder$q(luvio, resourceParams);
+}
+function typeCheckConfig$a(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$c(untrustedConfig, config, getCoachingAIFeedback_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$a(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$9(luvio, config) {
+    createResourceParams$a(config);
+    return select$p();
+}
+function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$9(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$9(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$a(luvio, config, options) {
+    const resourceParams = createResourceParams$a(config);
+    const request = createResourceRequest$a(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$9(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$9(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$a, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$p(luvio, config),
+        node: adapterFragment$9(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getCoachingAIFeedbackAdapterFactory = (luvio) => function LearningContentPlatform__getCoachingAIFeedback(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$a(untrustedConfig, getCoachingAIFeedback_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$9, buildNetworkSnapshotCachePolicy$9);
+};
+
 const TTL$6 = 15000;
 const VERSION$e = "b489f9f2cbdc91a04dd15b4d467b6760";
 function validate$f(obj, path = 'FeaturedItemRepresentation') {
@@ -876,14 +1365,14 @@ const getFeaturedItemsRecommendedList_ConfigPropertyMetadata = [
     generateParamConfigMetadata('context', true, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getFeaturedItemsRecommendedList_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getFeaturedItemsRecommendedList_ConfigPropertyMetadata);
-const createResourceParams$9 = /*#__PURE__*/ createResourceParams$a(getFeaturedItemsRecommendedList_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$c(getFeaturedItemsRecommendedList_ConfigPropertyMetadata);
 function keyBuilder$m(luvio, config) {
     const resourceParams = createResourceParams$9(config);
     return keyBuilder$n(luvio, resourceParams);
 }
 function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$a(untrustedConfig, config, getFeaturedItemsRecommendedList_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getFeaturedItemsRecommendedList_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
@@ -932,7 +1421,7 @@ function buildNetworkSnapshot$9(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
@@ -1056,7 +1545,7 @@ function select$k(luvio, params) {
     return select$l();
 }
 function keyBuilder$l(luvio, params) {
-    return keyPrefix + '::FeaturedItemRelatedListRepresentation:(' + 'appId:' + params.queryParams.appId + ',' + 'pageRef:' + params.queryParams.pageRef + ')';
+    return keyPrefix + '::FeaturedItemRelatedListRepresentation:(' + 'appId:' + params.queryParams.appId + ',' + 'pageRef:' + params.queryParams.pageRef + ',' + 'returnMax:' + params.queryParams.returnMax + ')';
 }
 function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$9(storeKeyMap, luvio, response, () => keyBuilder$l(luvio, resourceParams));
@@ -1102,16 +1591,17 @@ const adapterName$8 = 'getFeaturedItemsRelatedList';
 const getFeaturedItemsRelatedList_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appId', true, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('pageRef', true, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('returnMax', false, 1 /* QueryParameter */, 1 /* Boolean */),
 ];
 const getFeaturedItemsRelatedList_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getFeaturedItemsRelatedList_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$a(getFeaturedItemsRelatedList_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$c(getFeaturedItemsRelatedList_ConfigPropertyMetadata);
 function keyBuilder$k(luvio, config) {
     const resourceParams = createResourceParams$8(config);
     return keyBuilder$l(luvio, resourceParams);
 }
 function typeCheckConfig$8(untrustedConfig) {
     const config = {};
-    typeCheckConfig$a(untrustedConfig, config, getFeaturedItemsRelatedList_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getFeaturedItemsRelatedList_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
@@ -1160,7 +1650,7 @@ function buildNetworkSnapshot$8(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
@@ -1323,7 +1813,7 @@ function createResourceRequest$7(config) {
 const adapterName$7 = 'getLearningConfig';
 const getLearningConfig_ConfigPropertyMetadata = [];
 const getLearningConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getLearningConfig_ConfigPropertyMetadata);
-const createResourceParams$7 = /*#__PURE__*/ createResourceParams$a(getLearningConfig_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$c(getLearningConfig_ConfigPropertyMetadata);
 function keyBuilder$i(luvio, config) {
     createResourceParams$7(config);
     return keyBuilder$j();
@@ -1378,7 +1868,7 @@ function buildNetworkSnapshot$7(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
@@ -2015,14 +2505,14 @@ const getLearningItemsList_ConfigPropertyMetadata = [
     generateParamConfigMetadata('learningItemIds', false, 1 /* QueryParameter */, 0 /* String */, true),
 ];
 const getLearningItemsList_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getLearningItemsList_ConfigPropertyMetadata);
-const createResourceParams$6 = /*#__PURE__*/ createResourceParams$a(getLearningItemsList_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$c(getLearningItemsList_ConfigPropertyMetadata);
 function keyBuilder$f(luvio, config) {
     const resourceParams = createResourceParams$6(config);
     return keyBuilder$g(luvio, resourceParams);
 }
 function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$a(untrustedConfig, config, getLearningItemsList_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getLearningItemsList_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
@@ -2071,7 +2561,7 @@ function buildNetworkSnapshot$6(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
@@ -2411,14 +2901,14 @@ const getLearningItemProgress_ConfigPropertyMetadata = [
     generateParamConfigMetadata('learningItemIds', false, 1 /* QueryParameter */, 0 /* String */, true),
 ];
 const getLearningItemProgress_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getLearningItemProgress_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$a(getLearningItemProgress_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$c(getLearningItemProgress_ConfigPropertyMetadata);
 function keyBuilder$c(luvio, config) {
     const resourceParams = createResourceParams$5(config);
     return keyBuilder$d(luvio, resourceParams);
 }
 function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$a(untrustedConfig, config, getLearningItemProgress_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getLearningItemProgress_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
@@ -2467,7 +2957,7 @@ function buildNetworkSnapshot$5(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
@@ -3354,14 +3844,14 @@ const getLearningModel_ConfigPropertyMetadata = [
     generateParamConfigMetadata('learningItemId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getLearningModel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getLearningModel_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$a(getLearningModel_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$c(getLearningModel_ConfigPropertyMetadata);
 function keyBuilder$9(luvio, config) {
     const resourceParams = createResourceParams$4(config);
     return keyBuilder$a(luvio, resourceParams);
 }
 function typeCheckConfig$4(untrustedConfig) {
     const config = {};
-    typeCheckConfig$a(untrustedConfig, config, getLearningModel_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getLearningModel_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
@@ -3410,7 +3900,7 @@ function buildNetworkSnapshot$4(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
@@ -4046,14 +4536,14 @@ const getModule_ConfigPropertyMetadata = [
     generateParamConfigMetadata('moduleId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getModule_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getModule_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$a(getModule_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$c(getModule_ConfigPropertyMetadata);
 function keyBuilder$6(luvio, config) {
     const resourceParams = createResourceParams$3(config);
     return keyBuilder$7(luvio, resourceParams);
 }
 function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$a(untrustedConfig, config, getModule_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getModule_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
@@ -4102,7 +4592,7 @@ function buildNetworkSnapshot$3(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
@@ -4313,14 +4803,14 @@ const getLearningPractice_ConfigPropertyMetadata = [
     generateParamConfigMetadata('learningItemId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getLearningPractice_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getLearningPractice_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$a(getLearningPractice_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$c(getLearningPractice_ConfigPropertyMetadata);
 function keyBuilder$3(luvio, config) {
     const resourceParams = createResourceParams$2(config);
     return keyBuilder$4(luvio, resourceParams);
 }
 function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$a(untrustedConfig, config, getLearningPractice_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getLearningPractice_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
@@ -4369,7 +4859,7 @@ function buildNetworkSnapshot$2(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { luvio, config } = context;
@@ -4466,7 +4956,7 @@ const evaluateLearningItem_ConfigPropertyMetadata = [
     generateParamConfigMetadata('payload', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const evaluateLearningItem_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, evaluateLearningItem_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$a(evaluateLearningItem_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$c(evaluateLearningItem_ConfigPropertyMetadata);
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
     const untrustedConfig_payload = untrustedConfig.payload;
@@ -4813,14 +5303,14 @@ const getTextLesson_ConfigPropertyMetadata = [
     generateParamConfigMetadata('learningItemId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getTextLesson_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getTextLesson_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$a(getTextLesson_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$c(getTextLesson_ConfigPropertyMetadata);
 function keyBuilder(luvio, config) {
     const resourceParams = createResourceParams(config);
     return keyBuilder$1(luvio, resourceParams);
 }
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$a(untrustedConfig, config, getTextLesson_ConfigPropertyMetadata);
+    typeCheckConfig$c(untrustedConfig, config, getTextLesson_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig(untrustedConfig, configPropertyNames) {
@@ -4869,7 +5359,7 @@ function buildNetworkSnapshot(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
@@ -4894,4 +5384,4 @@ const getTextLessonAdapterFactory = (luvio) => function LearningContentPlatform_
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
-export { evaluateLearningItemAdapterFactory, getFeaturedItemsRecommendedListAdapterFactory, getFeaturedItemsRelatedListAdapterFactory, getLearningConfigAdapterFactory, getLearningItemProgressAdapterFactory, getLearningItemsListAdapterFactory, getLearningModelAdapterFactory, getLearningPracticeAdapterFactory, getModuleAdapterFactory, getTextLessonAdapterFactory, notifyUpdateAvailableFactory$1 as notifyLearningItemProgressUpdateAvailableFactory, notifyUpdateAvailableFactory$2 as notifyLearningItemUpdateAvailableFactory, notifyUpdateAvailableFactory as notifyLearningTextLessonUpdateAvailableFactory };
+export { evaluateLearningItemAdapterFactory, getCoachingAIFeedbackAdapterFactory, getFeaturedItemsRecommendedListAdapterFactory, getFeaturedItemsRelatedListAdapterFactory, getLearningConfigAdapterFactory, getLearningItemProgressAdapterFactory, getLearningItemsListAdapterFactory, getLearningModelAdapterFactory, getLearningPracticeAdapterFactory, getModuleAdapterFactory, getTextLessonAdapterFactory, notifyUpdateAvailableFactory$1 as notifyLearningItemProgressUpdateAvailableFactory, notifyUpdateAvailableFactory$2 as notifyLearningItemUpdateAvailableFactory, notifyUpdateAvailableFactory as notifyLearningTextLessonUpdateAvailableFactory, submitForCoachingAIFeedbackAdapterFactory };