@conform-ed/contracts 0.0.3

package/src/qti/v3_0_1/imsqti_asiv3p0p1_v1p0.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+
+export * from "./assessment-internal";
+export * from "./variables-internal";
+export * from "./processing-internal";
+
+import { strictObject } from "./shared";
+import { QtiAssessmentItemSchema, QtiAssessmentStimulusSchema, QtiAssessmentTestSchema } from "./assessment-internal";
+import { QtiOutcomeDeclarationSchema } from "./variables-internal";
+import { QtiResponseProcessingDocumentSchema } from "./imsqti_responseprocessingv3p0p1_v1p0";
+import { QtiAssessmentSectionDocumentSchema, QtiAssessmentSectionSchema } from "./imsqti_sectionv3p0p1_v1p0";
+import { QtiAssessmentStimulusDocumentSchema } from "./imsqti_stimulusv3p0p1_v1p0";
+import { QtiOutcomeDeclarationDocumentSchema } from "./imsqti_outcomev3p0p1_v1p0";
+import { QtiAssessmentItemDocumentSchema } from "./imsqti_itemv3p0p1_v1p0";
+import { QtiAssessmentTestDocumentSchema, QtiOutcomeProcessingDocumentSchema } from "./imsqti_testv3p0p1_v1p0";
+
+export const QtiAssessmentItemDocumentSchemaAlias = QtiAssessmentItemDocumentSchema;
+export const QtiAssessmentSectionDocumentSchemaAlias = QtiAssessmentSectionDocumentSchema;
+export const QtiAssessmentStimulusDocumentSchemaAlias = QtiAssessmentStimulusDocumentSchema;
+export const QtiAssessmentTestDocumentSchemaAlias = QtiAssessmentTestDocumentSchema;
+
+export const QtiAssessmentItemStandaloneDocumentSchema = strictObject({
+  assessmentItem: QtiAssessmentItemSchema,
+});
+
+export const QtiAssessmentSectionStandaloneDocumentSchema = strictObject({
+  assessmentSection: QtiAssessmentSectionSchema,
+});
+
+export const QtiAssessmentStimulusStandaloneDocumentSchema = strictObject({
+  assessmentStimulus: QtiAssessmentStimulusSchema,
+});
+
+export const QtiAssessmentTestStandaloneDocumentSchema = strictObject({
+  assessmentTest: QtiAssessmentTestSchema,
+});
+
+export const QtiOutcomeDeclarationStandaloneDocumentSchema = strictObject({
+  outcomeDeclaration: QtiOutcomeDeclarationSchema,
+});
+
+export const QtiAsiProfileDocumentSchema = z.union([
+  QtiAssessmentItemDocumentSchema,
+  QtiAssessmentSectionDocumentSchema,
+  QtiAssessmentStimulusDocumentSchema,
+  QtiAssessmentTestDocumentSchema,
+  QtiOutcomeDeclarationDocumentSchema,
+  QtiOutcomeProcessingDocumentSchema,
+  QtiResponseProcessingDocumentSchema,
+]);
+// Inferred types from exported Zod validators.
+export type QtiAssessmentItemStandaloneDocument = z.infer<typeof QtiAssessmentItemStandaloneDocumentSchema>;
+export type QtiAssessmentSectionStandaloneDocument = z.infer<typeof QtiAssessmentSectionStandaloneDocumentSchema>;
+export type QtiAssessmentStimulusStandaloneDocument = z.infer<typeof QtiAssessmentStimulusStandaloneDocumentSchema>;
+export type QtiAssessmentTestStandaloneDocument = z.infer<typeof QtiAssessmentTestStandaloneDocumentSchema>;
+export type QtiOutcomeDeclarationStandaloneDocument = z.infer<typeof QtiOutcomeDeclarationStandaloneDocumentSchema>;
+export type QtiAsiProfileDocument = z.infer<typeof QtiAsiProfileDocumentSchema>;

package/src/qti/v3_0_1/imsqti_itemv3p0p1_v1p0.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+
+export {
+  QtiAssessmentItemRawSchema,
+  QtiAssessmentItemRefSchema,
+  QtiAssessmentItemSchema,
+  QtiAssessmentStimulusRefSchema,
+  QtiChoiceInteractionSchema,
+  QtiCompanionMaterialsInfoSchema,
+  QtiExtendedTextInteractionSchema,
+  QtiGapMatchInteractionSchema,
+  QtiHotTextInteractionSchema,
+  QtiHotspotInteractionSchema,
+  QtiInlineChoiceInteractionSchema,
+  QtiItemBodySchema,
+  QtiMatchInteractionSchema,
+  QtiMediaInteractionSchema,
+  QtiModalFeedbackSchema,
+  QtiOrderInteractionSchema,
+  QtiTextEntryInteractionSchema,
+  QtiUploadInteractionSchema,
+} from "./assessment-internal";
+export {
+  QtiOutcomeDeclarationRawSchema,
+  QtiOutcomeDeclarationSchema,
+  QtiResponseDeclarationRawSchema,
+  QtiResponseDeclarationSchema,
+  QtiTemplateDeclarationSchema,
+} from "./variables-internal";
+export {
+  QtiResponseConditionSchema,
+  QtiResponseElseSchema,
+  QtiResponseIfSchema,
+  QtiResponseProcessingFragmentSchema,
+  QtiResponseProcessingSchema,
+  QtiTemplateConditionSchema,
+  QtiTemplateConstraintSchema,
+  QtiTemplateDefaultSchema,
+  QtiTemplateElseSchema,
+  QtiTemplateIfSchema,
+  QtiTemplateProcessingSchema,
+} from "./processing-internal";
+
+import { QtiAssessmentItemSchema } from "./assessment-internal";
+import { strictObject } from "./shared";
+import { QtiOutcomeDeclarationDocumentSchema } from "./imsqti_outcomev3p0p1_v1p0";
+import { QtiResponseProcessingDocumentSchema } from "./imsqti_responseprocessingv3p0p1_v1p0";
+
+export const QtiAssessmentItemDocumentSchema = strictObject({
+  assessmentItem: QtiAssessmentItemSchema,
+});
+
+export const QtiItemProfileDocumentSchema = z.union([
+  QtiAssessmentItemDocumentSchema,
+  QtiOutcomeDeclarationDocumentSchema,
+  QtiResponseProcessingDocumentSchema,
+]);
+// Inferred types from exported Zod validators.
+export type QtiAssessmentItemDocument = z.infer<typeof QtiAssessmentItemDocumentSchema>;
+export type QtiItemProfileDocument = z.infer<typeof QtiItemProfileDocumentSchema>;

package/src/qti/v3_0_1/imsqti_metadatav3p0_v1p0.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+
+import { strictObject } from "./shared";
+
+export const QtiMetadataInteractionTypeSchema = z.enum([
+  "associateInteraction",
+  "choiceInteraction",
+  "customInteraction",
+  "drawingInteraction",
+  "endAttemptInteraction",
+  "extendedTextInteraction",
+  "gapMatchInteraction",
+  "graphicAssociateInteraction",
+  "graphicGapMatchInteraction",
+  "graphicOrderInteraction",
+  "hotspotInteraction",
+  "hottextInteraction",
+  "inlineChoiceInteraction",
+  "matchInteraction",
+  "mediaInteraction",
+  "orderInteraction",
+  "portableCustomInteraction",
+  "positionObjectInteraction",
+  "selectPointInteraction",
+  "sliderInteraction",
+  "textEntryInteraction",
+  "uploadInteraction",
+]);
+
+export const QtiMetadataFeedbackTypeSchema = z.enum(["adaptive", "nonadaptive", "none"]);
+
+export const QtiMetadataScoringModeSchema = z.enum(["human", "externalmachine", "responseprocessing"]);
+
+export const QtiPortableCustomInteractionContextSchema = strictObject({
+  customTypeIdentifier: z.string().optional(),
+  interactionKind: z.string().optional(),
+});
+
+export const QtiMetadataSchema = strictObject({
+  itemTemplate: z.boolean().optional(),
+  timeDependent: z.boolean().optional(),
+  composite: z.boolean().optional(),
+  interactionType: z.array(QtiMetadataInteractionTypeSchema).optional(),
+  portableCustomInteractionContext: QtiPortableCustomInteractionContextSchema.optional(),
+  feedbackType: QtiMetadataFeedbackTypeSchema.optional(),
+  solutionAvailable: z.boolean().optional(),
+  scoringMode: z.array(QtiMetadataScoringModeSchema).optional(),
+  toolName: z.string().max(256).optional(),
+  toolVersion: z.string().max(256).optional(),
+  toolVendor: z.string().max(256).optional(),
+}).superRefine((value, context) => {
+  const hasPortableCustomInteraction = value.interactionType?.includes("portableCustomInteraction") ?? false;
+
+  if (value.portableCustomInteractionContext && !hasPortableCustomInteraction) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["portableCustomInteractionContext"],
+      message:
+        "portableCustomInteractionContext is only valid when interactionType includes portableCustomInteraction.",
+    });
+  }
+});
+
+export const QtiMetadataDocumentSchema = strictObject({
+  qtiMetadata: QtiMetadataSchema,
+});
+// Inferred types from exported Zod validators.
+export type QtiMetadataInteractionType = z.infer<typeof QtiMetadataInteractionTypeSchema>;
+export type QtiMetadataFeedbackType = z.infer<typeof QtiMetadataFeedbackTypeSchema>;
+export type QtiMetadataScoringMode = z.infer<typeof QtiMetadataScoringModeSchema>;
+export type QtiPortableCustomInteractionContext = z.infer<typeof QtiPortableCustomInteractionContextSchema>;
+export type QtiMetadata = z.infer<typeof QtiMetadataSchema>;
+export type QtiMetadataDocument = z.infer<typeof QtiMetadataDocumentSchema>;

package/src/qti/v3_0_1/imsqti_outcomev3p0p1_v1p0.ts

@@ -0,0 +1,11 @@
+import type { z } from "zod";
+export { QtiOutcomeDeclarationRawSchema, QtiOutcomeDeclarationSchema } from "./variables-internal";
+
+import { strictObject } from "./shared";
+import { QtiOutcomeDeclarationSchema } from "./variables-internal";
+
+export const QtiOutcomeDeclarationDocumentSchema = strictObject({
+  outcomeDeclaration: QtiOutcomeDeclarationSchema,
+});
+// Inferred types from exported Zod validators.
+export type QtiOutcomeDeclarationDocument = z.infer<typeof QtiOutcomeDeclarationDocumentSchema>;

package/src/qti/v3_0_1/imsqti_responseprocessingv3p0p1_v1p0.ts

@@ -0,0 +1,17 @@
+import type { z } from "zod";
+export {
+  QtiResponseConditionSchema,
+  QtiResponseElseSchema,
+  QtiResponseIfSchema,
+  QtiResponseProcessingFragmentSchema,
+  QtiResponseProcessingSchema,
+} from "./processing-internal";
+
+import { strictObject } from "./shared";
+import { QtiResponseProcessingSchema } from "./processing-internal";
+
+export const QtiResponseProcessingDocumentSchema = strictObject({
+  responseProcessing: QtiResponseProcessingSchema,
+});
+// Inferred types from exported Zod validators.
+export type QtiResponseProcessingDocument = z.infer<typeof QtiResponseProcessingDocumentSchema>;

package/src/qti/v3_0_1/imsqti_resultv3p0_v1p0.ts

@@ -0,0 +1,222 @@
+import { z } from "zod";
+
+import {
+  QtiAnsweredStatusSchema,
+  QtiBaseTypeSchema,
+  QtiCardinalitySchema,
+  QtiExternalScoredSchema,
+  QtiIdentifierListSchema,
+  QtiIdentifierSchema,
+  QtiScoreStatusSchema,
+  QtiSessionStatusSchema,
+  QtiSupportAssignmentSchema,
+  QtiViewSchema,
+  XmlExtensionNodeListSchema,
+  addIssue,
+  strictObject,
+} from "./shared";
+
+export const QtiResultValueSchema = strictObject({
+  value: z.string(),
+  fieldIdentifier: QtiIdentifierSchema.optional(),
+  baseType: QtiBaseTypeSchema.optional(),
+});
+
+export const QtiResultCandidateResponseSchema = strictObject({
+  values: z.array(QtiResultValueSchema).optional(),
+});
+
+export const QtiResultCorrectResponseSchema = strictObject({
+  values: z.array(QtiResultValueSchema).min(1),
+  interpretation: z.string().optional(),
+});
+
+export const QtiResultSessionIdentifierSchema = strictObject({
+  sourceId: z.string(),
+  identifier: QtiIdentifierSchema,
+});
+
+export const QtiResultContextSchema = strictObject({
+  sourcedId: QtiIdentifierSchema.optional(),
+  sessionIdentifiers: z.array(QtiResultSessionIdentifierSchema).optional(),
+});
+
+export const QtiResultSupportSchema = strictObject({
+  name: z.string().min(1),
+  assignment: QtiSupportAssignmentSchema,
+  value: z.string().optional(),
+  xmlLang: z.string().optional(),
+});
+
+const QtiResultVariableBaseShape = {
+  identifier: QtiIdentifierSchema,
+  cardinality: QtiCardinalitySchema,
+  baseType: QtiBaseTypeSchema.optional(),
+  values: z.array(QtiResultValueSchema).optional(),
+};
+
+export const QtiResultContextVariableSchema = strictObject({
+  ...QtiResultVariableBaseShape,
+});
+
+export const QtiResultTemplateVariableSchema = strictObject({
+  ...QtiResultVariableBaseShape,
+});
+
+export const QtiResultOutcomeInformationSchema = strictObject({
+  extensions: XmlExtensionNodeListSchema.optional(),
+});
+
+export const QtiResultOutcomeVariableSchema = strictObject({
+  ...QtiResultVariableBaseShape,
+  outcomeInformation: QtiResultOutcomeInformationSchema.optional(),
+  view: z.array(QtiViewSchema).optional(),
+  interpretation: z.string().optional(),
+  longInterpretation: z.string().optional(),
+  normalMaximum: z.number().optional(),
+  normalMinimum: z.number().optional(),
+  masteryValue: z.number().optional(),
+  externalScored: QtiExternalScoredSchema.optional(),
+  variableIdentifierRef: QtiIdentifierSchema.optional(),
+});
+
+export const QtiResultResponseVariableSchema = strictObject({
+  ...QtiResultVariableBaseShape,
+  correctResponse: QtiResultCorrectResponseSchema.optional(),
+  candidateResponse: QtiResultCandidateResponseSchema,
+  extensions: XmlExtensionNodeListSchema.optional(),
+  choiceSequence: QtiIdentifierListSchema.optional(),
+  scoreStatus: QtiScoreStatusSchema.optional(),
+  answeredStatus: QtiAnsweredStatusSchema.optional(),
+});
+
+function validateValuesForCardinality(
+  values: readonly z.infer<typeof QtiResultValueSchema>[] | undefined,
+  cardinality: z.infer<typeof QtiCardinalitySchema>,
+  context: z.RefinementCtx,
+  path: Array<string | number>,
+) {
+  if (!values?.length) {
+    return;
+  }
+
+  if (cardinality === "record") {
+    for (const [index, value] of values.entries()) {
+      if (!value.fieldIdentifier) {
+        addIssue(
+          context,
+          [...path, index, "fieldIdentifier"],
+          "Record-valued result entries must define fieldIdentifier.",
+        );
+      }
+    }
+    return;
+  }
+
+  for (const [index, value] of values.entries()) {
+    if (value.fieldIdentifier) {
+      addIssue(
+        context,
+        [...path, index, "fieldIdentifier"],
+        "fieldIdentifier is only valid for record-valued results.",
+      );
+    }
+  }
+}
+
+function createVariableSuperRefine(valueKey: "values" | "candidateResponse", candidateResponseKey?: "values") {
+  return (
+    value: {
+      cardinality: z.infer<typeof QtiCardinalitySchema>;
+      baseType?: z.infer<typeof QtiBaseTypeSchema>;
+      values?: readonly z.infer<typeof QtiResultValueSchema>[];
+      candidateResponse?: { values?: readonly z.infer<typeof QtiResultValueSchema>[] };
+    },
+    context: z.RefinementCtx,
+  ) => {
+    if (value.cardinality === "record" && value.baseType) {
+      addIssue(context, ["baseType"], "baseType must be omitted when cardinality is record.");
+    }
+
+    if (valueKey === "values") {
+      validateValuesForCardinality(value.values, value.cardinality, context, ["values"]);
+      return;
+    }
+
+    validateValuesForCardinality(
+      value.candidateResponse?.[candidateResponseKey ?? "values"],
+      value.cardinality,
+      context,
+      ["candidateResponse", candidateResponseKey ?? "values"],
+    );
+  };
+}
+
+export const QtiResultOutcomeVariableValidatedSchema = QtiResultOutcomeVariableSchema.superRefine(
+  createVariableSuperRefine("values"),
+);
+
+export const QtiResultContextVariableValidatedSchema = QtiResultContextVariableSchema.superRefine(
+  createVariableSuperRefine("values"),
+);
+
+export const QtiResultTemplateVariableValidatedSchema = QtiResultTemplateVariableSchema.superRefine(
+  createVariableSuperRefine("values"),
+);
+
+export const QtiResultResponseVariableValidatedSchema = QtiResultResponseVariableSchema.superRefine(
+  createVariableSuperRefine("candidateResponse", "values"),
+);
+
+export const QtiResultTestResultSchema = strictObject({
+  identifier: QtiIdentifierSchema,
+  datestamp: z.string(),
+  responseVariables: z.array(QtiResultResponseVariableValidatedSchema).optional(),
+  templateVariables: z.array(QtiResultTemplateVariableValidatedSchema).optional(),
+  outcomeVariables: z.array(QtiResultOutcomeVariableValidatedSchema).optional(),
+  contextVariables: z.array(QtiResultContextVariableValidatedSchema).optional(),
+  supports: z.array(QtiResultSupportSchema).optional(),
+});
+
+export const QtiResultItemResultSchema = strictObject({
+  identifier: QtiIdentifierSchema,
+  sequenceIndex: z.number().int().optional(),
+  datestamp: z.string(),
+  sessionStatus: QtiSessionStatusSchema,
+  responseVariables: z.array(QtiResultResponseVariableValidatedSchema).optional(),
+  templateVariables: z.array(QtiResultTemplateVariableValidatedSchema).optional(),
+  outcomeVariables: z.array(QtiResultOutcomeVariableValidatedSchema).optional(),
+  contextVariables: z.array(QtiResultContextVariableValidatedSchema).optional(),
+  candidateComment: z.string().optional(),
+  supports: z.array(QtiResultSupportSchema).optional(),
+});
+
+export const QtiAssessmentResultSchema = strictObject({
+  context: QtiResultContextSchema,
+  testResult: QtiResultTestResultSchema.optional(),
+  itemResults: z.array(QtiResultItemResultSchema).optional(),
+});
+
+export const QtiAssessmentResultDocumentSchema = strictObject({
+  assessmentResult: QtiAssessmentResultSchema,
+});
+// Inferred types from exported Zod validators.
+export type QtiResultValue = z.infer<typeof QtiResultValueSchema>;
+export type QtiResultCandidateResponse = z.infer<typeof QtiResultCandidateResponseSchema>;
+export type QtiResultCorrectResponse = z.infer<typeof QtiResultCorrectResponseSchema>;
+export type QtiResultSessionIdentifier = z.infer<typeof QtiResultSessionIdentifierSchema>;
+export type QtiResultContext = z.infer<typeof QtiResultContextSchema>;
+export type QtiResultSupport = z.infer<typeof QtiResultSupportSchema>;
+export type QtiResultContextVariable = z.infer<typeof QtiResultContextVariableSchema>;
+export type QtiResultTemplateVariable = z.infer<typeof QtiResultTemplateVariableSchema>;
+export type QtiResultOutcomeInformation = z.infer<typeof QtiResultOutcomeInformationSchema>;
+export type QtiResultOutcomeVariable = z.infer<typeof QtiResultOutcomeVariableSchema>;
+export type QtiResultResponseVariable = z.infer<typeof QtiResultResponseVariableSchema>;
+export type QtiResultOutcomeVariableValidated = z.infer<typeof QtiResultOutcomeVariableValidatedSchema>;
+export type QtiResultContextVariableValidated = z.infer<typeof QtiResultContextVariableValidatedSchema>;
+export type QtiResultTemplateVariableValidated = z.infer<typeof QtiResultTemplateVariableValidatedSchema>;
+export type QtiResultResponseVariableValidated = z.infer<typeof QtiResultResponseVariableValidatedSchema>;
+export type QtiResultTestResult = z.infer<typeof QtiResultTestResultSchema>;
+export type QtiResultItemResult = z.infer<typeof QtiResultItemResultSchema>;
+export type QtiAssessmentResult = z.infer<typeof QtiAssessmentResultSchema>;
+export type QtiAssessmentResultDocument = z.infer<typeof QtiAssessmentResultDocumentSchema>;

package/src/qti/v3_0_1/imsqti_sectionv3p0p1_v1p0.ts

@@ -0,0 +1,15 @@
+import type { z } from "zod";
+export {
+  QtiAssessmentSectionRawSchema,
+  QtiAssessmentSectionRefSchema,
+  QtiAssessmentSectionSchema,
+} from "./assessment-internal";
+
+import { strictObject } from "./shared";
+import { QtiAssessmentSectionSchema } from "./assessment-internal";
+
+export const QtiAssessmentSectionDocumentSchema = strictObject({
+  assessmentSection: QtiAssessmentSectionSchema,
+});
+// Inferred types from exported Zod validators.
+export type QtiAssessmentSectionDocument = z.infer<typeof QtiAssessmentSectionDocumentSchema>;

package/src/qti/v3_0_1/imsqti_stimulusv3p0p1_v1p0.ts

@@ -0,0 +1,15 @@
+import type { z } from "zod";
+export {
+  QtiAssessmentStimulusRefSchema,
+  QtiAssessmentStimulusSchema,
+  QtiStimulusBodySchema,
+} from "./assessment-internal";
+
+import { strictObject } from "./shared";
+import { QtiAssessmentStimulusSchema } from "./assessment-internal";
+
+export const QtiAssessmentStimulusDocumentSchema = strictObject({
+  assessmentStimulus: QtiAssessmentStimulusSchema,
+});
+// Inferred types from exported Zod validators.
+export type QtiAssessmentStimulusDocument = z.infer<typeof QtiAssessmentStimulusDocumentSchema>;

package/src/qti/v3_0_1/imsqti_testv3p0p1_v1p0.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+
+export {
+  QtiAdaptiveSelectionSchema,
+  QtiAssessmentItemRefSchema,
+  QtiAssessmentSectionRawSchema,
+  QtiAssessmentSectionRefSchema,
+  QtiAssessmentSectionSchema,
+  QtiAssessmentTestRawSchema,
+  QtiAssessmentTestSchema,
+  QtiOrderingSchema,
+  QtiSelectionSchema,
+  QtiTestFeedbackSchema,
+  QtiTestPartSchema,
+  QtiTestRubricBlockSchema,
+} from "./assessment-internal";
+export { QtiOutcomeDeclarationRawSchema, QtiOutcomeDeclarationSchema } from "./variables-internal";
+export {
+  QtiOutcomeConditionSchema,
+  QtiOutcomeElseSchema,
+  QtiOutcomeIfSchema,
+  QtiOutcomeProcessingFragmentSchema,
+  QtiOutcomeProcessingSchema,
+} from "./processing-internal";
+
+import { QtiAssessmentTestSchema } from "./assessment-internal";
+import { QtiOutcomeProcessingSchema } from "./processing-internal";
+import { strictObject } from "./shared";
+import { QtiOutcomeDeclarationDocumentSchema } from "./imsqti_outcomev3p0p1_v1p0";
+import { QtiAssessmentSectionDocumentSchema } from "./imsqti_sectionv3p0p1_v1p0";
+
+export const QtiAssessmentTestDocumentSchema = strictObject({
+  assessmentTest: QtiAssessmentTestSchema,
+});
+
+export const QtiOutcomeProcessingDocumentSchema = strictObject({
+  outcomeProcessing: QtiOutcomeProcessingSchema,
+});
+
+export const QtiTestProfileDocumentSchema = z.union([
+  QtiAssessmentTestDocumentSchema,
+  QtiAssessmentSectionDocumentSchema,
+  QtiOutcomeDeclarationDocumentSchema,
+  QtiOutcomeProcessingDocumentSchema,
+]);
+// Inferred types from exported Zod validators.
+export type QtiAssessmentTestDocument = z.infer<typeof QtiAssessmentTestDocumentSchema>;
+export type QtiOutcomeProcessingDocument = z.infer<typeof QtiOutcomeProcessingDocumentSchema>;
+export type QtiTestProfileDocument = z.infer<typeof QtiTestProfileDocumentSchema>;

package/src/qti/v3_0_1/imsqti_usagedatav3p0_v1p0.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+
+import { QtiMapEntrySchema, QtiValueSchema } from "./variables-internal";
+import { QtiIdentifierSchema, UriReferenceSchema, addIssue, strictObject } from "./shared";
+
+export const QtiUsageDateSchema = z.iso.date();
+
+export const QtiUsageObjectTypeSchema = z.enum([
+  "test",
+  "testpart",
+  "section",
+  "item",
+  "outcome",
+  "interaction",
+  "choice",
+]);
+
+export const QtiUsageTargetObjectSchema = strictObject({
+  identifier: z.string().min(1),
+  partIdentifier: QtiIdentifierSchema.optional(),
+  objectType: QtiUsageObjectTypeSchema.optional(),
+});
+
+export const QtiUsageMappingSchema = strictObject({
+  lowerBound: z.number().optional(),
+  upperBound: z.number().optional(),
+  defaultValue: z.number().optional(),
+  mapEntries: z.array(QtiMapEntrySchema).min(1),
+}).superRefine((value, context) => {
+  if (value.lowerBound !== undefined && value.upperBound !== undefined && value.lowerBound > value.upperBound) {
+    addIssue(context, ["upperBound"], "upperBound must be greater than or equal to lowerBound.");
+  }
+});
+
+const QtiUsageStatisticBaseShape = {
+  name: QtiIdentifierSchema,
+  glossary: UriReferenceSchema.optional(),
+  context: UriReferenceSchema,
+  caseCount: z.number().int().nonnegative().optional(),
+  stdError: z.number().optional(),
+  stdDeviation: z.number().optional(),
+  lastUpdated: QtiUsageDateSchema.optional(),
+  targetObjects: z.array(QtiUsageTargetObjectSchema).min(1),
+};
+
+export const QtiOrdinaryStatisticSchema = strictObject({
+  kind: z.literal("ordinaryStatistic"),
+  ...QtiUsageStatisticBaseShape,
+  value: QtiValueSchema,
+});
+
+export const QtiCategorizedStatisticSchema = strictObject({
+  kind: z.literal("categorizedStatistic"),
+  ...QtiUsageStatisticBaseShape,
+  mapping: QtiUsageMappingSchema,
+});
+
+export const QtiUsageStatisticSchema = z.union([QtiOrdinaryStatisticSchema, QtiCategorizedStatisticSchema]);
+
+export const QtiUsageDataSchema = strictObject({
+  glossary: UriReferenceSchema.optional(),
+  statistics: z.array(QtiUsageStatisticSchema).default([]),
+});
+
+export const QtiUsageDataDocumentSchema = strictObject({
+  usageData: QtiUsageDataSchema,
+});
+// Inferred types from exported Zod validators.
+export type QtiUsageDate = z.infer<typeof QtiUsageDateSchema>;
+export type QtiUsageObjectType = z.infer<typeof QtiUsageObjectTypeSchema>;
+export type QtiUsageTargetObject = z.infer<typeof QtiUsageTargetObjectSchema>;
+export type QtiUsageMapping = z.infer<typeof QtiUsageMappingSchema>;
+export type QtiOrdinaryStatistic = z.infer<typeof QtiOrdinaryStatisticSchema>;
+export type QtiCategorizedStatistic = z.infer<typeof QtiCategorizedStatisticSchema>;
+export type QtiUsageStatistic = z.infer<typeof QtiUsageStatisticSchema>;
+export type QtiUsageData = z.infer<typeof QtiUsageDataSchema>;
+export type QtiUsageDataDocument = z.infer<typeof QtiUsageDataDocumentSchema>;