@conform-ed/contracts 0.0.3

package/src/cmi5/v1_0/index.ts

@@ -0,0 +1,134 @@
+import { z } from "zod";
+
+function strictObject<T extends z.ZodRawShape>(shape: T) {
+  return z.object(shape).strict();
+}
+
+const UriSchema = z.string().regex(/^[a-zA-Z][a-zA-Z0-9+.-]*:.+$/u);
+
+export const Cmi5LanguageStringSchema = strictObject({
+  lang: z.string().min(1).optional(),
+  value: z.string(),
+});
+
+export const Cmi5TextSchema = strictObject({
+  langstrings: z.array(Cmi5LanguageStringSchema).min(1),
+});
+
+export const Cmi5ObjectiveSchema = strictObject({
+  id: UriSchema,
+  title: Cmi5TextSchema,
+  description: Cmi5TextSchema,
+});
+
+export const Cmi5ObjectiveReferenceSchema = strictObject({
+  idref: UriSchema,
+});
+
+export const Cmi5KeywordReferenceSchema = strictObject({
+  idref: UriSchema,
+});
+
+export const Cmi5KeywordDefinitionSchema = strictObject({
+  id: UriSchema,
+  title: Cmi5TextSchema,
+  description: Cmi5TextSchema.optional(),
+});
+
+export const Cmi5KeywordExtensionSchema = strictObject({
+  keywords: z.array(Cmi5KeywordDefinitionSchema).min(1),
+});
+
+let Cmi5BlockSchema: z.ZodTypeAny;
+
+export const Cmi5AuSchema = strictObject({
+  id: UriSchema,
+  title: Cmi5TextSchema,
+  description: Cmi5TextSchema,
+  objectives: z.array(Cmi5ObjectiveReferenceSchema).min(1).optional(),
+  url: UriSchema,
+  launchParameters: z.string().optional(),
+  entitlementKey: z.string().optional(),
+  moveOn: z.enum(["NotApplicable", "Passed", "Completed", "CompletedAndPassed", "CompletedOrPassed"]).optional(),
+  masteryScore: z.number().min(0).max(1).optional(),
+  launchMethod: z.enum(["AnyWindow", "OwnWindow"]).optional(),
+  activityType: UriSchema.optional(),
+  keywords: z.array(Cmi5KeywordReferenceSchema).min(1).optional(),
+});
+
+export const Cmi5CourseStructureItemSchema = z.lazy(() => z.union([Cmi5AuSchema, Cmi5BlockSchema]));
+
+Cmi5BlockSchema = strictObject({
+  id: UriSchema,
+  title: Cmi5TextSchema,
+  description: Cmi5TextSchema,
+  objectives: z.array(Cmi5ObjectiveReferenceSchema).min(1).optional(),
+  children: z.array(Cmi5CourseStructureItemSchema).min(1),
+});
+
+export const Cmi5CourseSchema = strictObject({
+  id: UriSchema,
+  title: Cmi5TextSchema,
+  description: Cmi5TextSchema,
+});
+
+export const Cmi5CourseStructureSchema = strictObject({
+  course: Cmi5CourseSchema,
+  objectives: z.array(Cmi5ObjectiveSchema).min(1).optional(),
+  children: z.array(Cmi5CourseStructureItemSchema).min(1),
+});
+
+export const Cmi5CourseStructureDocumentSchema = strictObject({
+  courseStructure: Cmi5CourseStructureSchema,
+  keywords: Cmi5KeywordExtensionSchema.optional(),
+});
+
+export namespace Cmi5V1_0 {
+  export namespace Schemas {
+    export const LanguageString = Cmi5LanguageStringSchema;
+    export const Text = Cmi5TextSchema;
+    export const Objective = Cmi5ObjectiveSchema;
+    export const ObjectiveReference = Cmi5ObjectiveReferenceSchema;
+    export const KeywordReference = Cmi5KeywordReferenceSchema;
+    export const KeywordDefinition = Cmi5KeywordDefinitionSchema;
+    export const KeywordExtension = Cmi5KeywordExtensionSchema;
+    export const Course = Cmi5CourseSchema;
+    export const Au = Cmi5AuSchema;
+    export const Block = Cmi5BlockSchema;
+    export const CourseStructure = Cmi5CourseStructureSchema;
+    export const CourseStructureDocument = Cmi5CourseStructureDocumentSchema;
+  }
+}
+
+export const Schemas = Cmi5V1_0.Schemas;
+
+export type Cmi5V1_0Schemas = typeof Cmi5V1_0.Schemas;
+
+export const Cmi5V1_0DerivedZodTemplates = {
+  description: "cmi5 Quartz Zod schemas for course-structure XML and keyword extension documents",
+  specLinks: {
+    main: "https://github.com/AICC/CMI-5_Spec_Current/tree/quartz",
+    courseStructure: "https://github.com/AICC/CMI-5_Spec_Current/blob/quartz/v1/CourseStructure.xsd",
+    keywordExtension: "https://github.com/AICC/CMI-5_Spec_Current/blob/quartz/v1/examples/extended-cmi5.xsd",
+  },
+  scope: "Course structure XML plus keyword extension documents",
+  notes: [
+    "This bundle models the official cmi5 course-structure XSD and keyword extension XSD, not the runtime xAPI launch flow.",
+    "The XML examples in the Quartz repository map cleanly to a normalized object model with course, objectives, blocks, AUs, and keyword dictionaries.",
+  ],
+} as const;
+
+export const DerivedZodTemplates = Cmi5V1_0DerivedZodTemplates;
+// Inferred types from exported Zod validators.
+export type Cmi5LanguageString = z.infer<typeof Cmi5LanguageStringSchema>;
+export type Cmi5Text = z.infer<typeof Cmi5TextSchema>;
+export type Cmi5Objective = z.infer<typeof Cmi5ObjectiveSchema>;
+export type Cmi5ObjectiveReference = z.infer<typeof Cmi5ObjectiveReferenceSchema>;
+export type Cmi5KeywordReference = z.infer<typeof Cmi5KeywordReferenceSchema>;
+export type Cmi5KeywordDefinition = z.infer<typeof Cmi5KeywordDefinitionSchema>;
+export type Cmi5KeywordExtension = z.infer<typeof Cmi5KeywordExtensionSchema>;
+export type Cmi5Au = z.infer<typeof Cmi5AuSchema>;
+export type Cmi5CourseStructureItem = z.infer<typeof Cmi5CourseStructureItemSchema>;
+export type Cmi5Course = z.infer<typeof Cmi5CourseSchema>;
+export type Cmi5CourseStructure = z.infer<typeof Cmi5CourseStructureSchema>;
+export type Cmi5CourseStructureDocument = z.infer<typeof Cmi5CourseStructureDocumentSchema>;

package/src/common-cartridge/v1_3/ccv1p3_imsccauth_v1p3.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+
+import { NonEmptyStringSchema, XmlExtensionNodeListSchema, strictObject } from "./shared";
+
+export const CommonCartridgeAuthorizationAccessSchema = z.enum(["cartridge", "resource"]);
+
+export const CommonCartridgeAuthorizationSchema = strictObject({
+  cartridgeId: NonEmptyStringSchema,
+  webservice: z.string().optional(),
+});
+
+export const CommonCartridgeAuthorizationsSchema = strictObject({
+  authorization: CommonCartridgeAuthorizationSchema,
+  access: CommonCartridgeAuthorizationAccessSchema,
+  import: z.boolean().optional(),
+  extensions: XmlExtensionNodeListSchema.optional(),
+});
+
+export const CommonCartridgeAuthorizationsDocumentSchema = strictObject({
+  authorizations: CommonCartridgeAuthorizationsSchema,
+});
+// Inferred types from exported Zod validators.
+export type CommonCartridgeAuthorizationAccess = z.infer<typeof CommonCartridgeAuthorizationAccessSchema>;
+export type CommonCartridgeAuthorization = z.infer<typeof CommonCartridgeAuthorizationSchema>;
+export type CommonCartridgeAuthorizations = z.infer<typeof CommonCartridgeAuthorizationsSchema>;
+export type CommonCartridgeAuthorizationsDocument = z.infer<typeof CommonCartridgeAuthorizationsDocumentSchema>;

package/src/common-cartridge/v1_3/ccv1p3_imscp_v1p2_v1p0.ts

@@ -0,0 +1,352 @@
+import { z } from "zod";
+
+import { CurriculumStandardsMetadataSetSchema } from "./ccv1p3_imscsmd_v1p0";
+import { CommonCartridgeAuthorizationsSchema } from "./ccv1p3_imsccauth_v1p3";
+import { LomManifestSchema } from "./ccv1p3_lommanifest_v1p0";
+import { LomResourceSchema } from "./ccv1p3_lomresource_v1p0";
+import {
+  NonEmptyStringSchema,
+  UriReferenceSchema,
+  XmlExtensionNodeListSchema,
+  addIssue,
+  asArray,
+  collectDuplicates,
+  strictObject,
+} from "./shared";
+
+export const CommonCartridgeResourceTypeSchema = z.enum([
+  "webcontent",
+  "imsqti_xmlv1p2/imscc_xmlv1p3/assessment",
+  "imsqti_xmlv1p2/imscc_xmlv1p3/question-bank",
+  "associatedcontent/imscc_xmlv1p3/learning-application-resource",
+  "imsdt_xmlv1p3",
+  "imswl_xmlv1p3",
+  "imsbasiclti_xmlv1p3",
+  "idpfepub_epubv3p0",
+  "imsapip_zipv1p0",
+  "imsiwb_iwbv1p0",
+  "assignment_xmlv1p0",
+]);
+
+export const CommonCartridgeIntendedUseSchema = z.enum(["assignment", "lessonplan", "syllabus", "unspecified"]);
+
+export const CommonCartridgeGenericMetadataSchema = strictObject({
+  extensions: XmlExtensionNodeListSchema.optional(),
+});
+
+export const CommonCartridgeDependencySchema = strictObject({
+  identifierref: NonEmptyStringSchema,
+});
+
+export const CommonCartridgeFileSchema = strictObject({
+  href: UriReferenceSchema,
+  metadata: CommonCartridgeGenericMetadataSchema.optional(),
+});
+
+export const CommonCartridgeItemSchema: z.ZodTypeAny = z.lazy(() =>
+  strictObject({
+    identifier: NonEmptyStringSchema,
+    identifierref: NonEmptyStringSchema.optional(),
+    title: z.string(),
+    item: z.array(CommonCartridgeItemSchema).optional(),
+    metadata: CommonCartridgeGenericMetadataSchema.optional(),
+  }),
+);
+
+export const CommonCartridgeItemOrgSchema: z.ZodTypeAny = z.lazy(() =>
+  strictObject({
+    identifier: NonEmptyStringSchema,
+    item: z.array(CommonCartridgeItemSchema).optional(),
+    metadata: CommonCartridgeGenericMetadataSchema.optional(),
+  }),
+);
+
+export const CommonCartridgeOrganizationSchema = strictObject({
+  identifier: NonEmptyStringSchema,
+  structure: z.literal("rooted-hierarchy"),
+  title: z.string().optional(),
+  item: CommonCartridgeItemOrgSchema,
+  metadata: CommonCartridgeGenericMetadataSchema.optional(),
+});
+
+export const CommonCartridgeOrganizationsSchema = strictObject({
+  organization: CommonCartridgeOrganizationSchema.optional(),
+});
+
+export const CommonCartridgeManifestMetadataSchema = strictObject({
+  schema: z.enum(["IMS Common Cartridge", "IMS Thin Common Cartridge"]),
+  schemaversion: z.literal("1.3.0"),
+  lom: LomManifestSchema,
+  curriculumStandardsMetadataSet: CurriculumStandardsMetadataSetSchema.optional(),
+});
+
+export const CommonCartridgeResourceMetadataSchema = strictObject({
+  schema: z.string().optional(),
+  schemaversion: z.string().optional(),
+  lom: LomResourceSchema.optional(),
+  curriculumStandardsMetadataSet: z.array(CurriculumStandardsMetadataSetSchema).optional(),
+});
+
+export const CommonCartridgeResourceSchema = strictObject({
+  identifier: NonEmptyStringSchema,
+  type: CommonCartridgeResourceTypeSchema,
+  href: UriReferenceSchema.optional(),
+  xmlBase: z.string().optional(),
+  intendeduse: CommonCartridgeIntendedUseSchema.optional(),
+  // `protected` is imported from `imsccauth` as a global `xs:boolean` attribute. The manifest
+  // profile applies a schema-level default of `false`, but parsed XML objects do not reliably
+  // materialize XSD defaults, so the normalized JS model keeps it optional.
+  protected: z.boolean().optional(),
+  metadata: CommonCartridgeResourceMetadataSchema.optional(),
+  file: z.array(CommonCartridgeFileSchema).optional(),
+  dependency: z.array(CommonCartridgeDependencySchema).optional(),
+  extensions: XmlExtensionNodeListSchema.optional(),
+});
+
+export const CommonCartridgeResourcesSchema = strictObject({
+  xmlBase: z.string().optional(),
+  resource: z.array(CommonCartridgeResourceSchema).optional(),
+});
+
+export const CommonCartridgeManifestRawSchema = strictObject({
+  identifier: NonEmptyStringSchema,
+  xmlBase: z.string().optional(),
+  metadata: CommonCartridgeManifestMetadataSchema,
+  organizations: CommonCartridgeOrganizationsSchema,
+  resources: CommonCartridgeResourcesSchema,
+  authorizations: CommonCartridgeAuthorizationsSchema.optional(),
+});
+
+type CommonCartridgeTraversalItem = {
+  identifier: string;
+  identifierref?: string;
+  item?: CommonCartridgeTraversalItem[];
+};
+
+type CommonCartridgeTraversalManifest = {
+  organizations: {
+    organization?: {
+      item: {
+        item?: CommonCartridgeTraversalItem[];
+      };
+    };
+  };
+};
+
+function walkCommonCartridgeItems(
+  item: CommonCartridgeTraversalItem,
+  visit: (candidate: CommonCartridgeTraversalItem) => void,
+) {
+  visit(item);
+  for (const child of asArray(item.item)) {
+    walkCommonCartridgeItems(child, visit);
+  }
+}
+
+function collectCommonCartridgeItems(manifest: CommonCartridgeTraversalManifest): CommonCartridgeTraversalItem[] {
+  const items: CommonCartridgeTraversalItem[] = [];
+  const rootItem = manifest.organizations.organization?.item;
+
+  if (!rootItem) {
+    return items;
+  }
+
+  for (const child of asArray(rootItem.item)) {
+    walkCommonCartridgeItems(child, (candidate) => {
+      items.push(candidate);
+    });
+  }
+
+  return items;
+}
+
+const resourceTypesThatForbidHref = new Set<string>([
+  "imsdt_xmlv1p3",
+  "imswl_xmlv1p3",
+  "imsqti_xmlv1p2/imscc_xmlv1p3/assessment",
+  "imsqti_xmlv1p2/imscc_xmlv1p3/question-bank",
+]);
+
+const resourceTypesThatForbidAllDependencies = new Set<string>(["imswl_xmlv1p3"]);
+
+const prohibitedDependencyTargetsByType: Record<string, ReadonlySet<string>> = {
+  imsdt_xmlv1p3: new Set([
+    "imsdt_xmlv1p3",
+    "imswl_xmlv1p3",
+    "imsqti_xmlv1p2/imscc_xmlv1p3/assessment",
+    "imsqti_xmlv1p2/imscc_xmlv1p3/question-bank",
+    "imsbasiclti_xmlv1p3",
+  ]),
+  "imsqti_xmlv1p2/imscc_xmlv1p3/assessment": new Set([
+    "imsdt_xmlv1p3",
+    "imswl_xmlv1p3",
+    "imsqti_xmlv1p2/imscc_xmlv1p3/assessment",
+    "imsqti_xmlv1p2/imscc_xmlv1p3/question-bank",
+    "imsbasiclti_xmlv1p3",
+  ]),
+  "imsqti_xmlv1p2/imscc_xmlv1p3/question-bank": new Set([
+    "imsdt_xmlv1p3",
+    "imswl_xmlv1p3",
+    "imsqti_xmlv1p2/imscc_xmlv1p3/assessment",
+    "imsqti_xmlv1p2/imscc_xmlv1p3/question-bank",
+    "imsbasiclti_xmlv1p3",
+  ]),
+  webcontent: new Set([
+    "imsdt_xmlv1p3",
+    "imswl_xmlv1p3",
+    "imsqti_xmlv1p2/imscc_xmlv1p3/assessment",
+    "imsqti_xmlv1p2/imscc_xmlv1p3/question-bank",
+    "associatedcontent/imscc_xmlv1p3/learning-application-resource",
+    "imsbasiclti_xmlv1p3",
+  ]),
+  "associatedcontent/imscc_xmlv1p3/learning-application-resource": new Set([
+    "imsdt_xmlv1p3",
+    "imswl_xmlv1p3",
+    "imsqti_xmlv1p2/imscc_xmlv1p3/assessment",
+    "imsqti_xmlv1p2/imscc_xmlv1p3/question-bank",
+    "associatedcontent/imscc_xmlv1p3/learning-application-resource",
+    "imsbasiclti_xmlv1p3",
+  ]),
+  imsbasiclti_xmlv1p3: new Set([
+    "imsdt_xmlv1p3",
+    "imswl_xmlv1p3",
+    "imsqti_xmlv1p2/imscc_xmlv1p3/assessment",
+    "imsqti_xmlv1p2/imscc_xmlv1p3/question-bank",
+    "webcontent",
+    "imsbasiclti_xmlv1p3",
+  ]),
+};
+
+export const CommonCartridgeManifestProfileSchema = CommonCartridgeManifestRawSchema.superRefine(
+  (manifest, context) => {
+    const resources = asArray(manifest.resources.resource);
+    const resourcesByIdentifier = new Map(resources.map((resource) => [resource.identifier, resource] as const));
+
+    for (const duplicate of collectDuplicates(resources.map((resource) => resource.identifier))) {
+      addIssue(context, ["resources", "resource"], `Duplicate resource identifier: ${duplicate}`);
+    }
+
+    resources.forEach((resource, resourceIndex) => {
+      const files = asArray(resource.file);
+      const dependencies = asArray(resource.dependency);
+
+      for (const duplicate of collectDuplicates(files.map((file) => file.href))) {
+        addIssue(
+          context,
+          ["resources", "resource", resourceIndex, "file"],
+          `Resource ${resource.identifier} contains duplicate file href values: ${duplicate}`,
+        );
+      }
+
+      for (const duplicate of collectDuplicates(dependencies.map((dependency) => dependency.identifierref))) {
+        addIssue(
+          context,
+          ["resources", "resource", resourceIndex, "dependency"],
+          `Resource ${resource.identifier} contains duplicate dependency identifierref values: ${duplicate}`,
+        );
+      }
+
+      if (resourceTypesThatForbidHref.has(resource.type) && resource.href) {
+        addIssue(
+          context,
+          ["resources", "resource", resourceIndex, "href"],
+          `Resources of type ${resource.type} must not carry href in the active Schematron profile.`,
+        );
+      }
+
+      if (resource.href && files.length === 0) {
+        addIssue(
+          context,
+          ["resources", "resource", resourceIndex, "file"],
+          `Resource ${resource.identifier} has href but no file entries.`,
+        );
+      }
+
+      if (resource.href && !files.some((file) => file.href === resource.href)) {
+        addIssue(
+          context,
+          ["resources", "resource", resourceIndex, "href"],
+          `Resource ${resource.identifier} has href ${resource.href} but no matching file/@href.`,
+        );
+      }
+
+      if (resourceTypesThatForbidAllDependencies.has(resource.type) && dependencies.length > 0) {
+        addIssue(
+          context,
+          ["resources", "resource", resourceIndex, "dependency"],
+          `Resources of type ${resource.type} must not contain dependency entries in the active Schematron profile.`,
+        );
+      }
+
+      for (const [dependencyIndex, dependency] of dependencies.entries()) {
+        if (dependency.identifierref === resource.identifier) {
+          addIssue(
+            context,
+            ["resources", "resource", resourceIndex, "dependency", dependencyIndex, "identifierref"],
+            `Resource ${resource.identifier} has a circular dependency on itself.`,
+          );
+        }
+
+        const target = resourcesByIdentifier.get(dependency.identifierref);
+        const prohibitedTargets = prohibitedDependencyTargetsByType[resource.type];
+
+        if (target && prohibitedTargets?.has(target.type)) {
+          addIssue(
+            context,
+            ["resources", "resource", resourceIndex, "dependency", dependencyIndex, "identifierref"],
+            `Resource ${resource.identifier} (${resource.type}) must not depend on ${target.identifier} (${target.type}).`,
+          );
+        }
+      }
+    });
+
+    const items = collectCommonCartridgeItems(manifest as CommonCartridgeTraversalManifest);
+    const questionBankIdentifiers = new Set(
+      resources
+        .filter((resource) => resource.type === "imsqti_xmlv1p2/imscc_xmlv1p3/question-bank")
+        .map((resource) => resource.identifier),
+    );
+
+    items.forEach((item, itemIndex) => {
+      if (item.identifierref && questionBankIdentifiers.has(item.identifierref)) {
+        addIssue(
+          context,
+          ["organizations", "organization", "item", itemIndex, "identifierref"],
+          `Item ${item.identifier} must not reference a question-bank resource.`,
+        );
+      }
+
+      if (item.identifierref && asArray(item.item).length > 0) {
+        addIssue(
+          context,
+          ["organizations", "organization", "item", itemIndex, "item"],
+          `Learning-object item ${item.identifier} must not contain child items when identifierref is present.`,
+        );
+      }
+    });
+  },
+);
+
+export const CommonCartridgeManifestRawDocumentSchema = strictObject({
+  manifest: CommonCartridgeManifestRawSchema,
+});
+
+export const CommonCartridgeManifestProfileDocumentSchema = strictObject({
+  manifest: CommonCartridgeManifestProfileSchema,
+});
+// Inferred types from exported Zod validators.
+export type CommonCartridgeResourceType = z.infer<typeof CommonCartridgeResourceTypeSchema>;
+export type CommonCartridgeIntendedUse = z.infer<typeof CommonCartridgeIntendedUseSchema>;
+export type CommonCartridgeGenericMetadata = z.infer<typeof CommonCartridgeGenericMetadataSchema>;
+export type CommonCartridgeDependency = z.infer<typeof CommonCartridgeDependencySchema>;
+export type CommonCartridgeFile = z.infer<typeof CommonCartridgeFileSchema>;
+export type CommonCartridgeOrganization = z.infer<typeof CommonCartridgeOrganizationSchema>;
+export type CommonCartridgeOrganizations = z.infer<typeof CommonCartridgeOrganizationsSchema>;
+export type CommonCartridgeManifestMetadata = z.infer<typeof CommonCartridgeManifestMetadataSchema>;
+export type CommonCartridgeResourceMetadata = z.infer<typeof CommonCartridgeResourceMetadataSchema>;
+export type CommonCartridgeResource = z.infer<typeof CommonCartridgeResourceSchema>;
+export type CommonCartridgeResources = z.infer<typeof CommonCartridgeResourcesSchema>;
+export type CommonCartridgeManifestRaw = z.infer<typeof CommonCartridgeManifestRawSchema>;
+export type CommonCartridgeManifestProfile = z.infer<typeof CommonCartridgeManifestProfileSchema>;
+export type CommonCartridgeManifestRawDocument = z.infer<typeof CommonCartridgeManifestRawDocumentSchema>;
+export type CommonCartridgeManifestProfileDocument = z.infer<typeof CommonCartridgeManifestProfileDocumentSchema>;

package/src/common-cartridge/v1_3/ccv1p3_imscsmd_v1p0.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+
+import { NonEmptyStringSchema, strictObject } from "./shared";
+
+export const CurriculumStandardsLabelledGUIDSchema = strictObject({
+  label: z.string().optional(),
+  GUID: NonEmptyStringSchema,
+});
+
+export const CurriculumStandardsSetOfGUIDsSchema = strictObject({
+  labelledGUID: z.array(CurriculumStandardsLabelledGUIDSchema).min(1),
+  region: z.string().optional(),
+  version: z.string().optional(),
+});
+
+export const CurriculumStandardsMetadataSchema = strictObject({
+  setOfGUIDs: z.array(CurriculumStandardsSetOfGUIDsSchema).min(1),
+  providerId: z.string().optional(),
+});
+
+export const CurriculumStandardsMetadataSetSchema = strictObject({
+  curriculumStandardsMetadata: z.array(CurriculumStandardsMetadataSchema).min(1),
+  resourceLabel: z.string().optional(),
+  resourcePartId: z.string().optional(),
+});
+
+export const CurriculumStandardsMetadataSetDocumentSchema = strictObject({
+  curriculumStandardsMetadataSet: CurriculumStandardsMetadataSetSchema,
+});
+// Inferred types from exported Zod validators.
+export type CurriculumStandardsLabelledGUID = z.infer<typeof CurriculumStandardsLabelledGUIDSchema>;
+export type CurriculumStandardsSetOfGUIDs = z.infer<typeof CurriculumStandardsSetOfGUIDsSchema>;
+export type CurriculumStandardsMetadata = z.infer<typeof CurriculumStandardsMetadataSchema>;
+export type CurriculumStandardsMetadataSet = z.infer<typeof CurriculumStandardsMetadataSetSchema>;
+export type CurriculumStandardsMetadataSetDocument = z.infer<typeof CurriculumStandardsMetadataSetDocumentSchema>;

package/src/common-cartridge/v1_3/ccv1p3_imsdt_v1p3.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+
+import { NonEmptyStringSchema, UriReferenceSchema, XmlExtensionNodeListSchema, strictObject } from "./shared";
+
+export const DiscussionTopicAttachmentSchema = strictObject({
+  href: UriReferenceSchema,
+});
+
+export const DiscussionTopicAttachmentsSchema = strictObject({
+  attachment: z.array(DiscussionTopicAttachmentSchema).min(1),
+});
+
+export const DiscussionTopicTextSchema = strictObject({
+  value: z.string(),
+  texttype: z.enum(["text/plain", "text/html"]),
+});
+
+export const DiscussionTopicSchema = strictObject({
+  title: NonEmptyStringSchema,
+  text: DiscussionTopicTextSchema,
+  attachments: DiscussionTopicAttachmentsSchema.optional(),
+  extensions: XmlExtensionNodeListSchema.optional(),
+});
+
+export const DiscussionTopicDocumentSchema = strictObject({
+  topic: DiscussionTopicSchema,
+});
+// Inferred types from exported Zod validators.
+export type DiscussionTopicAttachment = z.infer<typeof DiscussionTopicAttachmentSchema>;
+export type DiscussionTopicAttachments = z.infer<typeof DiscussionTopicAttachmentsSchema>;
+export type DiscussionTopicText = z.infer<typeof DiscussionTopicTextSchema>;
+export type DiscussionTopic = z.infer<typeof DiscussionTopicSchema>;
+export type DiscussionTopicDocument = z.infer<typeof DiscussionTopicDocumentSchema>;

package/src/common-cartridge/v1_3/ccv1p3_imswl_v1p3.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+
+import { NonEmptyStringSchema, UriReferenceSchema, XmlExtensionNodeListSchema, strictObject } from "./shared";
+
+export const WebLinkUrlSchema = strictObject({
+  href: UriReferenceSchema,
+  target: z.string().optional(),
+  windowFeatures: z.string().optional(),
+});
+
+export const WebLinkSchema = strictObject({
+  title: NonEmptyStringSchema,
+  url: WebLinkUrlSchema,
+  extensions: XmlExtensionNodeListSchema.optional(),
+});
+
+export const WebLinkDocumentSchema = strictObject({
+  webLink: WebLinkSchema,
+});
+// Inferred types from exported Zod validators.
+export type WebLinkUrl = z.infer<typeof WebLinkUrlSchema>;
+export type WebLink = z.infer<typeof WebLinkSchema>;
+export type WebLinkDocument = z.infer<typeof WebLinkDocumentSchema>;

package/src/common-cartridge/v1_3/ccv1p3_lomccltilink_v1p0.ts

@@ -0,0 +1,14 @@
+import type { z } from "zod";
+import { strictObject } from "./shared";
+import { LomCcLtiLinkProfileSchemas } from "./lom-internal";
+
+export { LomCcLtiLinkProfileSchemas } from "./lom-internal";
+
+export const LomCcLtiLinkSchema = LomCcLtiLinkProfileSchemas.LomSchema;
+
+export const LomCcLtiLinkDocumentSchema = strictObject({
+  lom: LomCcLtiLinkSchema,
+});
+// Inferred types from exported Zod validators.
+export type LomCcLtiLink = z.infer<typeof LomCcLtiLinkSchema>;
+export type LomCcLtiLinkDocument = z.infer<typeof LomCcLtiLinkDocumentSchema>;

package/src/common-cartridge/v1_3/ccv1p3_lommanifest_v1p0.ts

@@ -0,0 +1,14 @@
+import type { z } from "zod";
+import { strictObject } from "./shared";
+import { LomManifestProfileSchemas } from "./lom-internal";
+
+export { LomManifestProfileSchemas } from "./lom-internal";
+
+export const LomManifestSchema = LomManifestProfileSchemas.LomSchema;
+
+export const LomManifestDocumentSchema = strictObject({
+  lom: LomManifestSchema,
+});
+// Inferred types from exported Zod validators.
+export type LomManifest = z.infer<typeof LomManifestSchema>;
+export type LomManifestDocument = z.infer<typeof LomManifestDocumentSchema>;

package/src/common-cartridge/v1_3/ccv1p3_lomresource_v1p0.ts

@@ -0,0 +1,14 @@
+import type { z } from "zod";
+import { strictObject } from "./shared";
+import { LomResourceProfileSchemas } from "./lom-internal";
+
+export { LomResourceProfileSchemas } from "./lom-internal";
+
+export const LomResourceSchema = LomResourceProfileSchemas.LomSchema;
+
+export const LomResourceDocumentSchema = strictObject({
+  lom: LomResourceSchema,
+});
+// Inferred types from exported Zod validators.
+export type LomResource = z.infer<typeof LomResourceSchema>;
+export type LomResourceDocument = z.infer<typeof LomResourceDocumentSchema>;