@conform-ed/contracts 0.0.3

package/src/common-cartridge/v1_4/shared/imsbasiclti_v1p0p1.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+import { NonEmptyStringSchema, UriReferenceSchema, strictObject } from "../shared";
+import { PlatformPropertySetSchema, PropertySetSchema } from "./imslticm_v1p0";
+import { IconSchema, VendorSchema } from "./imslticp_v1p0";
+
+export const BasicLTILinkSchema = strictObject({
+  title: NonEmptyStringSchema,
+  description: z.string().optional(),
+  custom: PropertySetSchema.optional(),
+  extensions: z.array(PlatformPropertySetSchema).optional(),
+  launch_url: UriReferenceSchema.optional(),
+  secure_launch_url: UriReferenceSchema.optional(),
+  icon: IconSchema.optional(),
+  secure_icon: IconSchema.optional(),
+  vendor: VendorSchema,
+});
+
+export const BasicLTILinkDocumentSchema = strictObject({
+  basic_lti_link: BasicLTILinkSchema,
+});
+// Inferred types from exported Zod validators.
+export type BasicLTILink = z.infer<typeof BasicLTILinkSchema>;
+export type BasicLTILinkDocument = z.infer<typeof BasicLTILinkDocumentSchema>;

package/src/common-cartridge/v1_4/shared/imslticm_v1p0.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+
+import { NonEmptyStringSchema, XmlForeignAttributesSchema, strictObject } from "../shared";
+
+export const PropertySchema = strictObject({
+  value: z.string(),
+  name: NonEmptyStringSchema,
+  foreignAttributes: XmlForeignAttributesSchema.optional(),
+});
+
+export const PropertySetSchema = strictObject({
+  property: z.array(PropertySchema).optional(),
+});
+
+export const PlatformPropertySetSchema = strictObject({
+  property: z.array(PropertySchema).optional(),
+  platform: NonEmptyStringSchema,
+  foreignAttributes: XmlForeignAttributesSchema.optional(),
+});
+// Inferred types from exported Zod validators.
+export type Property = z.infer<typeof PropertySchema>;
+export type PropertySet = z.infer<typeof PropertySetSchema>;
+export type PlatformPropertySet = z.infer<typeof PlatformPropertySetSchema>;

package/src/common-cartridge/v1_4/shared/imslticp_v1p0.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+
+import {
+  NonEmptyStringSchema,
+  UriReferenceSchema,
+  XmlExtensionNodeListSchema,
+  XmlForeignAttributesSchema,
+  strictObject,
+} from "../shared";
+
+export const LocalizedStringSchema = strictObject({
+  value: z.string(),
+  key: NonEmptyStringSchema.optional(),
+  foreignAttributes: XmlForeignAttributesSchema.optional(),
+});
+
+export const ContactSchema = strictObject({
+  email: NonEmptyStringSchema,
+  extensions: XmlExtensionNodeListSchema.optional(),
+});
+
+export const VendorSchema = strictObject({
+  code: NonEmptyStringSchema,
+  name: LocalizedStringSchema,
+  description: LocalizedStringSchema.optional(),
+  url: UriReferenceSchema.optional(),
+  contact: ContactSchema.optional(),
+});
+
+export const ProductInfoSchema = strictObject({
+  code: NonEmptyStringSchema,
+  name: LocalizedStringSchema,
+  version: NonEmptyStringSchema,
+  description: LocalizedStringSchema.optional(),
+  technical_description: LocalizedStringSchema.optional(),
+});
+
+export const ToolLocatorSchema = strictObject({
+  vendor: VendorSchema,
+  tool_info: ProductInfoSchema,
+  deployment_url: UriReferenceSchema,
+});
+
+export const IconSchema = strictObject({
+  value: UriReferenceSchema,
+  key: NonEmptyStringSchema.optional(),
+  platform: NonEmptyStringSchema.optional(),
+  style: NonEmptyStringSchema.optional(),
+  foreignAttributes: XmlForeignAttributesSchema.optional(),
+});
+// Inferred types from exported Zod validators.
+export type LocalizedString = z.infer<typeof LocalizedStringSchema>;
+export type Contact = z.infer<typeof ContactSchema>;
+export type Vendor = z.infer<typeof VendorSchema>;
+export type ProductInfo = z.infer<typeof ProductInfoSchema>;
+export type ToolLocator = z.infer<typeof ToolLocatorSchema>;
+export type Icon = z.infer<typeof IconSchema>;

package/src/common-cartridge/v1_4/shared/lineitem_v1p0.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+
+import { NonEmptyStringSchema, UriReferenceSchema, XmlForeignAttributesSchema, strictObject } from "../shared";
+
+export const AgsExtensionPropertyJsonTypeSchema = z.enum(["string", "number", "boolean", "object", "array", "other"]);
+
+export const AgsExtensionPropertySchema = strictObject({
+  value: z.string(),
+  name: NonEmptyStringSchema,
+  jsonType: AgsExtensionPropertyJsonTypeSchema.optional(),
+  foreignAttributes: XmlForeignAttributesSchema.optional(),
+});
+
+export const AgsExtensionsSchema = strictObject({
+  property: z.array(AgsExtensionPropertySchema).optional(),
+  claim: UriReferenceSchema,
+});
+
+export const LineItemSchema = strictObject({
+  scoreMaximum: z.number(),
+  label: z.string(),
+  resourceId: z.string().optional(),
+  tag: z.string().optional(),
+  extensions: z.array(AgsExtensionsSchema).optional(),
+});
+
+export const LineItemDocumentSchema = strictObject({
+  lineItem: LineItemSchema,
+});
+// Inferred types from exported Zod validators.
+export type AgsExtensionPropertyJsonType = z.infer<typeof AgsExtensionPropertyJsonTypeSchema>;
+export type AgsExtensionProperty = z.infer<typeof AgsExtensionPropertySchema>;
+export type AgsExtensions = z.infer<typeof AgsExtensionsSchema>;
+export type LineItem = z.infer<typeof LineItemSchema>;
+export type LineItemDocument = z.infer<typeof LineItemDocumentSchema>;

package/src/common-cartridge/v1_4/shared/resourcea11ymetadata-20210915.ts

@@ -0,0 +1,110 @@
+import { z } from "zod";
+
+import { strictObject } from "../shared";
+
+export const AccessibilityFeatureSchema = z.enum([
+  "alternativeText",
+  "annotations",
+  "audioDescription",
+  "bookmarks",
+  "braille",
+  "captions",
+  "ChemML",
+  "describedMath",
+  "displayTransformability",
+  "highContrastAudio",
+  "highContrastDisplay",
+  "index",
+  "largePrint",
+  "latex",
+  "longDescription",
+  "MathML",
+  "none",
+  "printPageNumbers",
+  "readingOrder",
+  "rubyAnnotations",
+  "signLanguage",
+  "structuralNavigation",
+  "synchronizedAudioText",
+  "tableOfContents",
+  "taggedPDF",
+  "tactileGraphic",
+  "tactileObject",
+  "timingControl",
+  "transcript",
+  "ttsMarkup",
+  "unlocked",
+]);
+
+export const AccessibilityHazardSchema = z.enum([
+  "flashing",
+  "noFlashingHazard",
+  "motionSimulation",
+  "noMotionSimulationHazard",
+  "sound",
+  "noSoundHazard",
+  "unknown",
+  "none",
+]);
+
+export const AccessibilityApiSchema = z.enum([
+  "AndroidAccessibility",
+  "ARIA",
+  "ATK",
+  "AT-SPI",
+  "BlackberryAccessibility",
+  "iAccessible2",
+  "iOSAccessibility",
+  "JavaAccessibility",
+  "MacOSXAccessibility",
+  "MSAA",
+  "UIAutomation",
+]);
+
+export const AccessibilityControlSchema = z.enum([
+  "fullKeyboardControl",
+  "fullMouseControl",
+  "fullSwitchControl",
+  "fullTouchControl",
+  "fullVideoControl",
+  "fullVoiceControl",
+]);
+
+export const AccessModeSchema = z.enum([
+  "auditory",
+  "chartOnVisual",
+  "chemOnVisual",
+  "colorDependent",
+  "diagramOnVisual",
+  "mathOnVisual",
+  "musicOnVisual",
+  "tactile",
+  "textOnVisual",
+  "textual",
+  "visual",
+]);
+
+export const AccessModeSufficientSchema = z.enum(["auditory", "tactile", "textual", "visual"]);
+
+export const ResourceAccessibilityMetadataSchema = strictObject({
+  accessibilityFeature: z.array(AccessibilityFeatureSchema).optional(),
+  accessibilityHazard: z.array(AccessibilityHazardSchema).optional(),
+  accessibilityAPI: z.array(AccessibilityApiSchema).optional(),
+  accessibilityControl: z.array(AccessibilityControlSchema).optional(),
+  accessMode: z.array(AccessModeSchema).optional(),
+  accessModeSufficient: z.array(AccessModeSufficientSchema).optional(),
+  accessibilitySummary: z.array(z.string()).optional(),
+});
+
+export const ResourceAccessibilityMetadataDocumentSchema = strictObject({
+  ResourceAccessibilityMetadata: ResourceAccessibilityMetadataSchema,
+});
+// Inferred types from exported Zod validators.
+export type AccessibilityFeature = z.infer<typeof AccessibilityFeatureSchema>;
+export type AccessibilityHazard = z.infer<typeof AccessibilityHazardSchema>;
+export type AccessibilityApi = z.infer<typeof AccessibilityApiSchema>;
+export type AccessibilityControl = z.infer<typeof AccessibilityControlSchema>;
+export type AccessMode = z.infer<typeof AccessModeSchema>;
+export type AccessModeSufficient = z.infer<typeof AccessModeSufficientSchema>;
+export type ResourceAccessibilityMetadata = z.infer<typeof ResourceAccessibilityMetadataSchema>;
+export type ResourceAccessibilityMetadataDocument = z.infer<typeof ResourceAccessibilityMetadataDocumentSchema>;

package/src/common-cartridge/v1_4/shared.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+
+export const NonEmptyStringSchema = z.string().min(1);
+export const UriReferenceSchema = z.string().min(1);
+export const YesNoSchema = z.enum(["Yes", "No"]);
+export const LowerYesNoSchema = z.enum(["yes", "no"]);
+export const XmlSpaceSchema = z.enum(["default", "preserve"]);
+export const XmlForeignAttributesSchema = z.record(z.string(), z.unknown());
+
+export const XmlExtensionNodeSchema = z
+  .object({
+    namespace: NonEmptyStringSchema,
+    name: NonEmptyStringSchema,
+    value: z.unknown().optional(),
+    attributes: XmlForeignAttributesSchema.optional(),
+    children: z.array(z.unknown()).optional(),
+  })
+  .strict();
+
+export const XmlExtensionNodeListSchema = z.array(XmlExtensionNodeSchema);
+
+export function strictObject<T extends z.ZodRawShape>(shape: T) {
+  return z.object(shape).strict();
+}
+
+export function looseObject<T extends z.ZodRawShape>(shape: T) {
+  return strictObject({
+    ...shape,
+    extensions: XmlExtensionNodeListSchema.optional(),
+    foreignAttributes: XmlForeignAttributesSchema.optional(),
+  });
+}
+
+export function addIssue(context: z.RefinementCtx, path: Array<string | number>, message: string) {
+  context.addIssue({
+    code: z.ZodIssueCode.custom,
+    path,
+    message,
+  });
+}
+
+export function collectDuplicates(values: string[]): string[] {
+  const seen = new Set<string>();
+  const duplicates = new Set<string>();
+
+  for (const value of values) {
+    if (seen.has(value)) {
+      duplicates.add(value);
+      continue;
+    }
+    seen.add(value);
+  }
+
+  return [...duplicates];
+}
+
+export function asArray<T>(value: readonly T[] | T[] | undefined | null): T[] {
+  return Array.isArray(value) ? [...value] : [];
+}
+// Inferred types from exported Zod validators.
+export type NonEmptyString = z.infer<typeof NonEmptyStringSchema>;
+export type UriReference = z.infer<typeof UriReferenceSchema>;
+export type YesNo = z.infer<typeof YesNoSchema>;
+export type LowerYesNo = z.infer<typeof LowerYesNoSchema>;
+export type XmlSpace = z.infer<typeof XmlSpaceSchema>;
+export type XmlForeignAttributes = z.infer<typeof XmlForeignAttributesSchema>;
+export type XmlExtensionNode = z.infer<typeof XmlExtensionNodeSchema>;
+export type XmlExtensionNodeList = z.infer<typeof XmlExtensionNodeListSchema>;

package/src/common-cartridge/v1_4/thin/ccv1p4_imscp_v1p2_v1p0.ts

@@ -0,0 +1,243 @@
+import { z } from "zod";
+
+import { CartridgeBasicLTILinkSchema } from "../shared/ccv1p4_imslticc_v1p4";
+import { CurriculumStandardsMetadataSetSchema } from "../shared/ccv1p4_imscsmd_v1p1";
+import { WebLinkSchema } from "../shared/ccv1p4_imswl_v1p4";
+import {
+  NonEmptyStringSchema,
+  UriReferenceSchema,
+  addIssue,
+  asArray,
+  collectDuplicates,
+  strictObject,
+} from "../shared";
+import { ThinLomManifestSchema } from "./ccv1p4_lommanifest_v1p0";
+import { ThinLomResourceSchema } from "./ccv1p4_lomresource_v1p0";
+
+export const ThinCommonCartridgeResourceTypeSchema = z.enum(["imsbasiclti_xmlv1p4", "imswl_xmlv1p4"]);
+
+export const ThinCommonCartridgeIntendedUseSchema = z.enum(["assignment", "lessonplan", "syllabus", "unspecified"]);
+
+export const ThinCommonCartridgeFileSchema = strictObject({
+  href: UriReferenceSchema,
+});
+
+export const ThinCommonCartridgeItemSchema: z.ZodTypeAny = z.lazy(() =>
+  strictObject({
+    identifier: NonEmptyStringSchema,
+    identifierref: NonEmptyStringSchema.optional(),
+    title: z.string(),
+    item: z.array(ThinCommonCartridgeItemSchema).optional(),
+  }),
+);
+
+export const ThinCommonCartridgeItemOrgSchema: z.ZodTypeAny = z.lazy(() =>
+  strictObject({
+    identifier: NonEmptyStringSchema,
+    item: z.array(ThinCommonCartridgeItemSchema).optional(),
+  }),
+);
+
+export const ThinCommonCartridgeOrganizationSchema = strictObject({
+  identifier: NonEmptyStringSchema,
+  structure: z.literal("rooted-hierarchy"),
+  title: z.string().optional(),
+  item: ThinCommonCartridgeItemOrgSchema,
+});
+
+export const ThinCommonCartridgeOrganizationsSchema = strictObject({
+  organization: ThinCommonCartridgeOrganizationSchema.optional(),
+});
+
+export const ThinCommonCartridgeManifestMetadataSchema = strictObject({
+  schema: z.enum(["IMS Thin Common Cartridge", "IMS K-12 Thin Common Cartridge"]),
+  schemaversion: z.literal("1.4.0"),
+  lom: ThinLomManifestSchema,
+  curriculumStandardsMetadataSet: CurriculumStandardsMetadataSetSchema.optional(),
+});
+
+export const ThinCommonCartridgeResourceMetadataSchema = strictObject({
+  schema: z.string().optional(),
+  schemaversion: z.string().optional(),
+  lom: ThinLomResourceSchema.optional(),
+  curriculumStandardsMetadataSet: z.array(CurriculumStandardsMetadataSetSchema).optional(),
+});
+
+export const ThinCommonCartridgeResourceSchema = strictObject({
+  identifier: NonEmptyStringSchema,
+  type: ThinCommonCartridgeResourceTypeSchema,
+  href: UriReferenceSchema.optional(),
+  xmlBase: z.string().optional(),
+  intendeduse: ThinCommonCartridgeIntendedUseSchema.optional(),
+  metadata: ThinCommonCartridgeResourceMetadataSchema.optional(),
+  file: z.array(ThinCommonCartridgeFileSchema).optional(),
+  cartridge_basiclti_link: CartridgeBasicLTILinkSchema.optional(),
+  webLink: WebLinkSchema.optional(),
+});
+
+export const ThinCommonCartridgeResourcesSchema = strictObject({
+  xmlBase: z.string().optional(),
+  resource: z.array(ThinCommonCartridgeResourceSchema).optional(),
+});
+
+export const ThinCommonCartridgeManifestRawSchema = strictObject({
+  identifier: NonEmptyStringSchema,
+  xmlBase: z.string().optional(),
+  metadata: ThinCommonCartridgeManifestMetadataSchema,
+  organizations: ThinCommonCartridgeOrganizationsSchema,
+  resources: ThinCommonCartridgeResourcesSchema,
+});
+
+type ThinCommonCartridgeTraversalItem = {
+  identifier: string;
+  identifierref?: string;
+  item?: ThinCommonCartridgeTraversalItem[];
+};
+
+type ThinCommonCartridgeTraversalManifest = {
+  organizations: {
+    organization?: {
+      item: {
+        item?: ThinCommonCartridgeTraversalItem[];
+      };
+    };
+  };
+};
+
+function walkThinCommonCartridgeItems(
+  item: ThinCommonCartridgeTraversalItem,
+  visit: (candidate: ThinCommonCartridgeTraversalItem) => void,
+) {
+  visit(item);
+  for (const child of asArray(item.item)) {
+    walkThinCommonCartridgeItems(child, visit);
+  }
+}
+
+function collectThinCommonCartridgeItems(
+  manifest: ThinCommonCartridgeTraversalManifest,
+): ThinCommonCartridgeTraversalItem[] {
+  const items: ThinCommonCartridgeTraversalItem[] = [];
+  const rootItem = manifest.organizations.organization?.item;
+
+  if (!rootItem) {
+    return items;
+  }
+
+  for (const child of asArray(rootItem.item)) {
+    walkThinCommonCartridgeItems(child, (candidate) => {
+      items.push(candidate);
+    });
+  }
+
+  return items;
+}
+
+export const ThinCommonCartridgeManifestProfileSchema = ThinCommonCartridgeManifestRawSchema.superRefine(
+  (manifest, context) => {
+    const resources = asArray(manifest.resources.resource);
+
+    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);
+
+      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}`,
+        );
+      }
+
+      const hasBasicLti = Boolean(resource.cartridge_basiclti_link);
+      const hasWebLink = Boolean(resource.webLink);
+
+      if (resource.type === "imsbasiclti_xmlv1p4" && !hasBasicLti) {
+        addIssue(
+          context,
+          ["resources", "resource", resourceIndex, "cartridge_basiclti_link"],
+          `Thin resource ${resource.identifier} must contain cartridge_basiclti_link when type is imsbasiclti_xmlv1p4.`,
+        );
+      }
+
+      if (resource.type === "imswl_xmlv1p4" && !hasWebLink) {
+        addIssue(
+          context,
+          ["resources", "resource", resourceIndex, "webLink"],
+          `Thin resource ${resource.identifier} must contain webLink when type is imswl_xmlv1p4.`,
+        );
+      }
+
+      if (resource.type === "imsbasiclti_xmlv1p4" && hasWebLink) {
+        addIssue(
+          context,
+          ["resources", "resource", resourceIndex, "webLink"],
+          `Thin resource ${resource.identifier} must not contain webLink when type is imsbasiclti_xmlv1p4.`,
+        );
+      }
+
+      if (resource.type === "imswl_xmlv1p4" && hasBasicLti) {
+        addIssue(
+          context,
+          ["resources", "resource", resourceIndex, "cartridge_basiclti_link"],
+          `Thin resource ${resource.identifier} must not contain cartridge_basiclti_link when type is imswl_xmlv1p4.`,
+        );
+      }
+
+      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.`,
+        );
+      }
+    });
+
+    const items = collectThinCommonCartridgeItems(manifest as ThinCommonCartridgeTraversalManifest);
+
+    items.forEach((item, itemIndex) => {
+      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 ThinCommonCartridgeManifestRawDocumentSchema = strictObject({
+  manifest: ThinCommonCartridgeManifestRawSchema,
+});
+
+export const ThinCommonCartridgeManifestProfileDocumentSchema = strictObject({
+  manifest: ThinCommonCartridgeManifestProfileSchema,
+});
+// Inferred types from exported Zod validators.
+export type ThinCommonCartridgeResourceType = z.infer<typeof ThinCommonCartridgeResourceTypeSchema>;
+export type ThinCommonCartridgeIntendedUse = z.infer<typeof ThinCommonCartridgeIntendedUseSchema>;
+export type ThinCommonCartridgeFile = z.infer<typeof ThinCommonCartridgeFileSchema>;
+export type ThinCommonCartridgeOrganization = z.infer<typeof ThinCommonCartridgeOrganizationSchema>;
+export type ThinCommonCartridgeOrganizations = z.infer<typeof ThinCommonCartridgeOrganizationsSchema>;
+export type ThinCommonCartridgeManifestMetadata = z.infer<typeof ThinCommonCartridgeManifestMetadataSchema>;
+export type ThinCommonCartridgeResourceMetadata = z.infer<typeof ThinCommonCartridgeResourceMetadataSchema>;
+export type ThinCommonCartridgeResource = z.infer<typeof ThinCommonCartridgeResourceSchema>;
+export type ThinCommonCartridgeResources = z.infer<typeof ThinCommonCartridgeResourcesSchema>;
+export type ThinCommonCartridgeManifestRaw = z.infer<typeof ThinCommonCartridgeManifestRawSchema>;
+export type ThinCommonCartridgeManifestProfile = z.infer<typeof ThinCommonCartridgeManifestProfileSchema>;
+export type ThinCommonCartridgeManifestRawDocument = z.infer<typeof ThinCommonCartridgeManifestRawDocumentSchema>;
+export type ThinCommonCartridgeManifestProfileDocument = z.infer<
+  typeof ThinCommonCartridgeManifestProfileDocumentSchema
+>;

package/src/common-cartridge/v1_4/thin/ccv1p4_lommanifest_v1p0.ts

@@ -0,0 +1,14 @@
+import type { z } from "zod";
+import { strictObject } from "../shared";
+import { LomThinManifestProfileSchemas } from "../lom-internal";
+
+export { LomThinManifestProfileSchemas } from "../lom-internal";
+
+export const ThinLomManifestSchema = LomThinManifestProfileSchemas.LomSchema;
+
+export const ThinLomManifestDocumentSchema = strictObject({
+  lom: ThinLomManifestSchema,
+});
+// Inferred types from exported Zod validators.
+export type ThinLomManifest = z.infer<typeof ThinLomManifestSchema>;
+export type ThinLomManifestDocument = z.infer<typeof ThinLomManifestDocumentSchema>;

package/src/common-cartridge/v1_4/thin/ccv1p4_lomresource_v1p0.ts

@@ -0,0 +1,14 @@
+import type { z } from "zod";
+import { strictObject } from "../shared";
+import { LomThinResourceProfileSchemas } from "../lom-internal";
+
+export { LomThinResourceProfileSchemas } from "../lom-internal";
+
+export const ThinLomResourceSchema = LomThinResourceProfileSchemas.LomSchema;
+
+export const ThinLomResourceDocumentSchema = strictObject({
+  lom: ThinLomResourceSchema,
+});
+// Inferred types from exported Zod validators.
+export type ThinLomResource = z.infer<typeof ThinLomResourceSchema>;
+export type ThinLomResourceDocument = z.infer<typeof ThinLomResourceDocumentSchema>;

package/src/common-cartridge/v1_4/vdex/imsmd_loose_v1p3p2.ts

@@ -0,0 +1,13 @@
+import type { z } from "zod";
+import { strictObject } from "../shared";
+import { LomManifestProfileSchemas } from "../lom-internal";
+
+export { LomManifestProfileSchemas } from "../lom-internal";
+
+export const ImsMdLooseLomSchema = LomManifestProfileSchemas.LomSchema;
+export const ImsMdLooseLomDocumentSchema = strictObject({
+  lom: ImsMdLooseLomSchema,
+});
+// Inferred types from exported Zod validators.
+export type ImsMdLooseLom = z.infer<typeof ImsMdLooseLomSchema>;
+export type ImsMdLooseLomDocument = z.infer<typeof ImsMdLooseLomDocumentSchema>;