@salesforce/lds-adapters-industries-education 0.1.0-dev1

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

@@ -0,0 +1,62 @@
+import { ApplicationRenderMethod as ApplicationRenderMethod_ApplicationRenderMethod } from './ApplicationRenderMethod';
+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 = "7b00d7b23bee729e6e252161c9451837";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: IndividualApplicationTask, existing: IndividualApplicationTaskNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): IndividualApplicationTaskNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: IndividualApplicationTaskNormalized, incoming: IndividualApplicationTaskNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: IndividualApplicationTask, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of the individual application task.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface IndividualApplicationTaskNormalized {
+    /** The application render methods associated with an individual application task. */
+    applicationRenderMethods?: Array<ApplicationRenderMethod_ApplicationRenderMethod>;
+    /** The due date of the Individual Application Task. */
+    dueDate?: string;
+    /** The ID of the Individual Application Task. */
+    id?: string;
+    /** An indicator of whether the Individual Application Task is required. */
+    isRequired?: boolean;
+    /** The name of the Individual Application Task. */
+    name?: string;
+    /** The Method Name of the Application Render Method associated with the Individual Application Task. */
+    renderMethodName?: string;
+    /** The Method Record ID of the Application Render Method associated with the Individual Application Task. */
+    renderMethodRecordId?: string;
+    /** The type of the Application Render Method associated with the Individual Application Task. */
+    renderMethodType?: string;
+    /** The description of the Individual Application Task's Application Stage Definition. */
+    stageDescription?: string;
+    /** The name of the Individual Application Task's Application Stage Definition. */
+    stageName?: string;
+    /** The status of the Individual Application Task. */
+    status?: string;
+    /** The translated status label of an individual application task. */
+    statusLabel?: string;
+}
+/**
+ * Representation of the individual application task.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface IndividualApplicationTask {
+    applicationRenderMethods?: Array<ApplicationRenderMethod_ApplicationRenderMethod>;
+    dueDate?: string;
+    id?: string;
+    isRequired?: boolean;
+    name?: string;
+    renderMethodName?: string;
+    renderMethodRecordId?: string;
+    renderMethodType?: string;
+    stageDescription?: string;
+    stageName?: string;
+    status?: string;
+    statusLabel?: string;
+}

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

@@ -0,0 +1,30 @@
+import { IndividualApplicationTask as IndividualApplicationTask_IndividualApplicationTask } from './IndividualApplicationTask';
+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';
+export declare const TTL = 100;
+export declare const VERSION = "51a57763ac92bf86b3c62c32e17dbd49";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: IndividualApplicationTaskOutputRepresentation, existing: IndividualApplicationTaskOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): IndividualApplicationTaskOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: IndividualApplicationTaskOutputRepresentationNormalized, incoming: IndividualApplicationTaskOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: IndividualApplicationTaskOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of the output for the get individual application task request.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface IndividualApplicationTaskOutputRepresentationNormalized {
+    /** Representation of the get individual application task request. */
+    result?: IndividualApplicationTask_IndividualApplicationTask;
+}
+/**
+ * Representation of the output for the get individual application task request.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface IndividualApplicationTaskOutputRepresentation {
+    result?: IndividualApplicationTask_IndividualApplicationTask;
+}

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

@@ -0,0 +1,86 @@
+import { LearningOutcomeItemOutput as LearningOutcomeItemOutput_LearningOutcomeItemOutput } from './LearningOutcomeItemOutput';
+import { LearnerProgramRequirement as LearnerProgramRequirement_LearnerProgramRequirement } from './LearnerProgramRequirement';
+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 = "91c8232d644b5cf481f0891830fc3207";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: LearnerProgram, existing: LearnerProgramNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LearnerProgramNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LearnerProgramNormalized, incoming: LearnerProgramNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LearnerProgram, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents information about a program enrolled by learner.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearnerProgramNormalized {
+    /** Description of the learner program */
+    description?: string;
+    /** End date of the learner program */
+    endDate?: string;
+    /** Learner account Id */
+    learnerAccountId?: string;
+    /** Learner contact Id */
+    learnerContactId?: string;
+    /** Learner program Id */
+    learnerProgramId?: string;
+    /** Learning Id for the associated learning program */
+    learningId?: string;
+    learningOutcomeItem?: LearningOutcomeItemOutput_LearningOutcomeItemOutput;
+    /** Learning Program Academic Level */
+    learningProgramAcademicLevel?: string;
+    /** Learning Program Cip Code */
+    learningProgramCipCode?: string;
+    /** Learning program Id for the associated learning program plan */
+    learningProgramId?: string;
+    /** Learning Program Name */
+    learningProgramName?: string;
+    /** Learning program plan Id for this learner program */
+    learningProgramPlanId?: string;
+    /** Learning Program Plan Name */
+    learningProgramPlanName?: string;
+    /** Learning Program Provider Id */
+    learningProgramProviderId?: string;
+    /** Learning Program Provider Name */
+    learningProgramProviderName?: string;
+    /** Name of the learner program */
+    name?: string;
+    /** Parent learner program Id */
+    parentLearnerProgramId?: string;
+    /** Status of the learner program */
+    requirements?: Array<LearnerProgramRequirement_LearnerProgramRequirement>;
+    /** Start date of the learner program */
+    startDate?: string;
+    /** Status of the learner program */
+    status?: string;
+}
+/**
+ * Represents information about a program enrolled by learner.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearnerProgram {
+    description?: string;
+    endDate?: string;
+    learnerAccountId?: string;
+    learnerContactId?: string;
+    learnerProgramId?: string;
+    learningId?: string;
+    learningOutcomeItem?: LearningOutcomeItemOutput_LearningOutcomeItemOutput;
+    learningProgramAcademicLevel?: string;
+    learningProgramCipCode?: string;
+    learningProgramId?: string;
+    learningProgramName?: string;
+    learningProgramPlanId?: string;
+    learningProgramPlanName?: string;
+    learningProgramProviderId?: string;
+    learningProgramProviderName?: string;
+    name?: string;
+    parentLearnerProgramId?: string;
+    requirements?: Array<LearnerProgramRequirement_LearnerProgramRequirement>;
+    startDate?: string;
+    status?: string;
+}

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

@@ -0,0 +1,53 @@
+import { LearningProgramPlanRequirementOutput as LearningProgramPlanRequirementOutput_LearningProgramPlanRequirementOutput } from './LearningProgramPlanRequirementOutput';
+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 = "d7af2bfee148ac8ae983037e910f21ac";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: LearnerProgramRequirement, existing: LearnerProgramRequirementNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LearnerProgramRequirementNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LearnerProgramRequirementNormalized, incoming: LearnerProgramRequirementNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LearnerProgramRequirement, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents information about a learner program requirement.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearnerProgramRequirementNormalized {
+    /** Description of the learner program requirement */
+    description?: string;
+    /** Learner program Id */
+    learnerProgramId: string;
+    /** Learner program requirement Id */
+    learnerProgramRequirementId?: string;
+    learningProgramPlanRequirement?: LearningProgramPlanRequirementOutput_LearningProgramPlanRequirementOutput;
+    /** Learning program plan requirement Id */
+    learningProgramPlanRequirementId?: string;
+    /** Name of the learner program requirement */
+    name: string;
+    /** Requirement durations by duration unit type */
+    requirementDurationsByUnit?: {
+        [key: string]: unknown;
+    };
+    /** Status of the learner program requirement */
+    status?: string;
+}
+/**
+ * Represents information about a learner program requirement.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearnerProgramRequirement {
+    description?: string;
+    learnerProgramId: string;
+    learnerProgramRequirementId?: string;
+    learningProgramPlanRequirement?: LearningProgramPlanRequirementOutput_LearningProgramPlanRequirementOutput;
+    learningProgramPlanRequirementId?: string;
+    name: string;
+    requirementDurationsByUnit?: {
+        [key: string]: unknown;
+    };
+    status?: string;
+}

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

@@ -0,0 +1,33 @@
+import { LearnerProgram as LearnerProgram_LearnerProgram } from './LearnerProgram';
+import { LearningFulfiller as LearningFulfiller_LearningFulfiller } from './LearningFulfiller';
+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';
+export declare const VERSION = "a465786ab4e5c95e1d888615e32dd640";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: LearnerProgressOutputRepresentation, existing: LearnerProgressOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LearnerProgressOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: LearnerProgressOutputRepresentationNormalized, incoming: LearnerProgressOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LearnerProgressOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Learner progress output.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearnerProgressOutputRepresentationNormalized {
+    /** List of learner programs enrolled by a student */
+    learnerPrograms?: Array<LearnerProgram_LearnerProgram>;
+    /** List of non required learnings completed or enrolled by a student */
+    nonRequiredLearnings?: Array<LearningFulfiller_LearningFulfiller>;
+}
+/**
+ * Learner progress output.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearnerProgressOutputRepresentation {
+    learnerPrograms?: Array<LearnerProgram_LearnerProgram>;
+    nonRequiredLearnings?: Array<LearningFulfiller_LearningFulfiller>;
+}

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

@@ -0,0 +1,61 @@
+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 = "e282875ab8d32af6bf8a1aef341b951f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: Learning, existing: LearningNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LearningNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LearningNormalized, incoming: LearningNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: Learning, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents information that defines an instructional object that can be made available as a course, program, or on-site experience, for a contact.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearningNormalized {
+    /** Academic level of the learning. */
+    academicLevel?: string;
+    /** Indicates whether the learning is active. */
+    active?: boolean;
+    /** Start date of the learning's active period. */
+    activeFromDate?: string;
+    /** End date of the learning's active period. */
+    activeToDate?: string;
+    /** Classification of Instructional Programming code that identifies the program or field of study. */
+    cipCode: string;
+    /** Description of the learning. */
+    description?: string;
+    /** Allocated duration to complete the learning. */
+    duration?: number;
+    /** Unit of the duration allocated to complete the learning. */
+    durationUnit?: string;
+    /** Learning id. */
+    learningId?: string;
+    /** Name of the Learning */
+    name?: string;
+    /** Account foreign key identifier of the institution that provides the learning. */
+    provider?: string;
+    /** Learning record type. Possible values are Learning Program and Learning Course. */
+    type: string;
+}
+/**
+ * Represents information that defines an instructional object that can be made available as a course, program, or on-site experience, for a contact.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface Learning {
+    academicLevel?: string;
+    active?: boolean;
+    activeFromDate?: string;
+    activeToDate?: string;
+    cipCode: string;
+    description?: string;
+    duration?: number;
+    durationUnit?: string;
+    learningId?: string;
+    name?: string;
+    provider?: string;
+    type: string;
+}

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

@@ -0,0 +1,53 @@
+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 = "43c0b375c9c05ccb03497cfeaa511e51";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: LearningAchievement, existing: LearningAchievementNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LearningAchievementNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LearningAchievementNormalized, incoming: LearningAchievementNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LearningAchievement, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Learning achievement accomplished by completing the requirement.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearningAchievementNormalized {
+    /** Abbreviation of the learning achievement. */
+    abbreviation?: string;
+    /** Academic level of the learning achievement. */
+    academicLevel?: string;
+    /** Custom field on the learning achievement. */
+    additionalField?: {
+        [key: string]: {};
+    };
+    /** Description of the learning achievement. */
+    description?: string;
+    /** Field of study of the learning achievement. */
+    fieldOfStudy?: string;
+    /** Issuer of the learning achievement. */
+    issuer?: string;
+    /** Name of the learning achievement. */
+    name: string;
+    /** Specialization of the learning achievement. */
+    specialization?: string;
+}
+/**
+ * Learning achievement accomplished by completing the requirement.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearningAchievement {
+    abbreviation?: string;
+    academicLevel?: string;
+    additionalField?: {
+        [key: string]: {};
+    };
+    description?: string;
+    fieldOfStudy?: string;
+    issuer?: string;
+    name: string;
+    specialization?: string;
+}

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

@@ -0,0 +1,48 @@
+import { Learning as Learning_Learning } from './Learning';
+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 = "6648edf61bb7a2be6899490ca21e93d9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: LearningCourse, existing: LearningCourseNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LearningCourseNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LearningCourseNormalized, incoming: LearningCourseNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LearningCourse, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents information about a course that’s required in a learning framework.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearningCourseNormalized extends Learning_Learning {
+    /** General type or level of instruction provided by the learning course. */
+    courseLevelDescription?: string;
+    /** Numeric identifier of the course. */
+    courseNumber?: string;
+    /** Field of study of the learning course. */
+    fieldOfStudy?: string;
+    /** Custom fields on the learning course. */
+    learningCourseCustomFields?: {
+        [key: string]: unknown;
+    };
+    /** Learning course id. */
+    learningCourseId?: string;
+    /** Abbreviation for the subject of the learning course. */
+    subjectAbbreviation?: string;
+}
+/**
+ * Represents information about a course that’s required in a learning framework.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearningCourse extends Learning_Learning {
+    courseLevelDescription?: string;
+    courseNumber?: string;
+    fieldOfStudy?: string;
+    learningCourseCustomFields?: {
+        [key: string]: unknown;
+    };
+    learningCourseId?: string;
+    subjectAbbreviation?: string;
+}

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

@@ -0,0 +1,55 @@
+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 = "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;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LearningCourseOutputNormalized, incoming: LearningCourseOutputNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LearningCourseOutput, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents information about a course that’s required in a learning framework.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearningCourseOutputNormalized extends LearningOutput_LearningOutput {
+    /** Learning course level description. */
+    courseLevelDescription?: string;
+    /** Learning course number. */
+    courseNumber?: string;
+    /** Type of the course. */
+    courseType?: string;
+    /** Learning field of study. */
+    fieldOfStudy?: string;
+    /** Learning course custom fields. */
+    learningCourseCustomFields?: {
+        [key: string]: unknown;
+    };
+    /** Learning course id. */
+    learningCourseId?: string;
+    /** Indicates if this is a linked-only course. */
+    linkedOnly?: boolean;
+    /** Learning subject abbreviation. */
+    subjectAbbreviation?: string;
+}
+/**
+ * Represents information about a course that’s required in a learning framework.
+ *
+ * Keys:
+ *    (none)
+ */
+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/LearningFoundationItemOutput.d.ts

@@ -0,0 +1,74 @@
+import { LearningFulfiller as LearningFulfiller_LearningFulfiller } from './LearningFulfiller';
+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 = "9fdc0b97a2f4609cd2047262a5147e33";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: LearningFoundationItemOutput, existing: LearningFoundationItemOutputNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LearningFoundationItemOutputNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LearningFoundationItemOutputNormalized, incoming: LearningFoundationItemOutputNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LearningFoundationItemOutput, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of a learning foundation item output.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearningFoundationItemOutputNormalized {
+    /** Category */
+    category?: string;
+    /** Duration */
+    duration?: number;
+    /** The unit of duration. */
+    durationUnit?: string;
+    /** List of learning fulfillers that provide more information about how the foundation item can be fulfilled. */
+    fulfilledBy?: Array<LearningFulfiller_LearningFulfiller>;
+    /** The completed duration towards fulfilling the learning foundation item. */
+    fulfilledDuration?: number;
+    /** Specifies whether the learning foundation item is fulfilled (true) or unfulfilled (false). */
+    isFulfilled?: boolean;
+    /** The name of the learning achievement config record */
+    learningAchievementConfigName?: string;
+    /** Learning Achievement Id */
+    learningAchievementId?: string;
+    /** The name of the learning achievement */
+    learningAchievementName?: string;
+    /** Type of Learning Achievement */
+    learningAchievementType?: string;
+    /** The ID of the learning foundation item. */
+    learningFoundationItemId: string;
+    /** Learning Id */
+    learningId?: string;
+    /** The minimum numeric grade required to fulfill the learning foundation item. */
+    minimumNumericGrade?: number;
+    /** Name */
+    name?: string;
+    /** The remaining duration required to fulfill the learning foundation item. */
+    remainingDuration?: number;
+    /** Type */
+    type?: string;
+}
+/**
+ * Representation of a learning foundation item output.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearningFoundationItemOutput {
+    category?: string;
+    duration?: number;
+    durationUnit?: string;
+    fulfilledBy?: Array<LearningFulfiller_LearningFulfiller>;
+    fulfilledDuration?: number;
+    isFulfilled?: boolean;
+    learningAchievementConfigName?: string;
+    learningAchievementId?: string;
+    learningAchievementName?: string;
+    learningAchievementType?: string;
+    learningFoundationItemId: string;
+    learningId?: string;
+    minimumNumericGrade?: number;
+    name?: string;
+    remainingDuration?: number;
+    type?: string;
+}

package/dist/es/es2018/types/src/generated/types/LearningFoundationItemValidationInput.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 = "5606509e191d8a650c5f5b790aa978c5";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: LearningFoundationItemValidationInput, existing: LearningFoundationItemValidationInputNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LearningFoundationItemValidationInputNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LearningFoundationItemValidationInputNormalized, incoming: LearningFoundationItemValidationInputNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LearningFoundationItemValidationInput, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of the input validating a learning's foundation items.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearningFoundationItemValidationInputNormalized {
+    /** List of learnings that could be taken at the same time as the learning that is being validated. */
+    concurrentLearnings: Array<{}>;
+    /** The ID of the learning foundation item to be validated. */
+    learningId: string;
+    /** List of learnings that could be taken before the learning that is being validated. */
+    precedingLearnings: Array<{}>;
+}
+/**
+ * Representation of the input validating a learning's foundation items.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LearningFoundationItemValidationInput {
+    concurrentLearnings: Array<{}>;
+    learningId: string;
+    precedingLearnings: Array<{}>;
+}