@salesforce/lds-adapters-platform-learning-content 1.296.0 → 1.297.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, StoreKeyMap, createResourceParams as createResourceParams$c, typeCheckConfig as typeCheckConfig$c, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$a } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$d, typeCheckConfig as typeCheckConfig$d, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$a } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -112,8 +112,8 @@ function createLink(ref) {
     };
 }
 
-const VERSION$g = "1d9120ef9f750e06b6b3bd3301a1970a";
-function validate$h(obj, path = 'CoachingAIFeedbackRepresentation') {
+const VERSION$h = "1d9120ef9f750e06b6b3bd3301a1970a";
+function validate$i(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 + '")');
@@ -131,14 +131,14 @@ function validate$h(obj, path = 'CoachingAIFeedbackRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$d = 'CoachingAIFeedbackRepresentation';
-function normalize$d(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$e = 'CoachingAIFeedbackRepresentation';
+function normalize$e(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$s = function CoachingAIFeedbackRepresentationSelect() {
+const select$u = function CoachingAIFeedbackRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$g,
+        version: VERSION$h,
         private: [],
         selections: [
             {
@@ -152,7 +152,7 @@ const select$s = function CoachingAIFeedbackRepresentationSelect() {
         ]
     };
 };
-function equals$g(existing, incoming) {
+function equals$h(existing, incoming) {
     const existing_conversationSummaryId = existing.conversationSummaryId;
     const incoming_conversationSummaryId = incoming.conversationSummaryId;
     if (!(existing_conversationSummaryId === incoming_conversationSummaryId)) {
@@ -165,38 +165,38 @@ function equals$g(existing, incoming) {
     }
     return true;
 }
-const ingest$d = function CoachingAIFeedbackRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$e = function CoachingAIFeedbackRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$h(input);
+        const validateError = validate$i(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);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$e, "LearningContentPlatform", VERSION$h, RepresentationType$e, equals$h);
     return createLink(key);
 };
-function getTypeCacheKeys$d(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$e(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,
+        representationName: RepresentationType$e,
         mergeable: false
     });
 }
 
-const TTL$7 = 15000;
-const VERSION$f = "d63f1d6a2345db84136a6263f8d81080";
-function validate$g(obj, path = 'CoachingAICallSubmissionOutputRepresentation') {
+const TTL$8 = 15000;
+const VERSION$g = "d63f1d6a2345db84136a6263f8d81080";
+function validate$h(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);
+        const referencepath_coachingAIFeedbackValidationError = validate$i(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');
@@ -210,24 +210,24 @@ function validate$g(obj, path = 'CoachingAICallSubmissionOutputRepresentation')
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$c = 'CoachingAICallSubmissionOutputRepresentation';
-function keyBuilder$r(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$c + ':' + config.generation_id;
+const RepresentationType$d = 'CoachingAICallSubmissionOutputRepresentation';
+function keyBuilder$s(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$d + ':' + config.generation_id;
 }
-function keyBuilderFromType$7(luvio, object) {
+function keyBuilderFromType$8(luvio, object) {
     const keyParams = {
         generation_id: object.generationId
     };
-    return keyBuilder$r(luvio, keyParams);
+    return keyBuilder$s(luvio, keyParams);
 }
-function normalize$c(input, existing, path, luvio, store, timestamp) {
+function normalize$d(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$r = function CoachingAICallSubmissionOutputRepresentationSelect() {
-    const { selections: CoachingAIFeedbackRepresentation__selections, opaque: CoachingAIFeedbackRepresentation__opaque, } = select$s();
+const select$t = function CoachingAICallSubmissionOutputRepresentationSelect() {
+    const { selections: CoachingAIFeedbackRepresentation__selections, opaque: CoachingAIFeedbackRepresentation__opaque, } = select$u();
     return {
         kind: 'Fragment',
-        version: VERSION$f,
+        version: VERSION$g,
         private: [],
         selections: [
             {
@@ -242,7 +242,7 @@ const select$r = function CoachingAICallSubmissionOutputRepresentationSelect() {
         ]
     };
 };
-function equals$f(existing, incoming) {
+function equals$g(existing, incoming) {
     const existing_generationId = existing.generationId;
     const incoming_generationId = incoming.generationId;
     if (!(existing_generationId === incoming_generationId)) {
@@ -250,12 +250,188 @@ function equals$f(existing, incoming) {
     }
     const existing_coachingAIFeedback = existing.coachingAIFeedback;
     const incoming_coachingAIFeedback = incoming.coachingAIFeedback;
-    if (!(equals$g(existing_coachingAIFeedback, incoming_coachingAIFeedback))) {
+    if (!(equals$h(existing_coachingAIFeedback, incoming_coachingAIFeedback))) {
         return false;
     }
     return true;
 }
-const ingest$c = function CoachingAICallSubmissionOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$d = function CoachingAICallSubmissionOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$h(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$8(luvio, input);
+    const ttlToUse = TTL$8;
+    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 = keyBuilderFromType$8(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$d,
+        mergeable: false
+    });
+}
+
+function select$s(luvio, params) {
+    return select$t();
+}
+function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$d(storeKeyMap, luvio, response);
+}
+function ingestSuccess$c(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$8(luvio, body);
+    luvio.storeIngest(key, ingest$d, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$s(),
+        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$c(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v62.0',
+        basePath: '/learning-content-platform/coaching/ai-feedback',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$c = 'submitForCoachingAIFeedback';
+const submitForCoachingAIFeedback_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('callId', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('learningItemId', true, 2 /* Body */, 0 /* String */),
+];
+const submitForCoachingAIFeedback_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, submitForCoachingAIFeedback_ConfigPropertyMetadata);
+const createResourceParams$c = /*#__PURE__*/ createResourceParams$d(submitForCoachingAIFeedback_ConfigPropertyMetadata);
+function typeCheckConfig$c(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$d(untrustedConfig, config, submitForCoachingAIFeedback_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$c(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$c(luvio, config, options) {
+    const resourceParams = createResourceParams$c(config);
+    const request = createResourceRequest$c(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$c(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const submitForCoachingAIFeedbackAdapterFactory = (luvio) => {
+    return function submitForCoachingAIFeedback(untrustedConfig) {
+        const config = validateAdapterConfig$c(untrustedConfig, submitForCoachingAIFeedback_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "submitForCoachingAIFeedback"');
+        }
+        return buildNetworkSnapshot$c(luvio, config);
+    };
+};
+
+const TTL$7 = 15000;
+const VERSION$f = "9d7483cd116cf47821138a231d5d5836";
+function validate$g(obj, path = 'CoachingAIFeedbackSummaryOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_feedback = obj.feedback;
+        const path_feedback = path + '.feedback';
+        if (typeof obj_feedback !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_feedback + '" (at "' + path_feedback + '")');
+        }
+        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 = 'CoachingAIFeedbackSummaryOutputRepresentation';
+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 CoachingAIFeedbackSummaryOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$f,
+        private: [],
+        selections: [
+            {
+                name: 'feedback',
+                kind: 'Scalar'
+            },
+            {
+                name: 'generationId',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$f(existing, incoming) {
+    const existing_feedback = existing.feedback;
+    const incoming_feedback = incoming.feedback;
+    if (!(existing_feedback === incoming_feedback)) {
+        return false;
+    }
+    const existing_generationId = existing.generationId;
+    const incoming_generationId = incoming.generationId;
+    if (!(existing_generationId === incoming_generationId)) {
+        return false;
+    }
+    return true;
+}
+const ingest$c = function CoachingAIFeedbackSummaryOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$g(input);
         if (validateError !== null) {
@@ -304,7 +480,7 @@ function createResourceRequest$b(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/learning-content-platform/coaching/ai-feedback',
+        basePath: '/learning-content-platform/coaching/moments/ai-product-pitch-feedback',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -314,16 +490,23 @@ function createResourceRequest$b(config) {
     };
 }
 
-const adapterName$b = 'submitForCoachingAIFeedback';
-const submitForCoachingAIFeedback_ConfigPropertyMetadata = [
+const adapterName$b = 'submitForCoachingMomentsProductPitchFeedback';
+const submitForCoachingMomentsProductPitchFeedback_ConfigPropertyMetadata = [
     generateParamConfigMetadata('callId', true, 2 /* Body */, 0 /* String */),
-    generateParamConfigMetadata('learningItemId', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('productId', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const submitForCoachingAIFeedback_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, submitForCoachingAIFeedback_ConfigPropertyMetadata);
-const createResourceParams$b = /*#__PURE__*/ createResourceParams$c(submitForCoachingAIFeedback_ConfigPropertyMetadata);
+const submitForCoachingMomentsProductPitchFeedback_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, submitForCoachingMomentsProductPitchFeedback_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$d(submitForCoachingMomentsProductPitchFeedback_ConfigPropertyMetadata);
 function typeCheckConfig$b(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, submitForCoachingAIFeedback_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, submitForCoachingMomentsProductPitchFeedback_ConfigPropertyMetadata);
+    const untrustedConfig_productId = untrustedConfig.productId;
+    if (typeof untrustedConfig_productId === 'string') {
+        config.productId = untrustedConfig_productId;
+    }
+    if (untrustedConfig_productId === null) {
+        config.productId = untrustedConfig_productId;
+    }
     return config;
 }
 function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
@@ -357,30 +540,30 @@ function buildNetworkSnapshot$b(luvio, config, options) {
         throw response;
     });
 }
-const submitForCoachingAIFeedbackAdapterFactory = (luvio) => {
-    return function submitForCoachingAIFeedback(untrustedConfig) {
-        const config = validateAdapterConfig$b(untrustedConfig, submitForCoachingAIFeedback_ConfigPropertyNames);
+const submitForCoachingMomentsProductPitchFeedbackAdapterFactory = (luvio) => {
+    return function submitForCoachingMomentsProductPitchFeedback(untrustedConfig) {
+        const config = validateAdapterConfig$b(untrustedConfig, submitForCoachingMomentsProductPitchFeedback_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error('Invalid config for "submitForCoachingAIFeedback"');
+            throw new Error('Invalid config for "submitForCoachingMomentsProductPitchFeedback"');
         }
         return buildNetworkSnapshot$b(luvio, config);
     };
 };
 
 function select$p(luvio, params) {
-    return select$s();
+    return select$u();
 }
 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));
+    getTypeCacheKeys$e(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);
+    luvio.storeIngest(key, ingest$e, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$p(),
@@ -419,14 +602,14 @@ 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);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$d(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);
+    typeCheckConfig$d(untrustedConfig, config, getCoachingAIFeedback_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
@@ -1264,14 +1447,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$c(getFeaturedItemsRecommendedList_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$d(getFeaturedItemsRecommendedList_ConfigPropertyMetadata);
 function keyBuilder$m(luvio, config) {
     const resourceParams = createResourceParams$9(config);
     return keyBuilder$n(luvio, resourceParams);
 }
 function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getFeaturedItemsRecommendedList_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getFeaturedItemsRecommendedList_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
@@ -1493,14 +1676,14 @@ const getFeaturedItemsRelatedList_ConfigPropertyMetadata = [
     generateParamConfigMetadata('returnMax', false, 1 /* QueryParameter */, 1 /* Boolean */),
 ];
 const getFeaturedItemsRelatedList_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getFeaturedItemsRelatedList_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$c(getFeaturedItemsRelatedList_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$d(getFeaturedItemsRelatedList_ConfigPropertyMetadata);
 function keyBuilder$k(luvio, config) {
     const resourceParams = createResourceParams$8(config);
     return keyBuilder$l(luvio, resourceParams);
 }
 function typeCheckConfig$8(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getFeaturedItemsRelatedList_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getFeaturedItemsRelatedList_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
@@ -1712,7 +1895,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$c(getLearningConfig_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$d(getLearningConfig_ConfigPropertyMetadata);
 function keyBuilder$i(luvio, config) {
     createResourceParams$7(config);
     return keyBuilder$j();
@@ -2404,14 +2587,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$c(getLearningItemsList_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$d(getLearningItemsList_ConfigPropertyMetadata);
 function keyBuilder$f(luvio, config) {
     const resourceParams = createResourceParams$6(config);
     return keyBuilder$g(luvio, resourceParams);
 }
 function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getLearningItemsList_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getLearningItemsList_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
@@ -2800,14 +2983,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$c(getLearningItemProgress_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$d(getLearningItemProgress_ConfigPropertyMetadata);
 function keyBuilder$c(luvio, config) {
     const resourceParams = createResourceParams$5(config);
     return keyBuilder$d(luvio, resourceParams);
 }
 function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getLearningItemProgress_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getLearningItemProgress_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
@@ -3743,14 +3926,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$c(getLearningModel_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$d(getLearningModel_ConfigPropertyMetadata);
 function keyBuilder$9(luvio, config) {
     const resourceParams = createResourceParams$4(config);
     return keyBuilder$a(luvio, resourceParams);
 }
 function typeCheckConfig$4(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getLearningModel_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getLearningModel_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
@@ -4435,14 +4618,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$c(getModule_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$d(getModule_ConfigPropertyMetadata);
 function keyBuilder$6(luvio, config) {
     const resourceParams = createResourceParams$3(config);
     return keyBuilder$7(luvio, resourceParams);
 }
 function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getModule_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getModule_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
@@ -4744,14 +4927,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$c(getLearningPractice_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$d(getLearningPractice_ConfigPropertyMetadata);
 function keyBuilder$3(luvio, config) {
     const resourceParams = createResourceParams$2(config);
     return keyBuilder$4(luvio, resourceParams);
 }
 function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getLearningPractice_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getLearningPractice_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
@@ -4897,7 +5080,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$c(evaluateLearningItem_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$d(evaluateLearningItem_ConfigPropertyMetadata);
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
     const untrustedConfig_payload = untrustedConfig.payload;
@@ -5244,14 +5427,14 @@ const getTextLesson_ConfigPropertyMetadata = [
     generateParamConfigMetadata('learningItemId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getTextLesson_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getTextLesson_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$c(getTextLesson_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$d(getTextLesson_ConfigPropertyMetadata);
 function keyBuilder(luvio, config) {
     const resourceParams = createResourceParams(config);
     return keyBuilder$1(luvio, resourceParams);
 }
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$c(untrustedConfig, config, getTextLesson_ConfigPropertyMetadata);
+    typeCheckConfig$d(untrustedConfig, config, getTextLesson_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig(untrustedConfig, configPropertyNames) {
@@ -5325,4 +5508,4 @@ const getTextLessonAdapterFactory = (luvio) => function LearningContentPlatform_
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
-export { evaluateLearningItemAdapterFactory, getCoachingAIFeedbackAdapterFactory, getFeaturedItemsRecommendedListAdapterFactory, getFeaturedItemsRelatedListAdapterFactory, getLearningConfigAdapterFactory, getLearningItemProgressAdapterFactory, getLearningItemsListAdapterFactory, getLearningModelAdapterFactory, getLearningPracticeAdapterFactory, getModuleAdapterFactory, getTextLessonAdapterFactory, notifyUpdateAvailableFactory$1 as notifyLearningItemProgressUpdateAvailableFactory, notifyUpdateAvailableFactory$2 as notifyLearningItemUpdateAvailableFactory, notifyUpdateAvailableFactory as notifyLearningTextLessonUpdateAvailableFactory, submitForCoachingAIFeedbackAdapterFactory };
+export { evaluateLearningItemAdapterFactory, getCoachingAIFeedbackAdapterFactory, getFeaturedItemsRecommendedListAdapterFactory, getFeaturedItemsRelatedListAdapterFactory, getLearningConfigAdapterFactory, getLearningItemProgressAdapterFactory, getLearningItemsListAdapterFactory, getLearningModelAdapterFactory, getLearningPracticeAdapterFactory, getModuleAdapterFactory, getTextLessonAdapterFactory, notifyUpdateAvailableFactory$1 as notifyLearningItemProgressUpdateAvailableFactory, notifyUpdateAvailableFactory$2 as notifyLearningItemUpdateAvailableFactory, notifyUpdateAvailableFactory as notifyLearningTextLessonUpdateAvailableFactory, submitForCoachingAIFeedbackAdapterFactory, submitForCoachingMomentsProductPitchFeedbackAdapterFactory };

package/dist/es/es2018/types/src/generated/adapters/submitForCoachingMomentsProductPitchFeedback.d.ts

@@ -0,0 +1,16 @@
+import { AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata, Luvio as $64$luvio_engine_Luvio, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import { Untrusted as adapter$45$utils_Untrusted, AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig } from './adapter-utils';
+import { ResourceRequestConfig as resources_postLearningContentPlatformCoachingMomentsAiProductPitchFeedback_ResourceRequestConfig } from '../resources/postLearningContentPlatformCoachingMomentsAiProductPitchFeedback';
+import { CoachingAIFeedbackSummaryOutputRepresentation as types_CoachingAIFeedbackSummaryOutputRepresentation_CoachingAIFeedbackSummaryOutputRepresentation } from '../types/CoachingAIFeedbackSummaryOutputRepresentation';
+export declare const adapterName = "submitForCoachingMomentsProductPitchFeedback";
+export declare const submitForCoachingMomentsProductPitchFeedback_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const submitForCoachingMomentsProductPitchFeedback_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface SubmitForCoachingMomentsProductPitchFeedbackConfig {
+    callId: string;
+    productId: string | null;
+}
+export declare const createResourceParams: (config: SubmitForCoachingMomentsProductPitchFeedbackConfig) => resources_postLearningContentPlatformCoachingMomentsAiProductPitchFeedback_ResourceRequestConfig;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<SubmitForCoachingMomentsProductPitchFeedbackConfig>): adapter$45$utils_Untrusted<SubmitForCoachingMomentsProductPitchFeedbackConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): SubmitForCoachingMomentsProductPitchFeedbackConfig | null;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: SubmitForCoachingMomentsProductPitchFeedbackConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<import("@luvio/engine").FulfilledSnapshot<types_CoachingAIFeedbackSummaryOutputRepresentation_CoachingAIFeedbackSummaryOutputRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_CoachingAIFeedbackSummaryOutputRepresentation_CoachingAIFeedbackSummaryOutputRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_CoachingAIFeedbackSummaryOutputRepresentation_CoachingAIFeedbackSummaryOutputRepresentation, any>>;
+export declare const submitForCoachingMomentsProductPitchFeedbackAdapterFactory: $64$luvio_engine_AdapterFactory<SubmitForCoachingMomentsProductPitchFeedbackConfig, types_CoachingAIFeedbackSummaryOutputRepresentation_CoachingAIFeedbackSummaryOutputRepresentation>;

package/dist/es/es2018/types/src/generated/artifacts/main.d.ts

@@ -1,4 +1,5 @@
 export { submitForCoachingAIFeedbackAdapterFactory } from '../adapters/submitForCoachingAIFeedback';
+export { submitForCoachingMomentsProductPitchFeedbackAdapterFactory } from '../adapters/submitForCoachingMomentsProductPitchFeedback';
 export { getCoachingAIFeedbackAdapterFactory } from '../adapters/getCoachingAIFeedback';
 export { getFeaturedItemsRecommendedListAdapterFactory } from '../adapters/getFeaturedItemsRecommendedList';
 export { getFeaturedItemsRelatedListAdapterFactory } from '../adapters/getFeaturedItemsRelatedList';

package/dist/es/es2018/types/src/generated/artifacts/sfdc.d.ts

@@ -13,6 +13,7 @@ declare let getModuleNotifyChange: any;
 declare let getTextLesson: any;
 declare let getTextLessonNotifyChange: any;
 declare let submitForCoachingAIFeedback: any;
+declare let submitForCoachingMomentsProductPitchFeedback: any;
 declare let getCoachingAIFeedback_imperative: any;
 declare let getFeaturedItemsRecommendedList_imperative: any;
 declare let getFeaturedItemsRelatedList_imperative: any;
@@ -26,5 +27,5 @@ declare let getTextLesson_imperative: any;
 declare let notifyLearningItemProgressUpdateAvailable: any;
 declare let notifyLearningItemUpdateAvailable: any;
 declare let notifyLearningTextLessonUpdateAvailable: any;
-export { evaluateLearningItem, getCoachingAIFeedback, getFeaturedItemsRecommendedList, getFeaturedItemsRelatedList, getLearningConfig, getLearningItemProgress, getLearningItemsList, getLearningModel, getLearningPractice, getLearningPracticeNotifyChange, getModule, getModuleNotifyChange, getTextLesson, getTextLessonNotifyChange, submitForCoachingAIFeedback, getCoachingAIFeedback_imperative, getFeaturedItemsRecommendedList_imperative, getFeaturedItemsRelatedList_imperative, getLearningConfig_imperative, getLearningItemProgress_imperative, getLearningItemsList_imperative, getLearningModel_imperative, getLearningPractice_imperative, getModule_imperative, getTextLesson_imperative, };
+export { evaluateLearningItem, getCoachingAIFeedback, getFeaturedItemsRecommendedList, getFeaturedItemsRelatedList, getLearningConfig, getLearningItemProgress, getLearningItemsList, getLearningModel, getLearningPractice, getLearningPracticeNotifyChange, getModule, getModuleNotifyChange, getTextLesson, getTextLessonNotifyChange, submitForCoachingAIFeedback, submitForCoachingMomentsProductPitchFeedback, getCoachingAIFeedback_imperative, getFeaturedItemsRecommendedList_imperative, getFeaturedItemsRelatedList_imperative, getLearningConfig_imperative, getLearningItemProgress_imperative, getLearningItemsList_imperative, getLearningModel_imperative, getLearningPractice_imperative, getModule_imperative, getTextLesson_imperative, };
 export { notifyLearningItemProgressUpdateAvailable, notifyLearningItemUpdateAvailable, notifyLearningTextLessonUpdateAvailable, };

package/dist/es/es2018/types/src/generated/resources/postLearningContentPlatformCoachingMomentsAiProductPitchFeedback.d.ts

@@ -0,0 +1,13 @@
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, FetchResponse as $64$luvio_engine_FetchResponse, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { CoachingAIFeedbackSummaryOutputRepresentation as types_CoachingAIFeedbackSummaryOutputRepresentation_CoachingAIFeedbackSummaryOutputRepresentation } from '../types/CoachingAIFeedbackSummaryOutputRepresentation';
+export interface ResourceRequestConfig {
+    body: {
+        callId: string;
+        productId: string | null;
+    };
+}
+export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function getResponseCacheKeys(storeKeyMap: any, luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_CoachingAIFeedbackSummaryOutputRepresentation_CoachingAIFeedbackSummaryOutputRepresentation): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_CoachingAIFeedbackSummaryOutputRepresentation_CoachingAIFeedbackSummaryOutputRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_CoachingAIFeedbackSummaryOutputRepresentation_CoachingAIFeedbackSummaryOutputRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_CoachingAIFeedbackSummaryOutputRepresentation_CoachingAIFeedbackSummaryOutputRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_CoachingAIFeedbackSummaryOutputRepresentation_CoachingAIFeedbackSummaryOutputRepresentation, any>;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;