@conform-ed/contracts 0.0.3

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

@@ -0,0 +1,206 @@
+import { z } from "zod";
+
+export const LocaleTagSchema = z.string().regex(/^[a-z]{2}(-[A-Z]{2})?$/u);
+export const LocalizedStringMapSchema = z.record(LocaleTagSchema, z.string());
+export const NonEmptyLocalizedStringMapSchema = z.record(LocaleTagSchema, z.string().min(1));
+export const W3cCredentialsV2ContextSchema = z.literal("https://www.w3.org/ns/credentials/v2");
+export const CompactJwsSchema = z.string().regex(/^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*\.[A-Za-z0-9_-]+$/u);
+
+export type LocalizedStringMap = Record<string, string>;
+export type TextValue = string | LocalizedStringMap;
+export type UriValue = string | LocalizedStringMap;
+export type CompactJwsValue = string | LocalizedStringMap;
+export type JsonLdContextEntry = Record<string, unknown> | UriValue;
+export type OneOrManyValue<T> = T | T[];
+
+export const TextValueSchema = z.union([z.string(), LocalizedStringMapSchema]);
+export const UriValueSchema = z.union([z.string().min(1), NonEmptyLocalizedStringMapSchema]);
+export const CompactJwsValueSchema = z.union([CompactJwsSchema, z.record(LocaleTagSchema, CompactJwsSchema)]);
+export const JsonLdContextEntrySchema = z.union([z.record(z.string(), z.unknown()), UriValueSchema]);
+
+export function strictObject<T extends z.ZodRawShape>(shape: T) {
+  return z.object(shape).strict();
+}
+
+export function passthroughObject<T extends z.ZodRawShape>(shape: T) {
+  return z.object(shape).passthrough();
+}
+
+export function oneOrMany<T extends z.ZodTypeAny>(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,
+    path,
+    message,
+  });
+}
+
+function valueMatchesLiteral(value: unknown, expected: string) {
+  if (typeof value === "string") {
+    return value === expected;
+  }
+
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+
+  return Object.values(value).some((entry) => entry === expected);
+}
+
+export function literalOrLocalizedLiteralSchema(expected: string) {
+  return z.union([z.literal(expected), z.record(LocaleTagSchema, z.literal(expected))]);
+}
+
+export function localizedEnumValueSchema<T extends readonly [string, ...string[]]>(values: T) {
+  const allowed = new Set(values);
+  const message = `Expected one of: ${values.join(", ")}`;
+
+  return z.union([
+    z.string().refine((value) => allowed.has(value), { message }),
+    z.record(
+      LocaleTagSchema,
+      z.string().refine((value) => allowed.has(value), {
+        message,
+      }),
+    ),
+  ]);
+}
+
+export function singleTypeSchema(expected: string) {
+  return z.union([
+    literalOrLocalizedLiteralSchema(expected),
+    z
+      .array(UriValueSchema)
+      .min(1)
+      .superRefine((values, context) => {
+        if (!values.some((value) => valueMatchesLiteral(value, expected))) {
+          addIssue(context, [], `Expected type array to include "${expected}"`);
+        }
+      }),
+  ]);
+}
+
+export function credentialTypeSchema<T extends readonly [string, ...string[]]>(domainTypes: T) {
+  return z
+    .array(UriValueSchema)
+    .min(2)
+    .superRefine((values, context) => {
+      if (!values.some((value) => valueMatchesLiteral(value, "VerifiableCredential"))) {
+        addIssue(context, [], 'Expected type array to include "VerifiableCredential"');
+      }
+
+      if (!domainTypes.some((domainType) => values.some((value) => valueMatchesLiteral(value, domainType)))) {
+        addIssue(context, [], `Expected type array to include one of: ${domainTypes.join(", ")}`);
+      }
+    });
+}
+
+export function contextArraySchema(label: string, requiredEntries: readonly z.ZodTypeAny[]) {
+  return z
+    .array(JsonLdContextEntrySchema)
+    .min(requiredEntries.length)
+    .superRefine((values, context) => {
+      requiredEntries.forEach((schema, index) => {
+        const result = schema.safeParse(values[index]);
+        if (!result.success) {
+          addIssue(context, [index], `${label} context entry ${index} does not match the expected shape`);
+        }
+      });
+    });
+}
+
+const VerifiableCredentialContextSchema = contextArraySchema("VC Data Model 2.0", [W3cCredentialsV2ContextSchema]);
+const VerifiablePresentationContextSchema = contextArraySchema("VC Data Model 2.0", [W3cCredentialsV2ContextSchema]);
+
+export const CredentialSchemaSchema = passthroughObject({
+  id: UriValueSchema,
+  type: TextValueSchema,
+});
+
+export const CredentialStatusSchema = passthroughObject({
+  id: UriValueSchema.optional(),
+  type: TextValueSchema,
+});
+
+export const RefreshServiceSchema = passthroughObject({
+  id: UriValueSchema,
+  type: TextValueSchema,
+});
+
+export const TermsOfUseSchema = passthroughObject({
+  id: UriValueSchema.optional(),
+  type: TextValueSchema,
+});
+
+export const ProofSchema = passthroughObject({
+  type: TextValueSchema,
+  created: z.iso.datetime().optional(),
+  cryptosuite: TextValueSchema.optional(),
+  challenge: TextValueSchema.optional(),
+  domain: TextValueSchema.optional(),
+  nonce: TextValueSchema.optional(),
+  proofPurpose: TextValueSchema.optional(),
+  proofValue: TextValueSchema.optional(),
+  verificationMethod: UriValueSchema.optional(),
+});
+
+export const EvidenceSchema = passthroughObject({
+  id: UriValueSchema.optional(),
+  type: TextValueSchema.optional(),
+  narrative: TextValueSchema.optional(),
+  name: TextValueSchema.optional(),
+  description: TextValueSchema.optional(),
+});
+
+export const CredentialSubjectSchema = passthroughObject({
+  id: UriValueSchema.optional(),
+});
+
+const GenericEntityReferenceSchema = z.union([UriValueSchema, z.record(z.string(), z.unknown())]);
+
+export const VerifiableCredentialSchema = passthroughObject({
+  "@context": VerifiableCredentialContextSchema,
+  id: UriValueSchema.optional(),
+  type: singleTypeSchema("VerifiableCredential"),
+  issuer: GenericEntityReferenceSchema,
+  validFrom: z.iso.datetime(),
+  validUntil: z.iso.datetime().optional(),
+  credentialSubject: z.union([CredentialSubjectSchema, z.array(CredentialSubjectSchema).min(1)]),
+  name: TextValueSchema.optional(),
+  description: TextValueSchema.optional(),
+  proof: oneOrMany(ProofSchema).optional(),
+  credentialSchema: oneOrMany(CredentialSchemaSchema).optional(),
+  credentialStatus: oneOrMany(CredentialStatusSchema).optional(),
+  refreshService: oneOrMany(RefreshServiceSchema).optional(),
+  termsOfUse: oneOrMany(TermsOfUseSchema).optional(),
+  evidence: oneOrMany(EvidenceSchema).optional(),
+});
+
+export const HolderSchema = GenericEntityReferenceSchema;
+
+export const VerifiablePresentationSchema = passthroughObject({
+  "@context": VerifiablePresentationContextSchema,
+  type: singleTypeSchema("VerifiablePresentation"),
+  id: UriValueSchema.optional(),
+  holder: HolderSchema.optional(),
+  verifiableCredential: oneOrMany(z.union([VerifiableCredentialSchema, CompactJwsValueSchema])).optional(),
+  proof: oneOrMany(ProofSchema).optional(),
+});
+// Inferred types from exported Zod validators.
+export type LocaleTag = z.infer<typeof LocaleTagSchema>;
+export type NonEmptyLocalizedStringMap = z.infer<typeof NonEmptyLocalizedStringMapSchema>;
+export type W3cCredentialsV2Context = z.infer<typeof W3cCredentialsV2ContextSchema>;
+export type CompactJws = z.infer<typeof CompactJwsSchema>;
+export type CredentialSchema = z.infer<typeof CredentialSchemaSchema>;
+export type CredentialStatus = z.infer<typeof CredentialStatusSchema>;
+export type RefreshService = z.infer<typeof RefreshServiceSchema>;
+export type TermsOfUse = z.infer<typeof TermsOfUseSchema>;
+export type Proof = z.infer<typeof ProofSchema>;
+export type Evidence = z.infer<typeof EvidenceSchema>;
+export type CredentialSubject = z.infer<typeof CredentialSubjectSchema>;
+export type VerifiableCredential = z.infer<typeof VerifiableCredentialSchema>;
+export type Holder = z.infer<typeof HolderSchema>;
+export type VerifiablePresentation = z.infer<typeof VerifiablePresentationSchema>;

package/src/xapi/index.ts

@@ -0,0 +1,12 @@
+export * from "./shared";
+
+export * as V1_0_3 from "./v1_0_3";
+export * as V2_0 from "./v2_0";
+
+import { XapiV1_0_3DerivedZodTemplates } from "./v1_0_3";
+import { XapiV2_0DerivedZodTemplates } from "./v2_0";
+
+export const XapiDerivedZodTemplates = {
+  v1_0_3: XapiV1_0_3DerivedZodTemplates,
+  v2_0: XapiV2_0DerivedZodTemplates,
+} as const;

package/src/xapi/shared.ts

@@ -0,0 +1,444 @@
+import { z } from "zod";
+
+export 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 NonEmptyStringSchema = z.string().min(1);
+export const UuidSchema = z.string().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();
+export const Iso8601DurationSchema = z
+  .string()
+  .regex(/^P(?=.+)(?:\d+Y)?(?:\d+M)?(?:\d+W)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+(?:\.\d+)?S)?)?$/u);
+
+export const LanguageMapSchema = z.record(LanguageTagSchema, z.string());
+export const ExtensionsSchema = z.record(UriSchema, z.unknown());
+export const AttachmentSha2Schema = z.string().regex(/^[A-Fa-f0-9]{64}$/u);
+
+export const AgentAccountSchema = strictObject({
+  homePage: UriSchema,
+  name: NonEmptyStringSchema,
+});
+
+function hasDefined(value: unknown): boolean {
+  return value !== undefined && value !== null;
+}
+
+function hasNonEmptyArray(value: unknown): boolean {
+  return Array.isArray(value) && value.length > 0;
+}
+
+export const AgentSchema = strictObject({
+  objectType: z.literal("Agent").optional(),
+  name: NonEmptyStringSchema.optional(),
+  mbox: z
+    .string()
+    .regex(/^mailto:.+@.+$/u)
+    .optional(),
+  mbox_sha1sum: z
+    .string()
+    .regex(/^[A-Fa-f0-9]{40}$/u)
+    .optional(),
+  openid: UriSchema.optional(),
+  account: AgentAccountSchema.optional(),
+}).refine(
+  (value) =>
+    hasDefined(value.mbox) || hasDefined(value.mbox_sha1sum) || hasDefined(value.openid) || hasDefined(value.account),
+  {
+    message: "An xAPI Agent requires at least one identifier",
+  },
+);
+
+export const GroupSchema = strictObject({
+  objectType: z.literal("Group").optional(),
+  name: NonEmptyStringSchema.optional(),
+  mbox: z
+    .string()
+    .regex(/^mailto:.+@.+$/u)
+    .optional(),
+  mbox_sha1sum: z
+    .string()
+    .regex(/^[A-Fa-f0-9]{40}$/u)
+    .optional(),
+  openid: UriSchema.optional(),
+  account: AgentAccountSchema.optional(),
+  member: z.array(AgentSchema).min(1).optional(),
+}).refine(
+  (value) =>
+    hasDefined(value.mbox) ||
+    hasDefined(value.mbox_sha1sum) ||
+    hasDefined(value.openid) ||
+    hasDefined(value.account) ||
+    hasDefined(value.member),
+  {
+    message: "An xAPI Group requires an identifier or member list",
+  },
+);
+
+export const PersonSchema = strictObject({
+  objectType: z.literal("Person"),
+  name: z.array(NonEmptyStringSchema).min(1).optional(),
+  mbox: z
+    .array(z.string().regex(/^mailto:.+@.+$/u))
+    .min(1)
+    .optional(),
+  mbox_sha1sum: z
+    .array(z.string().regex(/^[A-Fa-f0-9]{40}$/u))
+    .min(1)
+    .optional(),
+  openid: z.array(UriSchema).min(1).optional(),
+  account: z.array(AgentAccountSchema).min(1).optional(),
+}).refine(
+  (value) =>
+    hasNonEmptyArray(value.name) ||
+    hasNonEmptyArray(value.mbox) ||
+    hasNonEmptyArray(value.mbox_sha1sum) ||
+    hasNonEmptyArray(value.openid) ||
+    hasNonEmptyArray(value.account),
+  {
+    message: "An xAPI Person requires at least one populated identifier or name array",
+  },
+);
+
+export const VerbSchema = strictObject({
+  id: IriSchema,
+  display: LanguageMapSchema.optional(),
+});
+
+export const InteractionTypeSchema = z.enum([
+  "true-false",
+  "choice",
+  "fill-in",
+  "long-fill-in",
+  "matching",
+  "performance",
+  "sequencing",
+  "likert",
+  "numeric",
+  "other",
+]);
+
+export const InteractionComponentSchema = strictObject({
+  id: NonEmptyStringSchema,
+  description: LanguageMapSchema.optional(),
+});
+
+export const ActivityDefinitionSchema = strictObject({
+  name: LanguageMapSchema.optional(),
+  description: LanguageMapSchema.optional(),
+  type: IriSchema.optional(),
+  moreInfo: IriSchema.optional(),
+  interactionType: InteractionTypeSchema.optional(),
+  correctResponsesPattern: z.array(NonEmptyStringSchema).min(1).optional(),
+  choices: z.array(InteractionComponentSchema).min(1).optional(),
+  scale: z.array(InteractionComponentSchema).min(1).optional(),
+  source: z.array(InteractionComponentSchema).min(1).optional(),
+  target: z.array(InteractionComponentSchema).min(1).optional(),
+  steps: z.array(InteractionComponentSchema).min(1).optional(),
+  extensions: ExtensionsSchema.optional(),
+});
+
+export const ActivitySchema = strictObject({
+  objectType: z.literal("Activity").optional(),
+  id: IriSchema,
+  definition: ActivityDefinitionSchema.optional(),
+});
+
+export const StatementRefSchema = strictObject({
+  objectType: z.literal("StatementRef"),
+  id: UuidSchema,
+});
+
+export const ScoreSchema = strictObject({
+  scaled: z.number().min(-1).max(1).optional(),
+  raw: z.number().optional(),
+  min: z.number().optional(),
+  max: z.number().optional(),
+});
+
+export const ResultSchema = strictObject({
+  score: ScoreSchema.optional(),
+  success: z.boolean().optional(),
+  completion: z.boolean().optional(),
+  response: z.string().optional(),
+  duration: Iso8601DurationSchema.optional(),
+  extensions: ExtensionsSchema.optional(),
+});
+
+export const ContextActivitiesSchema = strictObject({
+  parent: z.array(ActivitySchema).min(1).optional(),
+  category: z.array(ActivitySchema).min(1).optional(),
+  grouping: z.array(ActivitySchema).min(1).optional(),
+  other: z.array(ActivitySchema).min(1).optional(),
+});
+
+export const ContextSchema = strictObject({
+  registration: UuidSchema.optional(),
+  instructor: z.union([AgentSchema, GroupSchema]).optional(),
+  team: z.union([AgentSchema, GroupSchema]).optional(),
+  contextActivities: ContextActivitiesSchema.optional(),
+  revision: NonEmptyStringSchema.optional(),
+  platform: NonEmptyStringSchema.optional(),
+  language: LanguageTagSchema.optional(),
+  statement: StatementRefSchema.optional(),
+  extensions: ExtensionsSchema.optional(),
+});
+
+export const AttachmentSchema = strictObject({
+  usageType: IriSchema,
+  display: LanguageMapSchema,
+  description: LanguageMapSchema.optional(),
+  contentType: MediaTypeSchema,
+  length: z.number().int().nonnegative(),
+  sha2: AttachmentSha2Schema,
+  fileUrl: z.url().optional(),
+});
+
+export const XapiDocumentSchema = strictObject({
+  contentType: MediaTypeSchema,
+  body: z.unknown(),
+  etag: NonEmptyStringSchema.optional(),
+  lastModified: Iso8601TimestampSchema.optional(),
+});
+
+export const StatementSubmissionSchema = z.union([
+  z.lazy(() => StatementSchema),
+  z.array(z.lazy(() => StatementSchema)).min(1),
+]);
+
+export const AboutResourceSchema = strictObject({
+  version: z.array(XapiVersionSchema).min(1),
+  extensions: ExtensionsSchema.optional(),
+});
+
+export const StatementsQueryFormatSchema = z.enum(["ids", "exact", "canonical"]);
+
+export const StatementsQuerySchema = strictObject({
+  statementId: UuidSchema.optional(),
+  voidedStatementId: UuidSchema.optional(),
+  agent: AgentSchema.optional(),
+  verb: IriSchema.optional(),
+  activity: IriSchema.optional(),
+  registration: UuidSchema.optional(),
+  related_activities: z.boolean().optional(),
+  related_agents: z.boolean().optional(),
+  since: Iso8601TimestampSchema.optional(),
+  until: Iso8601TimestampSchema.optional(),
+  limit: z.number().int().positive().optional(),
+  format: StatementsQueryFormatSchema.optional(),
+  attachments: z.boolean().optional(),
+  ascending: z.boolean().optional(),
+}).refine((value) => !(hasDefined(value.statementId) && hasDefined(value.voidedStatementId)), {
+  message: "Statements queries cannot specify both statementId and voidedStatementId",
+});
+
+export const AgentsResourceQuerySchema = strictObject({
+  agent: AgentSchema,
+});
+
+export const ActivitiesResourceQuerySchema = strictObject({
+  activityId: IriSchema,
+});
+
+export const StateDocumentQuerySchema = strictObject({
+  activityId: IriSchema,
+  agent: AgentSchema,
+  registration: UuidSchema.optional(),
+  stateId: NonEmptyStringSchema.optional(),
+});
+
+export const StateDocumentListingQuerySchema = strictObject({
+  activityId: IriSchema,
+  agent: AgentSchema,
+  registration: UuidSchema.optional(),
+  since: Iso8601TimestampSchema.optional(),
+});
+
+export const AgentProfileDocumentQuerySchema = strictObject({
+  agent: AgentSchema,
+  profileId: NonEmptyStringSchema.optional(),
+});
+
+export const AgentProfileDocumentListingQuerySchema = strictObject({
+  agent: AgentSchema,
+  since: Iso8601TimestampSchema.optional(),
+});
+
+export const ActivityProfileDocumentQuerySchema = strictObject({
+  activityId: IriSchema,
+  profileId: NonEmptyStringSchema.optional(),
+});
+
+export const ActivityProfileDocumentListingQuerySchema = strictObject({
+  activityId: IriSchema,
+  since: Iso8601TimestampSchema.optional(),
+});
+
+export const XapiDocumentIdListSchema = z.array(NonEmptyStringSchema);
+
+export const SubStatementSchema = strictObject({
+  objectType: z.literal("SubStatement"),
+  actor: z.union([AgentSchema, GroupSchema]),
+  verb: VerbSchema,
+  object: z.union([ActivitySchema, AgentSchema, GroupSchema, StatementRefSchema]),
+  result: ResultSchema.optional(),
+  context: ContextSchema.optional(),
+  timestamp: Iso8601TimestampSchema.optional(),
+});
+
+export const StatementObjectSchema = z.union([
+  ActivitySchema,
+  AgentSchema,
+  GroupSchema,
+  StatementRefSchema,
+  SubStatementSchema,
+]);
+
+export const StatementSchema = strictObject({
+  id: UuidSchema.optional(),
+  actor: z.union([AgentSchema, GroupSchema]),
+  verb: VerbSchema,
+  object: StatementObjectSchema,
+  result: ResultSchema.optional(),
+  context: ContextSchema.optional(),
+  timestamp: Iso8601TimestampSchema.optional(),
+  stored: Iso8601TimestampSchema.optional(),
+  authority: z.union([AgentSchema, GroupSchema]).optional(),
+  version: XapiVersionSchema.optional(),
+  attachments: z.array(AttachmentSchema).min(1).optional(),
+});
+
+export const StatementResultMoreSchema = z.string().regex(/^$|^(?![A-Za-z][A-Za-z0-9+.-]*:)\S+$/u);
+
+export const StatementResultSchema = strictObject({
+  statements: z.array(StatementSchema),
+  more: StatementResultMoreSchema.optional(),
+});
+
+export const XapiHttpMethodSchema = z.enum(["GET", "HEAD", "PUT", "POST", "DELETE"]);
+
+export const XapiResourceSchema = strictObject({
+  name: NonEmptyStringSchema,
+  description: NonEmptyStringSchema,
+  methods: z.array(XapiHttpMethodSchema).min(1),
+});
+
+export const XapiRequestHeaderSchema = z.enum([
+  "Accept",
+  "Accept-Encoding",
+  "Accept-Language",
+  "Authorization",
+  "Content-Type",
+  "Content-Length",
+  "Content-Transfer-Encoding",
+  "If-Match",
+  "If-None-Match",
+  "X-Experience-API-Hash",
+  "X-Experience-API-Version",
+]);
+
+export const XapiResponseHeaderSchema = z.enum([
+  "Content-Type",
+  "Content-Length",
+  "Last-Modified",
+  "ETag",
+  "Status",
+  "X-Experience-API-Version",
+  "X-Experience-API-Consistent-Through",
+]);
+
+export const XapiErrorCodeSchema = z.enum(["400", "401", "403", "404", "409", "411", "412", "413", "500", "501"]);
+
+export const XapiErrorResponseSchema = strictObject({
+  code: XapiErrorCodeSchema,
+  message: NonEmptyStringSchema,
+  details: NonEmptyStringSchema.optional(),
+});
+
+export const XapiConcurrencySchema = strictObject({
+  etag: NonEmptyStringSchema.optional(),
+  ifMatch: NonEmptyStringSchema.optional(),
+  ifNoneMatch: NonEmptyStringSchema.optional(),
+});
+
+export const XapiMultipartAttachmentPartSchema = strictObject({
+  headers: strictObject({
+    "Content-Type": MediaTypeSchema,
+    "Content-Transfer-Encoding": z.literal("binary"),
+    "X-Experience-API-Hash": AttachmentSha2Schema,
+  }),
+  body: z.unknown(),
+});
+
+export const XapiMultipartRequestSchema = strictObject({
+  contentType: z.literal("multipart/mixed"),
+  parts: z.tuple([
+    strictObject({
+      contentType: z.literal("application/json"),
+      body: z.union([StatementSchema, z.array(StatementSchema).min(1)]),
+    }),
+    z.array(XapiMultipartAttachmentPartSchema).min(1),
+  ]),
+});
+// Inferred types from exported Zod validators.
+export type NonEmptyString = z.infer<typeof NonEmptyStringSchema>;
+export type Uuid = z.infer<typeof UuidSchema>;
+export type Iri = z.infer<typeof IriSchema>;
+export type MediaType = z.infer<typeof MediaTypeSchema>;
+export type LanguageTag = z.infer<typeof LanguageTagSchema>;
+export type XapiVersion = z.infer<typeof XapiVersionSchema>;
+export type Iso8601Timestamp = z.infer<typeof Iso8601TimestampSchema>;
+export type Iso8601Duration = z.infer<typeof Iso8601DurationSchema>;
+export type LanguageMap = z.infer<typeof LanguageMapSchema>;
+export type Extensions = z.infer<typeof ExtensionsSchema>;
+export type AttachmentSha2 = z.infer<typeof AttachmentSha2Schema>;
+export type AgentAccount = z.infer<typeof AgentAccountSchema>;
+export type Agent = z.infer<typeof AgentSchema>;
+export type Group = z.infer<typeof GroupSchema>;
+export type Person = z.infer<typeof PersonSchema>;
+export type Verb = z.infer<typeof VerbSchema>;
+export type InteractionType = z.infer<typeof InteractionTypeSchema>;
+export type InteractionComponent = z.infer<typeof InteractionComponentSchema>;
+export type ActivityDefinition = z.infer<typeof ActivityDefinitionSchema>;
+export type Activity = z.infer<typeof ActivitySchema>;
+export type StatementRef = z.infer<typeof StatementRefSchema>;
+export type Score = z.infer<typeof ScoreSchema>;
+export type Result = z.infer<typeof ResultSchema>;
+export type ContextActivities = z.infer<typeof ContextActivitiesSchema>;
+export type Context = z.infer<typeof ContextSchema>;
+export type Attachment = z.infer<typeof AttachmentSchema>;
+export type XapiDocument = z.infer<typeof XapiDocumentSchema>;
+export type StatementSubmission = z.infer<typeof StatementSubmissionSchema>;
+export type AboutResource = z.infer<typeof AboutResourceSchema>;
+export type StatementsQueryFormat = z.infer<typeof StatementsQueryFormatSchema>;
+export type StatementsQuery = z.infer<typeof StatementsQuerySchema>;
+export type AgentsResourceQuery = z.infer<typeof AgentsResourceQuerySchema>;
+export type ActivitiesResourceQuery = z.infer<typeof ActivitiesResourceQuerySchema>;
+export type StateDocumentQuery = z.infer<typeof StateDocumentQuerySchema>;
+export type StateDocumentListingQuery = z.infer<typeof StateDocumentListingQuerySchema>;
+export type AgentProfileDocumentQuery = z.infer<typeof AgentProfileDocumentQuerySchema>;
+export type AgentProfileDocumentListingQuery = z.infer<typeof AgentProfileDocumentListingQuerySchema>;
+export type ActivityProfileDocumentQuery = z.infer<typeof ActivityProfileDocumentQuerySchema>;
+export type ActivityProfileDocumentListingQuery = z.infer<typeof ActivityProfileDocumentListingQuerySchema>;
+export type XapiDocumentIdList = z.infer<typeof XapiDocumentIdListSchema>;
+export type SubStatement = z.infer<typeof SubStatementSchema>;
+export type StatementObject = z.infer<typeof StatementObjectSchema>;
+export type Statement = z.infer<typeof StatementSchema>;
+export type StatementResultMore = z.infer<typeof StatementResultMoreSchema>;
+export type StatementResult = z.infer<typeof StatementResultSchema>;
+export type XapiHttpMethod = z.infer<typeof XapiHttpMethodSchema>;
+export type XapiResource = z.infer<typeof XapiResourceSchema>;
+export type XapiRequestHeader = z.infer<typeof XapiRequestHeaderSchema>;
+export type XapiResponseHeader = z.infer<typeof XapiResponseHeaderSchema>;
+export type XapiErrorCode = z.infer<typeof XapiErrorCodeSchema>;
+export type XapiErrorResponse = z.infer<typeof XapiErrorResponseSchema>;
+export type XapiConcurrency = z.infer<typeof XapiConcurrencySchema>;
+export type XapiMultipartAttachmentPart = z.infer<typeof XapiMultipartAttachmentPartSchema>;
+export type XapiMultipartRequest = z.infer<typeof XapiMultipartRequestSchema>;