@conform-ed/contracts 0.0.12 → 0.0.14

package/src/qti/v3_0_1/imsqti_asiv3p0p1_v1p0.ts

@@ -4,15 +4,15 @@ 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 { QtiAssessmentItemDocumentSchema } from "./imsqti_itemv3p0p1_v1p0";
+import { QtiOutcomeDeclarationDocumentSchema } from "./imsqti_outcomev3p0p1_v1p0";
 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";
+import { strictObject } from "./shared";
+import { QtiOutcomeDeclarationSchema } from "./variables-internal";
 
 export const QtiAssessmentItemDocumentSchemaAlias = QtiAssessmentItemDocumentSchema;
 export const QtiAssessmentSectionDocumentSchemaAlias = QtiAssessmentSectionDocumentSchema;

package/src/qti/v3_0_1/imsqti_itemv3p0p1_v1p0.ts

@@ -42,9 +42,9 @@ export {
 } from "./processing-internal";
 
 import { QtiAssessmentItemSchema } from "./assessment-internal";
-import { strictObject } from "./shared";
 import { QtiOutcomeDeclarationDocumentSchema } from "./imsqti_outcomev3p0p1_v1p0";
 import { QtiResponseProcessingDocumentSchema } from "./imsqti_responseprocessingv3p0p1_v1p0";
+import { strictObject } from "./shared";
 
 export const QtiAssessmentItemDocumentSchema = strictObject({
   assessmentItem: QtiAssessmentItemSchema,

package/src/qti/v3_0_1/imsqti_metadatav3p0_v1p0.ts

@@ -53,7 +53,7 @@ export const QtiMetadataSchema = strictObject({
 
   if (value.portableCustomInteractionContext && !hasPortableCustomInteraction) {
     context.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: "custom",
       path: ["portableCustomInteractionContext"],
       message:
         "portableCustomInteractionContext is only valid when interactionType includes portableCustomInteraction.",

package/src/qti/v3_0_1/imsqti_responseprocessingv3p0p1_v1p0.ts

@@ -7,8 +7,8 @@ export {
   QtiResponseProcessingSchema,
 } from "./processing-internal";
 
-import { strictObject } from "./shared";
 import { QtiResponseProcessingSchema } from "./processing-internal";
+import { strictObject } from "./shared";
 
 export const QtiResponseProcessingDocumentSchema = strictObject({
   responseProcessing: QtiResponseProcessingSchema,

package/src/qti/v3_0_1/imsqti_resultv3p0_v1p0.ts

@@ -128,9 +128,10 @@ function createVariableSuperRefine(valueKey: "values" | "candidateResponse", can
   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>[] };
+      // Receives zod-parsed variables; zod's `.optional()` infers `| undefined`, so these must too.
+      baseType?: z.infer<typeof QtiBaseTypeSchema> | undefined;
+      values?: readonly z.infer<typeof QtiResultValueSchema>[] | undefined;
+      candidateResponse?: { values?: readonly z.infer<typeof QtiResultValueSchema>[] | undefined } | undefined;
     },
     context: z.RefinementCtx,
   ) => {

package/src/qti/v3_0_1/imsqti_sectionv3p0p1_v1p0.ts

@@ -5,8 +5,8 @@ export {
   QtiAssessmentSectionSchema,
 } from "./assessment-internal";
 
-import { strictObject } from "./shared";
 import { QtiAssessmentSectionSchema } from "./assessment-internal";
+import { strictObject } from "./shared";
 
 export const QtiAssessmentSectionDocumentSchema = strictObject({
   assessmentSection: QtiAssessmentSectionSchema,

package/src/qti/v3_0_1/imsqti_stimulusv3p0p1_v1p0.ts

@@ -5,8 +5,8 @@ export {
   QtiStimulusBodySchema,
 } from "./assessment-internal";
 
-import { strictObject } from "./shared";
 import { QtiAssessmentStimulusSchema } from "./assessment-internal";
+import { strictObject } from "./shared";
 
 export const QtiAssessmentStimulusDocumentSchema = strictObject({
   assessmentStimulus: QtiAssessmentStimulusSchema,

package/src/qti/v3_0_1/imsqti_testv3p0p1_v1p0.ts

@@ -24,10 +24,10 @@ export {
 } 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";
+import { QtiOutcomeProcessingSchema } from "./processing-internal";
+import { strictObject } from "./shared";
 
 export const QtiAssessmentTestDocumentSchema = strictObject({
   assessmentTest: QtiAssessmentTestSchema,

package/src/qti/v3_0_1/imsqti_usagedatav3p0_v1p0.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 
-import { QtiMapEntrySchema, QtiValueSchema } from "./variables-internal";
 import { QtiIdentifierSchema, UriReferenceSchema, addIssue, strictObject } from "./shared";
+import { QtiMapEntrySchema, QtiValueSchema } from "./variables-internal";
 
 export const QtiUsageDateSchema = z.iso.date();
 

package/src/qti/v3_0_1/processing-internal.ts

@@ -33,7 +33,6 @@ const binaryExpressionKinds = [
   "divide",
   "delete",
   "match",
-  "equal",
   "integerDivide",
   "integerModulus",
   "contains",
@@ -178,35 +177,35 @@ export const QtiMathConstantExpressionSchema = strictObject({
   name: z.enum(["pi", "e"]),
 });
 
-export const QtiUnaryExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiUnaryExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.enum(unaryExpressionKinds),
     children: z.tuple([QtiExpressionSchema]),
   }),
 );
 
-export const QtiBinaryExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiBinaryExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.enum(binaryExpressionKinds),
     children: z.tuple([QtiExpressionSchema, QtiExpressionSchema]),
   }),
 );
 
-export const QtiOneToManyExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiOneToManyExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.enum(oneToManyExpressionKinds),
     children: z.array(QtiExpressionSchema).min(1),
   }),
 );
 
-export const QtiContainerExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiContainerExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.enum(containerExpressionKinds),
     children: z.array(QtiExpressionSchema),
   }),
 );
 
-export const QtiCustomOperatorExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiCustomOperatorExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("customOperator"),
     children: z.array(QtiExpressionSchema).optional(),
@@ -216,7 +215,7 @@ export const QtiCustomOperatorExpressionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiAnyNExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiAnyNExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("anyN"),
     children: z.array(QtiExpressionSchema).min(1),
@@ -237,7 +236,18 @@ export const QtiAnyNExpressionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiEqualRoundedExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiEqualExpressionSchema: z.ZodType = z.lazy(() =>
+  strictObject({
+    kind: z.literal("equal"),
+    children: z.tuple([QtiExpressionSchema, QtiExpressionSchema]),
+    toleranceMode: z.enum(["exact", "absolute", "relative"]).optional(),
+    tolerance: z.array(QtiNumberOrVariableSchema).min(1).max(2).optional(),
+    includeLowerBound: z.boolean().optional(),
+    includeUpperBound: z.boolean().optional(),
+  }),
+);
+
+export const QtiEqualRoundedExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("equalRounded"),
     children: z.tuple([QtiExpressionSchema, QtiExpressionSchema]),
@@ -248,7 +258,7 @@ export const QtiEqualRoundedExpressionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiFieldValueExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiFieldValueExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("fieldValue"),
     children: z.tuple([QtiExpressionSchema]),
@@ -256,7 +266,7 @@ export const QtiFieldValueExpressionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiIndexExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiIndexExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("index"),
     children: z.tuple([QtiExpressionSchema]),
@@ -266,7 +276,7 @@ export const QtiIndexExpressionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiInsideExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiInsideExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("inside"),
     children: z.tuple([QtiExpressionSchema]),
@@ -275,7 +285,7 @@ export const QtiInsideExpressionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiMathOperatorExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiMathOperatorExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("mathOperator"),
     children: z.array(QtiExpressionSchema).min(1),
@@ -293,7 +303,7 @@ export const QtiMathOperatorExpressionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiPatternMatchExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiPatternMatchExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("patternMatch"),
     children: z.tuple([QtiExpressionSchema]),
@@ -301,7 +311,7 @@ export const QtiPatternMatchExpressionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiRepeatExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiRepeatExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("repeat"),
     children: z.array(QtiExpressionSchema).min(1),
@@ -311,7 +321,7 @@ export const QtiRepeatExpressionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiRoundToExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiRoundToExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("roundTo"),
     children: z.tuple([QtiExpressionSchema]),
@@ -322,7 +332,7 @@ export const QtiRoundToExpressionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiStatsOperatorExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiStatsOperatorExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("statsOperator"),
     children: z.tuple([QtiExpressionSchema]),
@@ -330,7 +340,7 @@ export const QtiStatsOperatorExpressionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiStringMatchExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiStringMatchExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("stringMatch"),
     children: z.tuple([QtiExpressionSchema, QtiExpressionSchema]),
@@ -339,7 +349,7 @@ export const QtiStringMatchExpressionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiSubstringExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiSubstringExpressionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("substring"),
     children: z.tuple([QtiExpressionSchema, QtiExpressionSchema]),
@@ -394,7 +404,7 @@ export const QtiTestVariablesExpressionSchema = strictObject({
   baseType: QtiBaseTypeSchema.optional(),
 });
 
-export const QtiExpressionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiExpressionSchema: z.ZodType = z.lazy(() =>
   z.union([
     QtiNullExpressionSchema,
     QtiBaseValueExpressionSchema,
@@ -412,6 +422,7 @@ export const QtiExpressionSchema: z.ZodTypeAny = z.lazy(() =>
     QtiContainerExpressionSchema,
     QtiCustomOperatorExpressionSchema,
     QtiAnyNExpressionSchema,
+    QtiEqualExpressionSchema,
     QtiEqualRoundedExpressionSchema,
     QtiFieldValueExpressionSchema,
     QtiIndexExpressionSchema,
@@ -498,14 +509,14 @@ export const QtiExitTestSchema = strictObject({
   kind: z.literal("exitTest"),
 });
 
-export const QtiResponseElseSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiResponseElseSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("responseElse"),
     actions: z.array(QtiResponseRuleSchema).optional(),
   }),
 );
 
-export const QtiResponseIfSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiResponseIfSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("responseIf"),
     expression: QtiExpressionSchema,
@@ -513,7 +524,7 @@ export const QtiResponseIfSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiResponseConditionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiResponseConditionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("responseCondition"),
     responseIf: QtiResponseIfSchema,
@@ -522,14 +533,14 @@ export const QtiResponseConditionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiResponseProcessingFragmentSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiResponseProcessingFragmentSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("responseProcessingFragment"),
     rules: z.array(QtiResponseRuleSchema).optional(),
   }),
 );
 
-export const QtiResponseRuleSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiResponseRuleSchema: z.ZodType = z.lazy(() =>
   z.union([
     QtiIncludeSchema,
     QtiResponseConditionSchema,
@@ -546,14 +557,14 @@ export const QtiResponseProcessingSchema = strictObject({
   templateLocation: z.string().optional(),
 });
 
-export const QtiOutcomeElseSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiOutcomeElseSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("outcomeElse"),
     actions: z.array(QtiOutcomeRuleSchema).optional(),
   }),
 );
 
-export const QtiOutcomeIfSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiOutcomeIfSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("outcomeIf"),
     expression: QtiExpressionSchema,
@@ -561,7 +572,7 @@ export const QtiOutcomeIfSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiOutcomeConditionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiOutcomeConditionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("outcomeCondition"),
     outcomeIf: QtiOutcomeIfSchema,
@@ -570,14 +581,14 @@ export const QtiOutcomeConditionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiOutcomeProcessingFragmentSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiOutcomeProcessingFragmentSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("outcomeProcessingFragment"),
     rules: z.array(QtiOutcomeRuleSchema).optional(),
   }),
 );
 
-export const QtiOutcomeRuleSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiOutcomeRuleSchema: z.ZodType = z.lazy(() =>
   z.union([
     QtiIncludeSchema,
     QtiOutcomeConditionSchema,
@@ -592,14 +603,14 @@ export const QtiOutcomeProcessingSchema = strictObject({
   rules: z.array(QtiOutcomeRuleSchema).optional(),
 });
 
-export const QtiTemplateElseSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiTemplateElseSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("templateElse"),
     actions: z.array(QtiTemplateRuleSchema).optional(),
   }),
 );
 
-export const QtiTemplateIfSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiTemplateIfSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("templateIf"),
     expression: QtiExpressionSchema,
@@ -607,7 +618,7 @@ export const QtiTemplateIfSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiTemplateConditionSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiTemplateConditionSchema: z.ZodType = z.lazy(() =>
   strictObject({
     kind: z.literal("templateCondition"),
     templateIf: QtiTemplateIfSchema,
@@ -616,7 +627,7 @@ export const QtiTemplateConditionSchema: z.ZodTypeAny = z.lazy(() =>
   }),
 );
 
-export const QtiTemplateRuleSchema: z.ZodTypeAny = z.lazy(() =>
+export const QtiTemplateRuleSchema: z.ZodType = z.lazy(() =>
   z.union([
     QtiTemplateConditionSchema,
     QtiSetTemplateValueSchema,

package/src/qti/v3_0_1/shared.ts

@@ -76,7 +76,7 @@ export function looseObject<T extends z.ZodRawShape>(shape: T) {
   });
 }
 
-export function createXmlNodeSchema(childSchema: z.ZodTypeAny): z.ZodTypeAny {
+export function createXmlNodeSchema(childSchema: z.ZodType): z.ZodType {
   return z.lazy(() =>
     strictObject({
       kind: z.literal("xml"),
@@ -91,7 +91,7 @@ export function createXmlNodeSchema(childSchema: z.ZodTypeAny): z.ZodTypeAny {
 
 export function addIssue(context: z.RefinementCtx, path: Array<string | number>, message: string) {
   context.addIssue({
-    code: z.ZodIssueCode.custom,
+    code: "custom",
     path,
     message,
   });

package/src/vc-data-model/v2_0/shared.ts

@@ -23,16 +23,16 @@ export function strictObject<T extends z.ZodRawShape>(shape: T) {
 }
 
 export function passthroughObject<T extends z.ZodRawShape>(shape: T) {
-  return z.object(shape).passthrough();
+  return z.looseObject(shape);
 }
 
-export function oneOrMany<T extends z.ZodTypeAny>(schema: T) {
+export function oneOrMany<T extends z.ZodType>(schema: T) {
   return z.union([schema, z.array(schema).min(1)]);
 }
 
 export function addIssue(context: z.RefinementCtx, path: Array<string | number>, message: string) {
   context.addIssue({
-    code: z.ZodIssueCode.custom,
+    code: "custom",
     path,
     message,
   });
@@ -98,7 +98,7 @@ export function credentialTypeSchema<T extends readonly [string, ...string[]]>(d
     });
 }
 
-export function contextArraySchema(label: string, requiredEntries: readonly z.ZodTypeAny[]) {
+export function contextArraySchema(label: string, requiredEntries: readonly z.ZodType[]) {
   return z
     .array(JsonLdContextEntrySchema)
     .min(requiredEntries.length)

package/src/xapi/shared.ts

@@ -7,18 +7,15 @@ export function strictObject<T extends z.ZodRawShape>(shape: T) {
 const UriSchema = z.string().regex(/^[a-zA-Z][a-zA-Z0-9+.-]*:.+$/u);
 
 export const NonEmptyStringSchema = z.string().min(1);
-export const UuidSchema = z.string().uuid();
+export const UuidSchema = z.uuid();
 export const UriSchemaStrict = UriSchema;
 export const IriSchema = UriSchema;
 export const MediaTypeSchema = z.string().min(1);
 export const LanguageTagSchema = z.string().regex(/^[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*$/u);
 export const XapiVersionSchema = z.string().regex(/^\d+\.\d+(?:\.\d+)?$/u);
-export const Iso8601TimestampSchema = z
-  .string()
-  .datetime({ offset: true })
-  .refine((v) => !v.endsWith("-00:00"), {
-    message: "Negative zero offset (-00:00) is not a valid xAPI timestamp",
-  });
+export const Iso8601TimestampSchema = z.iso.datetime({ offset: true }).refine((v) => !v.endsWith("-00:00"), {
+  message: "Negative zero offset (-00:00) is not a valid xAPI timestamp",
+});
 export const Iso8601DurationSchema = z
   .string()
   .regex(/^P(?=.)(?:(\d+W)|(?:(\d+Y)?(\d+M)?(\d+D)?(?:T(?=\d)(\d+H)?(\d+M)?(\d+(?:\.\d+)?S)?)?))$/u);
@@ -57,7 +54,7 @@ export const AgentSchema = strictObject({
   const ifiCount = [value.mbox, value.mbox_sha1sum, value.openid, value.account].filter(hasDefined).length;
   if (ifiCount !== 1) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: "custom",
       message:
         "An xAPI Agent requires exactly one Inverse Functional Identifier (mbox, mbox_sha1sum, openid, or account)",
     });
@@ -82,13 +79,13 @@ export const GroupSchema = strictObject({
   const ifiCount = [value.mbox, value.mbox_sha1sum, value.openid, value.account].filter(hasDefined).length;
   if (ifiCount > 1) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: "custom",
       message: "An identified xAPI Group MUST have exactly one Inverse Functional Identifier",
     });
   }
   if (ifiCount === 0 && !hasDefined(value.member)) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: "custom",
       message: "An anonymous xAPI Group requires a member list",
     });
   }
@@ -162,7 +159,7 @@ export const ActivityDefinitionSchema = strictObject({
   for (const prop of interactionSubProperties) {
     if (value[prop] !== undefined) {
       ctx.addIssue({
-        code: z.ZodIssueCode.custom,
+        code: "custom",
         message: `Activity definition property '${prop}' requires interactionType to be set`,
         path: [prop],
       });
@@ -190,21 +187,21 @@ export const ScoreSchema = strictObject({
   const { min, max, raw } = value;
   if (min !== undefined && max !== undefined && min >= max) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: "custom",
       message: "Score max must be greater than min",
       path: ["max"],
     });
   }
   if (raw !== undefined && min !== undefined && raw < min) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: "custom",
       message: "Score raw must be greater than or equal to min",
       path: ["raw"],
     });
   }
   if (raw !== undefined && max !== undefined && raw > max) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: "custom",
       message: "Score raw must be less than or equal to max",
       path: ["raw"],
     });

package/src/xapi/v1_0_3/index.ts

@@ -51,61 +51,61 @@ import {
   XapiMultipartRequestSchema,
 } from "../shared";
 
-export namespace XapiV1_0_3 {
-  export namespace Schemas {
-    export const AgentAccount = AgentAccountSchema;
-    export const Agent = AgentSchema;
-    export const Group = GroupSchema;
-    export const Verb = VerbSchema;
-    export const InteractionComponent = InteractionComponentSchema;
-    export const Activity = ActivitySchema;
-    export const StatementRef = StatementRefSchema;
-    export const SubStatement = SubStatementSchema;
-    export const Score = ScoreSchema;
-    export const Result = ResultSchema;
-    export const ContextActivities = ContextActivitiesSchema;
-    export const Context = ContextSchema;
-    export const Attachment = AttachmentSchema;
-    export const StatementObject = StatementObjectSchema;
-    export const Statement = StatementSchema;
-    export const StatementSubmission = StatementSubmissionSchema;
-    export const StatementResult = StatementResultSchema;
-    export const Person = PersonSchema;
-    export const AboutResource = AboutResourceSchema;
-    export const StatementsQuery = StatementsQuerySchema;
-    export const AgentsResourceQuery = AgentsResourceQuerySchema;
-    export const ActivitiesResourceQuery = ActivitiesResourceQuerySchema;
-    export const StateDocumentQuery = StateDocumentQuerySchema;
-    export const StateDocumentListingQuery = StateDocumentListingQuerySchema;
-    export const AgentProfileDocumentQuery = AgentProfileDocumentQuerySchema;
-    export const AgentProfileDocumentListingQuery = AgentProfileDocumentListingQuerySchema;
-    export const ActivityProfileDocumentQuery = ActivityProfileDocumentQuerySchema;
-    export const ActivityProfileDocumentListingQuery = ActivityProfileDocumentListingQuerySchema;
-    export const XapiDocument = XapiDocumentSchema;
-    export const XapiDocumentIdList = XapiDocumentIdListSchema;
-    export const HttpMethod = XapiHttpMethodSchema;
-    export const Resource = XapiResourceSchema;
-    export const RequestHeader = XapiRequestHeaderSchema;
-    export const ResponseHeader = XapiResponseHeaderSchema;
-    export const ErrorCode = XapiErrorCodeSchema;
-    export const ErrorResponse = XapiErrorResponseSchema;
-    export const Concurrency = XapiConcurrencySchema;
-    export const MultipartAttachmentPart = XapiMultipartAttachmentPartSchema;
-    export const MultipartRequest = XapiMultipartRequestSchema;
-  }
+export const XapiV1_0_3 = {
+  Schemas: {
+    AgentAccount: AgentAccountSchema,
+    Agent: AgentSchema,
+    Group: GroupSchema,
+    Verb: VerbSchema,
+    InteractionComponent: InteractionComponentSchema,
+    Activity: ActivitySchema,
+    StatementRef: StatementRefSchema,
+    SubStatement: SubStatementSchema,
+    Score: ScoreSchema,
+    Result: ResultSchema,
+    ContextActivities: ContextActivitiesSchema,
+    Context: ContextSchema,
+    Attachment: AttachmentSchema,
+    StatementObject: StatementObjectSchema,
+    Statement: StatementSchema,
+    StatementSubmission: StatementSubmissionSchema,
+    StatementResult: StatementResultSchema,
+    Person: PersonSchema,
+    AboutResource: AboutResourceSchema,
+    StatementsQuery: StatementsQuerySchema,
+    AgentsResourceQuery: AgentsResourceQuerySchema,
+    ActivitiesResourceQuery: ActivitiesResourceQuerySchema,
+    StateDocumentQuery: StateDocumentQuerySchema,
+    StateDocumentListingQuery: StateDocumentListingQuerySchema,
+    AgentProfileDocumentQuery: AgentProfileDocumentQuerySchema,
+    AgentProfileDocumentListingQuery: AgentProfileDocumentListingQuerySchema,
+    ActivityProfileDocumentQuery: ActivityProfileDocumentQuerySchema,
+    ActivityProfileDocumentListingQuery: ActivityProfileDocumentListingQuerySchema,
+    XapiDocument: XapiDocumentSchema,
+    XapiDocumentIdList: XapiDocumentIdListSchema,
+    HttpMethod: XapiHttpMethodSchema,
+    Resource: XapiResourceSchema,
+    RequestHeader: XapiRequestHeaderSchema,
+    ResponseHeader: XapiResponseHeaderSchema,
+    ErrorCode: XapiErrorCodeSchema,
+    ErrorResponse: XapiErrorResponseSchema,
+    Concurrency: XapiConcurrencySchema,
+    MultipartAttachmentPart: XapiMultipartAttachmentPartSchema,
+    MultipartRequest: XapiMultipartRequestSchema,
+  },
 
-  export namespace Shared {
-    export const Uuid = UuidSchema;
-    export const Version = XapiVersionSchema;
-    export const Iri = IriSchema;
-    export const LanguageTag = LanguageTagSchema;
-    export const LanguageMap = LanguageMapSchema;
-    export const Timestamp = Iso8601TimestampSchema;
-    export const Duration = Iso8601DurationSchema;
-    export const NonEmptyString = NonEmptyStringSchema;
-    export const InteractionType = InteractionTypeSchema;
-  }
-}
+  Shared: {
+    Uuid: UuidSchema,
+    Version: XapiVersionSchema,
+    Iri: IriSchema,
+    LanguageTag: LanguageTagSchema,
+    LanguageMap: LanguageMapSchema,
+    Timestamp: Iso8601TimestampSchema,
+    Duration: Iso8601DurationSchema,
+    NonEmptyString: NonEmptyStringSchema,
+    InteractionType: InteractionTypeSchema,
+  },
+} as const;
 
 export type XapiV1_0_3Schemas = typeof XapiV1_0_3.Schemas;