@salesforce/lds-adapters-industries-education 1.364.0 → 1.366.0

package/dist/es/es2018/industries-education.js

@@ -173,7 +173,7 @@ var DiscriminatorValues;
     DiscriminatorValues["LearningCourse"] = "LearningCourse";
     DiscriminatorValues["LearningProgram"] = "LearningProgram";
 })(DiscriminatorValues || (DiscriminatorValues = {}));
-function validate$1g(obj, path = 'LearningOutput') {
+function validate$1h(obj, path = 'LearningOutput') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -267,7 +267,7 @@ function validate$1g(obj, path = 'LearningOutput') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$1f(obj, path = 'LearningOutcomeItemOutput') {
+function validate$1g(obj, path = 'LearningOutcomeItemOutput') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -331,6 +331,36 @@ function validate$1f(obj, path = 'LearningOutcomeItemOutput') {
     return v_error === undefined ? null : v_error;
 }
 
+function validate$1f(obj, path = 'LearningEquivalency') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.equivalencyId !== undefined) {
+            const obj_equivalencyId = obj.equivalencyId;
+            const path_equivalencyId = path + '.equivalencyId';
+            if (typeof obj_equivalencyId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_equivalencyId + '" (at "' + path_equivalencyId + '")');
+            }
+        }
+        if (obj.equivalencyName !== undefined) {
+            const obj_equivalencyName = obj.equivalencyName;
+            const path_equivalencyName = path + '.equivalencyName';
+            if (typeof obj_equivalencyName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_equivalencyName + '" (at "' + path_equivalencyName + '")');
+            }
+        }
+        if (obj.typeLabel !== undefined) {
+            const obj_typeLabel = obj.typeLabel;
+            const path_typeLabel = path + '.typeLabel';
+            if (typeof obj_typeLabel !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_typeLabel + '" (at "' + path_typeLabel + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
 function validate$1e(obj, path = 'LearningStatus') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -378,6 +408,21 @@ function validate$1e(obj, path = 'LearningStatus') {
                 return new TypeError('Expected "string" but received "' + typeof obj_durationUnit + '" (at "' + path_durationUnit + '")');
             }
         }
+        const obj_equivalency = obj.equivalency;
+        const path_equivalency = path + '.equivalency';
+        if (!ArrayIsArray(obj_equivalency)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_equivalency + '" (at "' + path_equivalency + '")');
+        }
+        for (let i = 0; i < obj_equivalency.length; i++) {
+            const obj_equivalency_item = obj_equivalency[i];
+            const path_equivalency_item = path_equivalency + '[' + i + ']';
+            const referencepath_equivalency_itemValidationError = validate$1f(obj_equivalency_item, path_equivalency_item);
+            if (referencepath_equivalency_itemValidationError !== null) {
+                let message = 'Object doesn\'t match LearningEquivalency (at "' + path_equivalency_item + '")\n';
+                message += referencepath_equivalency_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
         if (obj.learningId !== undefined) {
             const obj_learningId = obj.learningId;
             const path_learningId = path + '.learningId';
@@ -448,7 +493,7 @@ function validate$1d(obj, path = 'LearningFulfiller') {
         if (obj.learning !== undefined) {
             const obj_learning = obj.learning;
             const path_learning = path + '.learning';
-            const referencepath_learningValidationError = validate$1g(obj_learning, path_learning);
+            const referencepath_learningValidationError = validate$1h(obj_learning, path_learning);
             if (referencepath_learningValidationError !== null) {
                 let message = 'Object doesn\'t match LearningOutput (at "' + path_learning + '")\n';
                 message += referencepath_learningValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -458,7 +503,7 @@ function validate$1d(obj, path = 'LearningFulfiller') {
         if (obj.learningOutcomeItem !== undefined) {
             const obj_learningOutcomeItem = obj.learningOutcomeItem;
             const path_learningOutcomeItem = path + '.learningOutcomeItem';
-            const referencepath_learningOutcomeItemValidationError = validate$1f(obj_learningOutcomeItem, path_learningOutcomeItem);
+            const referencepath_learningOutcomeItemValidationError = validate$1g(obj_learningOutcomeItem, path_learningOutcomeItem);
             if (referencepath_learningOutcomeItemValidationError !== null) {
                 let message = 'Object doesn\'t match LearningOutcomeItemOutput (at "' + path_learningOutcomeItem + '")\n';
                 message += referencepath_learningOutcomeItemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -657,7 +702,7 @@ function validate$1a(obj, path = 'LearningPolicyRuleOutput') {
     return v_error === undefined ? null : v_error;
 }
 
-const VERSION$C = "9b0ee223b5d04bad05ae8dc9a29ceefd";
+const VERSION$C = "00d976655763261f8c025fa68734a565";
 function validate$19(obj, path = 'GetLearningOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -700,7 +745,7 @@ function validate$19(obj, path = 'GetLearningOutputRepresentation') {
         if (obj.learning !== undefined) {
             const obj_learning = obj.learning;
             const path_learning = path + '.learning';
-            const referencepath_learningValidationError = validate$1g(obj_learning, path_learning);
+            const referencepath_learningValidationError = validate$1h(obj_learning, path_learning);
             if (referencepath_learningValidationError !== null) {
                 let message = 'Object doesn\'t match LearningOutput (at "' + path_learning + '")\n';
                 message += referencepath_learningValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -724,6 +769,23 @@ function validate$19(obj, path = 'GetLearningOutputRepresentation') {
                 }
             }
         }
+        if (obj.linked !== undefined) {
+            const obj_linked = obj.linked;
+            const path_linked = path + '.linked';
+            if (!ArrayIsArray(obj_linked)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_linked + '" (at "' + path_linked + '")');
+            }
+            for (let i = 0; i < obj_linked.length; i++) {
+                const obj_linked_item = obj_linked[i];
+                const path_linked_item = path_linked + '[' + i + ']';
+                const referencepath_linked_itemValidationError = validate$1c(obj_linked_item, path_linked_item);
+                if (referencepath_linked_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match LearningFoundationItemOutput (at "' + path_linked_item + '")\n';
+                    message += referencepath_linked_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
         if (obj.outcomes !== undefined) {
             const obj_outcomes = obj.outcomes;
             const path_outcomes = path + '.outcomes';
@@ -733,7 +795,7 @@ function validate$19(obj, path = 'GetLearningOutputRepresentation') {
             for (let i = 0; i < obj_outcomes.length; i++) {
                 const obj_outcomes_item = obj_outcomes[i];
                 const path_outcomes_item = path_outcomes + '[' + i + ']';
-                const referencepath_outcomes_itemValidationError = validate$1f(obj_outcomes_item, path_outcomes_item);
+                const referencepath_outcomes_itemValidationError = validate$1g(obj_outcomes_item, path_outcomes_item);
                 if (referencepath_outcomes_itemValidationError !== null) {
                     let message = 'Object doesn\'t match LearningOutcomeItemOutput (at "' + path_outcomes_item + '")\n';
                     message += referencepath_outcomes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -741,6 +803,23 @@ function validate$19(obj, path = 'GetLearningOutputRepresentation') {
                 }
             }
         }
+        if (obj.preOrCorequisites !== undefined) {
+            const obj_preOrCorequisites = obj.preOrCorequisites;
+            const path_preOrCorequisites = path + '.preOrCorequisites';
+            if (!ArrayIsArray(obj_preOrCorequisites)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_preOrCorequisites + '" (at "' + path_preOrCorequisites + '")');
+            }
+            for (let i = 0; i < obj_preOrCorequisites.length; i++) {
+                const obj_preOrCorequisites_item = obj_preOrCorequisites[i];
+                const path_preOrCorequisites_item = path_preOrCorequisites + '[' + i + ']';
+                const referencepath_preOrCorequisites_itemValidationError = validate$1c(obj_preOrCorequisites_item, path_preOrCorequisites_item);
+                if (referencepath_preOrCorequisites_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match LearningFoundationItemOutput (at "' + path_preOrCorequisites_item + '")\n';
+                    message += referencepath_preOrCorequisites_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
         if (obj.prerequisites !== undefined) {
             const obj_prerequisites = obj.prerequisites;
             const path_prerequisites = path + '.prerequisites';
@@ -3239,7 +3318,7 @@ function validate$S(obj, path = 'LearnerProgram') {
         if (obj.learningOutcomeItem !== undefined) {
             const obj_learningOutcomeItem = obj.learningOutcomeItem;
             const path_learningOutcomeItem = path + '.learningOutcomeItem';
-            const referencepath_learningOutcomeItemValidationError = validate$1f(obj_learningOutcomeItem, path_learningOutcomeItem);
+            const referencepath_learningOutcomeItemValidationError = validate$1g(obj_learningOutcomeItem, path_learningOutcomeItem);
             if (referencepath_learningOutcomeItemValidationError !== null) {
                 let message = 'Object doesn\'t match LearningOutcomeItemOutput (at "' + path_learningOutcomeItem + '")\n';
                 message += referencepath_learningOutcomeItemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');

package/dist/es/es2018/types/src/generated/types/CreateLearningInputRepresentation.d.ts

@@ -1,6 +1,6 @@
 import { LearningPolicyRules as LearningPolicyRules_LearningPolicyRules } from './LearningPolicyRules';
 import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
-export declare const VERSION = "0d79e65909ac4d67a9f6b706318b1978";
+export declare const VERSION = "f250a1bf201b7e81c82c7678e12844dc";
 export declare function validate(obj: any, path?: string): TypeError | null;
 export declare const RepresentationType: string;
 export declare function normalize(input: CreateLearningInputRepresentation, existing: CreateLearningInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CreateLearningInputRepresentationNormalized;
@@ -21,8 +21,12 @@ export interface CreateLearningInputRepresentationNormalized {
     learning: {};
     /** List of Learning Policy Rules that are part of learning */
     learningPolicyRules: Array<LearningPolicyRules_LearningPolicyRules>;
+    /** List of AchievementMappings that are part of the linked courses set set */
+    linked?: Array<unknown>;
     /** List of AchievementMappings which are part of the outcomes set */
     outcomes?: Array<{}>;
+    /** List of AchievementMappings that are part of the prerequisite or co-requisite set set */
+    preOrCorequisites?: Array<unknown>;
     /** List of AchievementMappings which are part of the prerequisite set */
     prerequisites?: Array<{}>;
     /** List of AchievementMappings which are part of the recommended set */
@@ -40,7 +44,9 @@ export interface CreateLearningInputRepresentation {
     corequisites?: Array<{}>;
     learning: {};
     learningPolicyRules: Array<LearningPolicyRules_LearningPolicyRules>;
+    linked?: Array<unknown>;
     outcomes?: Array<{}>;
+    preOrCorequisites?: Array<unknown>;
     prerequisites?: Array<{}>;
     recommended?: Array<{}>;
     skills?: Array<{}>;

package/dist/es/es2018/types/src/generated/types/GetLearningOutputRepresentation.d.ts

@@ -6,7 +6,7 @@ import { LearningOutcomeItemOutput as LearningOutcomeItemOutput_LearningOutcomeI
 import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
 import { LearningCourseOutput as LearningCourseOutput_LearningCourseOutput } from './LearningCourseOutput';
 import { LearningProgramOutput as LearningProgramOutput_LearningProgramOutput } from './LearningProgramOutput';
-export declare const VERSION = "9b0ee223b5d04bad05ae8dc9a29ceefd";
+export declare const VERSION = "00d976655763261f8c025fa68734a565";
 export declare function validate(obj: any, path?: string): TypeError | null;
 export declare const RepresentationType: string;
 export declare function normalize(input: GetLearningOutputRepresentation, existing: GetLearningOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): GetLearningOutputRepresentationNormalized;
@@ -28,8 +28,12 @@ export interface GetLearningOutputRepresentationNormalized {
     learning?: LearningOutput_LearningOutput;
     /** Learning Policies Output. */
     learningPolicyRules?: Array<LearningPolicyRuleOutput_LearningPolicyRuleOutput>;
+    /** Linked courses */
+    linked?: Array<LearningFoundationItemOutput_LearningFoundationItemOutput>;
     /** Outcomes */
     outcomes?: Array<LearningOutcomeItemOutput_LearningOutcomeItemOutput>;
+    /** Prerequisite or co-requisite courses */
+    preOrCorequisites?: Array<LearningFoundationItemOutput_LearningFoundationItemOutput>;
     /** Prerequisites */
     prerequisites?: Array<LearningFoundationItemOutput_LearningFoundationItemOutput>;
     /** Recommended */
@@ -48,7 +52,9 @@ export interface GetLearningOutputRepresentation {
     errors?: Array<EducationApiErrorDetails_EducationApiErrorDetails>;
     learning?: LearningCourseOutput_LearningCourseOutput | LearningProgramOutput_LearningProgramOutput;
     learningPolicyRules?: Array<LearningPolicyRuleOutput_LearningPolicyRuleOutput>;
+    linked?: Array<LearningFoundationItemOutput_LearningFoundationItemOutput>;
     outcomes?: Array<LearningOutcomeItemOutput_LearningOutcomeItemOutput>;
+    preOrCorequisites?: Array<LearningFoundationItemOutput_LearningFoundationItemOutput>;
     prerequisites?: Array<LearningFoundationItemOutput_LearningFoundationItemOutput>;
     recommended?: Array<LearningFoundationItemOutput_LearningFoundationItemOutput>;
     success?: boolean;

package/dist/es/es2018/types/src/generated/types/LearningCourseOutput.d.ts

@@ -1,6 +1,6 @@
 import { LearningOutput as LearningOutput_LearningOutput } from './LearningOutput';
 import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
-export declare const VERSION = "582bae5b819ddfda61a505eb2c634d67";
+export declare const VERSION = "76e451c422f7a4fcacdf4fcf5306c6be";
 export declare function validate(obj: any, path?: string): TypeError | null;
 export declare const RepresentationType: string;
 export declare function normalize(input: LearningCourseOutput, existing: LearningCourseOutputNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LearningCourseOutputNormalized;
@@ -19,6 +19,8 @@ export interface LearningCourseOutputNormalized extends LearningOutput_LearningO
     courseLevelDescription?: string;
     /** Learning course number. */
     courseNumber?: string;
+    /** Type of the course. */
+    courseType?: string;
     /** Learning field of study. */
     fieldOfStudy?: string;
     /** Learning course custom fields. */
@@ -27,6 +29,8 @@ export interface LearningCourseOutputNormalized extends LearningOutput_LearningO
     };
     /** Learning course id. */
     learningCourseId?: string;
+    /** Indicates if this is a linked-only course. */
+    linkedOnly?: boolean;
     /** Learning subject abbreviation. */
     subjectAbbreviation?: string;
 }
@@ -39,11 +43,13 @@ export interface LearningCourseOutputNormalized extends LearningOutput_LearningO
 export interface LearningCourseOutput extends LearningOutput_LearningOutput {
     courseLevelDescription?: string;
     courseNumber?: string;
+    courseType?: string;
     fieldOfStudy?: string;
     learningCourseCustomFields?: {
         [key: string]: unknown;
     };
     learningCourseId?: string;
+    linkedOnly?: boolean;
     subjectAbbreviation?: string;
     type: 'LearningCourse';
 }

package/dist/es/es2018/types/src/generated/types/LearningEquivalency.d.ts

@@ -0,0 +1,34 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "6641e60371a60a64b33d973a6073a3bf";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: LearningEquivalency, existing: LearningEquivalencyNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LearningEquivalencyNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LearningEquivalencyNormalized, incoming: LearningEquivalencyNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LearningEquivalency, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Equivalency like Transfer credit, Work Equivalency, etc.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearningEquivalencyNormalized {
+    /** ID of the Equivalency */
+    equivalencyId?: string;
+    /** Name of the Equivalency */
+    equivalencyName?: string;
+    /** type of the Equivalency */
+    typeLabel?: string;
+}
+/**
+ * Equivalency like Transfer credit, Work Equivalency, etc.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearningEquivalency {
+    equivalencyId?: string;
+    equivalencyName?: string;
+    typeLabel?: string;
+}

package/dist/es/es2018/types/src/generated/types/LearningStatus.d.ts

@@ -1,5 +1,6 @@
+import { LearningEquivalency as LearningEquivalency_LearningEquivalency } from './LearningEquivalency';
 import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
-export declare const VERSION = "dc0281943504f859c97796f295576dbb";
+export declare const VERSION = "5eca04ba460f4fede6472c81d60c2e34";
 export declare function validate(obj: any, path?: string): TypeError | null;
 export declare const RepresentationType: string;
 export declare function normalize(input: LearningStatus, existing: LearningStatusNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LearningStatusNormalized;
@@ -26,6 +27,8 @@ export interface LearningStatusNormalized {
     academicYear?: string;
     /** The unit of measurement for completion of the course */
     durationUnit?: string;
+    /** List of equivalencies like Transfer credit, Work Equivalency, etc. */
+    equivalency: Array<LearningEquivalency_LearningEquivalency>;
     /** Learning Id */
     learningId?: string;
     /** The letter grade awarded to the learner for completing the course */
@@ -56,6 +59,7 @@ export interface LearningStatus {
     academicTermId?: string;
     academicYear?: string;
     durationUnit?: string;
+    equivalency: Array<LearningEquivalency_LearningEquivalency>;
     learningId?: string;
     letterGrade?: string;
     mappedStatusDefinition: Array<string>;

package/dist/es/es2018/types/src/generated/types/UpdateLearningInputRepresentation.d.ts

@@ -1,6 +1,7 @@
 import { LearningPolicyRuleUpdate as LearningPolicyRuleUpdate_LearningPolicyRuleUpdate } from './LearningPolicyRuleUpdate';
+import { RequirementUpdateItem as RequirementUpdateItem_RequirementUpdateItem } from './RequirementUpdateItem';
 import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
-export declare const VERSION = "39c1b80b6205d38f91a32f58c68dc6ae";
+export declare const VERSION = "3ae73d176cf95194f686deb140056429";
 export declare function validate(obj: any, path?: string): TypeError | null;
 export declare const RepresentationType: string;
 export declare function normalize(input: UpdateLearningInputRepresentation, existing: UpdateLearningInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): UpdateLearningInputRepresentationNormalized;
@@ -21,8 +22,12 @@ export interface UpdateLearningInputRepresentationNormalized {
     learning: {};
     /** List of Learning Policy Rules that are part of learning */
     learningPolicyRules: Array<LearningPolicyRuleUpdate_LearningPolicyRuleUpdate>;
+    /** Requirement update item which is part of the linked set */
+    linked?: RequirementUpdateItem_RequirementUpdateItem;
     /** List of AchievementMappings which are part of the outcomes set */
     outcomes?: Array<{}>;
+    /** Requirement update item which is part of the prerequisite or co-requisite set */
+    preOrCorequisites?: RequirementUpdateItem_RequirementUpdateItem;
     /** Requirement update item which is part of the prerequisite set */
     prerequisites?: {};
     /** Requirement update item which is part of the recommended set */
@@ -38,7 +43,9 @@ export interface UpdateLearningInputRepresentation {
     corequisites?: {};
     learning: {};
     learningPolicyRules: Array<LearningPolicyRuleUpdate_LearningPolicyRuleUpdate>;
+    linked?: RequirementUpdateItem_RequirementUpdateItem;
     outcomes?: Array<{}>;
+    preOrCorequisites?: RequirementUpdateItem_RequirementUpdateItem;
     prerequisites?: {};
     recommended?: {};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-adapters-industries-education",
-    "version": "1.364.0",
+    "version": "1.366.0",
     "description": "Education Cloud related actions",
     "license": "MIT",
     "main": "dist/es/es2018/industries-education.js",
@@ -46,11 +46,11 @@
         "test:unit": "jest --config=./jest.config.js"
     },
     "dependencies": {
-        "@salesforce/lds-bindings": "^1.364.0"
+        "@salesforce/lds-bindings": "^1.366.0"
     },
     "devDependencies": {
-        "@salesforce/lds-compiler-plugins": "^1.364.0",
-        "@salesforce/lds-karma": "^1.364.0"
+        "@salesforce/lds-compiler-plugins": "^1.366.0",
+        "@salesforce/lds-karma": "^1.366.0"
     },
     "nx": {
         "targets": {