@conform-ed/contracts 0.0.3

package/src/oneroster/v1_2/shared.ts

@@ -0,0 +1,90 @@
+import { z } from "zod";
+
+function strictObject<T extends z.ZodRawShape>(shape: T) {
+  return z.object(shape).strict();
+}
+
+export function extensibleEnum<Values extends readonly [string, ...string[]]>(values: Values) {
+  return z.union([z.enum(values), ExtensibleVocabularyValueSchema]);
+}
+
+export function guidReferenceSchema<const EntityType extends string>(entityType: EntityType) {
+  return strictObject({
+    href: UrlSchema,
+    sourcedId: SourcedIdSchema,
+    type: z.literal(entityType),
+  });
+}
+
+export const UrlSchema = z.url();
+export const DateSchema = z.iso.date();
+export const DateTimeSchema = z.iso.datetime();
+export const SourcedIdSchema = z.string();
+export const EntityStatusSchema = z.enum(["active", "tobedeleted"]);
+export const TrueFalseStringSchema = z.enum(["true", "false"]);
+export const ExtensibleVocabularyValueSchema = z.string().regex(/^(ext:)[a-zA-Z0-9.\-_]+$/u);
+
+export const MetadataSchema = z.record(z.string(), z.unknown());
+
+export const AcadSessionGuidRefSchema = guidReferenceSchema("academicSession");
+export const ClassGuidRefSchema = guidReferenceSchema("class");
+export const CourseGuidRefSchema = guidReferenceSchema("course");
+export const OrgGuidRefSchema = guidReferenceSchema("org");
+export const ResourceGuidRefSchema = guidReferenceSchema("resource");
+export const UserGuidRefSchema = guidReferenceSchema("user");
+
+export const ImsxCodeMajorSchema = z.enum(["success", "processing", "failure", "unsupported"]);
+export const ImsxSeveritySchema = z.enum(["status", "warning", "error"]);
+export const ImsxCodeMinorFieldValueSchema = z.enum([
+  "deletefailure",
+  "forbidden",
+  "fullsuccess",
+  "internal_server_error",
+  "invalid_filter_field",
+  "invalid_selection_field",
+  "invalid_sort_field",
+  "invaliddata",
+  "server_busy",
+  "unauthorisedrequest",
+  "unknownobject",
+  "unsupported",
+]);
+
+export const ImsxCodeMinorFieldSchema = strictObject({
+  imsx_codeMinorFieldName: z.string(),
+  imsx_codeMinorFieldValue: ImsxCodeMinorFieldValueSchema,
+});
+
+export const ImsxCodeMinorSchema = strictObject({
+  imsx_codeMinorField: z.array(ImsxCodeMinorFieldSchema).min(1),
+});
+
+export const ImsxStatusInfoSchema = strictObject({
+  imsx_codeMajor: ImsxCodeMajorSchema,
+  imsx_severity: ImsxSeveritySchema,
+  imsx_description: z.string().optional(),
+  imsx_CodeMinor: ImsxCodeMinorSchema.optional(),
+});
+
+export { strictObject };
+// Inferred types from exported Zod validators.
+export type Url = z.infer<typeof UrlSchema>;
+export type Date = z.infer<typeof DateSchema>;
+export type DateTime = z.infer<typeof DateTimeSchema>;
+export type SourcedId = z.infer<typeof SourcedIdSchema>;
+export type EntityStatus = z.infer<typeof EntityStatusSchema>;
+export type TrueFalseString = z.infer<typeof TrueFalseStringSchema>;
+export type ExtensibleVocabularyValue = z.infer<typeof ExtensibleVocabularyValueSchema>;
+export type Metadata = z.infer<typeof MetadataSchema>;
+export type AcadSessionGuidRef = z.infer<typeof AcadSessionGuidRefSchema>;
+export type ClassGuidRef = z.infer<typeof ClassGuidRefSchema>;
+export type CourseGuidRef = z.infer<typeof CourseGuidRefSchema>;
+export type OrgGuidRef = z.infer<typeof OrgGuidRefSchema>;
+export type ResourceGuidRef = z.infer<typeof ResourceGuidRefSchema>;
+export type UserGuidRef = z.infer<typeof UserGuidRefSchema>;
+export type ImsxCodeMajor = z.infer<typeof ImsxCodeMajorSchema>;
+export type ImsxSeverity = z.infer<typeof ImsxSeveritySchema>;
+export type ImsxCodeMinorFieldValue = z.infer<typeof ImsxCodeMinorFieldValueSchema>;
+export type ImsxCodeMinorField = z.infer<typeof ImsxCodeMinorFieldSchema>;
+export type ImsxCodeMinor = z.infer<typeof ImsxCodeMinorSchema>;
+export type ImsxStatusInfo = z.infer<typeof ImsxStatusInfoSchema>;

package/src/open-badges/v3_0/index.ts

@@ -0,0 +1,20 @@
+export * from "./ob_v3p0_achievementcredential_schema";
+export * from "./ob_v3p0_endorsementcredential_schema";
+export * from "./ob_v3p0_profile_schema";
+export * from "./ob_v3p0_getopenbadgecredentialsresponse_schema";
+export * from "./ob_v3p0_imsx_statusinfo_schema";
+
+import { AchievementCredentialSchema, OpenBadgeCredentialSchema } from "./ob_v3p0_achievementcredential_schema";
+import { EndorsementCredentialSchema } from "./ob_v3p0_endorsementcredential_schema";
+import { GetOpenBadgeCredentialsResponseSchema } from "./ob_v3p0_getopenbadgecredentialsresponse_schema";
+import { ImsxStatusInfoSchema } from "./ob_v3p0_imsx_statusinfo_schema";
+import { ProfileSchema } from "./ob_v3p0_profile_schema";
+
+export const OpenBadges30DerivedZodTemplates = {
+  achievementCredential: AchievementCredentialSchema,
+  openBadgeCredential: OpenBadgeCredentialSchema,
+  endorsementCredential: EndorsementCredentialSchema,
+  getOpenBadgeCredentialsResponse: GetOpenBadgeCredentialsResponseSchema,
+  profile: ProfileSchema,
+  imsxStatusInfo: ImsxStatusInfoSchema,
+} as const;

package/src/open-badges/v3_0/ob_v3p0_achievementcredential_schema.ts

@@ -0,0 +1,17 @@
+export {
+  AchievementCredentialSchema,
+  AchievementSchema,
+  AchievementSubjectSchema,
+  AchievementTypeSchema,
+  AlignmentSchema,
+  AlignmentTargetTypeSchema,
+  CriteriaSchema,
+  IdentityObjectSchema,
+  OpenBadgeCredentialSchema,
+  RelatedSchema,
+  ResultDescriptionSchema,
+  ResultSchema,
+  ResultStatusTypeSchema,
+  ResultTypeSchema,
+  RubricCriterionLevelSchema,
+} from "./shared";

package/src/open-badges/v3_0/ob_v3p0_endorsementcredential_schema.ts

@@ -0,0 +1,11 @@
+export {
+  CredentialSchemaSchema,
+  CredentialStatusSchema,
+  EndorsementCredentialSchema,
+  EndorsementSubjectSchema,
+  EvidenceSchema,
+  ProfileRefSchema,
+  ProofSchema,
+  RefreshServiceSchema,
+  TermsOfUseSchema,
+} from "./shared";

package/src/open-badges/v3_0/ob_v3p0_getopenbadgecredentialsresponse_schema.ts

@@ -0,0 +1 @@
+export { GetOpenBadgeCredentialsResponseSchema } from "./shared";

package/src/open-badges/v3_0/ob_v3p0_imsx_statusinfo_schema.ts

@@ -0,0 +1,8 @@
+export {
+  ImsxCodeMajorSchema,
+  ImsxCodeMinorFieldSchema,
+  ImsxCodeMinorFieldValueSchema,
+  ImsxCodeMinorSchema,
+  ImsxSeveritySchema,
+  ImsxStatusInfoSchema,
+} from "../../shared/imsx-status";

package/src/open-badges/v3_0/ob_v3p0_profile_schema.ts

@@ -0,0 +1,9 @@
+export {
+  AddressSchema,
+  GeoCoordinatesSchema,
+  IdentifierEntrySchema,
+  IdentifierTypeEnumSchema,
+  ImageSchema,
+  ProfileRefSchema,
+  ProfileSchema,
+} from "./shared";

package/src/open-badges/v3_0/shared.ts

@@ -0,0 +1,458 @@
+import { z } from "zod";
+
+import {
+  CompactJwsValueSchema,
+  type CompactJwsValue,
+  contextArraySchema,
+  CredentialSchemaSchema,
+  CredentialStatusSchema,
+  credentialTypeSchema,
+  type JsonLdContextEntry,
+  localizedEnumValueSchema,
+  oneOrMany,
+  type OneOrManyValue,
+  passthroughObject,
+  ProofSchema,
+  RefreshServiceSchema,
+  singleTypeSchema,
+  TermsOfUseSchema,
+  TextValueSchema,
+  type TextValue,
+  UriValueSchema,
+  type UriValue,
+  W3cCredentialsV2ContextSchema,
+} from "../../vc-data-model/v2_0/shared";
+
+const OpenBadgesV30ContextUrlSchema = z
+  .string()
+  .regex(/^https:\/\/purl\.imsglobal\.org\/spec\/ob\/v3p0\/context(-3\.\d\.\d)*\.json$/u);
+
+type Profile = {
+  id: UriValue;
+  type: unknown;
+  name?: TextValue;
+  url?: UriValue;
+  phone?: TextValue;
+  description?: TextValue;
+  endorsement?: OneOrManyValue<EndorsementCredential>;
+  endorsementJwt?: OneOrManyValue<CompactJwsValue>;
+  image?: Record<string, unknown>;
+  email?: TextValue;
+  address?: Record<string, unknown>;
+  otherIdentifier?: OneOrManyValue<Record<string, unknown>>;
+  official?: TextValue;
+  parentOrg?: Profile;
+  familyName?: TextValue;
+  givenName?: TextValue;
+  additionalName?: TextValue;
+  patronymicName?: TextValue;
+  honorificPrefix?: TextValue;
+  honorificSuffix?: TextValue;
+  familyNamePrefix?: TextValue;
+  dateOfBirth?: string;
+  [key: string]: unknown;
+};
+
+type ProfileRef = Profile | UriValue;
+
+type EndorsementCredential = {
+  "@context": JsonLdContextEntry[];
+  type: unknown;
+  id: UriValue;
+  name: TextValue;
+  description?: TextValue;
+  credentialSubject: Record<string, unknown>;
+  awardedDate?: string;
+  issuer: ProfileRef;
+  validFrom: string;
+  validUntil?: string;
+  proof?: OneOrManyValue<Record<string, unknown>>;
+  credentialSchema?: OneOrManyValue<Record<string, unknown>>;
+  credentialStatus?: Record<string, unknown>;
+  refreshService?: Record<string, unknown>;
+  termsOfUse?: OneOrManyValue<Record<string, unknown>>;
+  evidence?: OneOrManyValue<Record<string, unknown>>;
+  [key: string]: unknown;
+};
+
+const IDENTIFIER_TYPES = [
+  "name",
+  "sourcedId",
+  "systemId",
+  "productId",
+  "userName",
+  "accountId",
+  "emailAddress",
+  "nationalIdentityNumber",
+  "isbn",
+  "issn",
+  "lisSourcedId",
+  "oneRosterSourcedId",
+  "sisSourcedId",
+  "ltiContextId",
+  "ltiDeploymentId",
+  "ltiToolId",
+  "ltiPlatformId",
+  "ltiUserId",
+  "identifier",
+] as const;
+
+const ACHIEVEMENT_TYPES = [
+  "Achievement",
+  "ApprenticeshipCertificate",
+  "Assessment",
+  "Assignment",
+  "AssociateDegree",
+  "Award",
+  "Badge",
+  "BachelorDegree",
+  "Certificate",
+  "CertificateOfCompletion",
+  "Certification",
+  "CommunityService",
+  "Competency",
+  "Course",
+  "CoCurricular",
+  "Degree",
+  "Diploma",
+  "DoctoralDegree",
+  "Fieldwork",
+  "GeneralEducationDevelopment",
+  "JourneymanCertificate",
+  "LearningProgram",
+  "License",
+  "Membership",
+  "ProfessionalDoctorate",
+  "QualityAssuranceCredential",
+  "MasterCertificate",
+  "MasterDegree",
+  "MicroCredential",
+  "ResearchDoctorate",
+  "SecondarySchoolDiploma",
+] as const;
+
+const ALIGNMENT_TARGET_TYPES = [
+  "ceasn:Competency",
+  "ceterms:Credential",
+  "CFItem",
+  "CFRubric",
+  "CFRubricCriterion",
+  "CFRubricCriterionLevel",
+  "CTDL",
+] as const;
+
+const RESULT_TYPES = [
+  "GradePointAverage",
+  "LetterGrade",
+  "Percent",
+  "PerformanceLevel",
+  "PredictedScore",
+  "RawScore",
+  "Result",
+  "RubricCriterion",
+  "RubricCriterionLevel",
+  "RubricScore",
+  "ScaledScore",
+  "Status",
+] as const;
+
+const RESULT_STATUSES = ["Completed", "Enrolled", "Failed", "InProgress", "OnHold", "Provisional", "Withdrew"] as const;
+
+export const IdentifierTypeEnumSchema = z.enum(IDENTIFIER_TYPES);
+export const AchievementTypeSchema = z.enum(ACHIEVEMENT_TYPES);
+export const AlignmentTargetTypeSchema = z.enum(ALIGNMENT_TARGET_TYPES);
+export const ResultTypeSchema = z.enum(RESULT_TYPES);
+export const ResultStatusTypeSchema = z.enum(RESULT_STATUSES);
+
+export const OpenBadgesAchievementCredentialContextSchema = contextArraySchema("Open Badges 3.0", [
+  W3cCredentialsV2ContextSchema,
+  OpenBadgesV30ContextUrlSchema,
+]);
+
+export const OpenBadgesEndorsementCredentialContextSchema = contextArraySchema("Open Badges 3.0", [
+  W3cCredentialsV2ContextSchema,
+  OpenBadgesV30ContextUrlSchema,
+]);
+
+export const OpenBadgesVerifiableCredentialContextSchema = contextArraySchema("Open Badges 3.0", [
+  W3cCredentialsV2ContextSchema,
+]);
+
+export const ImageSchema = passthroughObject({
+  id: UriValueSchema,
+  type: singleTypeSchema("Image"),
+  caption: TextValueSchema.optional(),
+});
+
+export const GeoCoordinatesSchema = passthroughObject({
+  type: singleTypeSchema("GeoCoordinates"),
+  latitude: z.number(),
+  longitude: z.number(),
+});
+
+export const AddressSchema = passthroughObject({
+  type: singleTypeSchema("Address"),
+  addressCountry: TextValueSchema.optional(),
+  addressCountryCode: TextValueSchema.optional(),
+  addressRegion: TextValueSchema.optional(),
+  addressLocality: TextValueSchema.optional(),
+  streetAddress: TextValueSchema.optional(),
+  postOfficeBoxNumber: TextValueSchema.optional(),
+  postalCode: TextValueSchema.optional(),
+  geo: GeoCoordinatesSchema.optional(),
+});
+
+export const IdentifierEntrySchema = passthroughObject({
+  type: singleTypeSchema("IdentifierEntry"),
+  identifier: TextValueSchema,
+  identifierType: localizedEnumValueSchema(IDENTIFIER_TYPES),
+});
+
+export const CriteriaSchema = passthroughObject({
+  id: UriValueSchema.optional(),
+  narrative: TextValueSchema.optional(),
+});
+
+export const AlignmentSchema = passthroughObject({
+  type: singleTypeSchema("Alignment"),
+  targetCode: TextValueSchema.optional(),
+  targetDescription: TextValueSchema.optional(),
+  targetName: TextValueSchema,
+  targetFramework: TextValueSchema.optional(),
+  targetType: localizedEnumValueSchema(ALIGNMENT_TARGET_TYPES).optional(),
+  targetUrl: UriValueSchema,
+});
+
+export const RelatedSchema = passthroughObject({
+  id: UriValueSchema,
+  type: singleTypeSchema("Related"),
+  inLanguage: TextValueSchema.optional(),
+  version: TextValueSchema.optional(),
+});
+
+export const RubricCriterionLevelSchema = passthroughObject({
+  id: UriValueSchema,
+  type: singleTypeSchema("RubricCriterionLevel"),
+  alignment: oneOrMany(AlignmentSchema).optional(),
+  description: TextValueSchema.optional(),
+  level: TextValueSchema.optional(),
+  name: TextValueSchema.optional(),
+  points: TextValueSchema.optional(),
+});
+
+export const ResultDescriptionSchema = passthroughObject({
+  id: UriValueSchema,
+  type: singleTypeSchema("ResultDescription"),
+  alignment: oneOrMany(AlignmentSchema).optional(),
+  allowedValue: oneOrMany(TextValueSchema).optional(),
+  name: TextValueSchema,
+  requiredLevel: TextValueSchema.optional(),
+  requiredValue: TextValueSchema.optional(),
+  resultType: localizedEnumValueSchema(RESULT_TYPES),
+  rubricCriterionLevel: oneOrMany(RubricCriterionLevelSchema).optional(),
+  valueMax: TextValueSchema.optional(),
+  valueMin: TextValueSchema.optional(),
+});
+
+export const EvidenceSchema = passthroughObject({
+  id: UriValueSchema.optional(),
+  type: singleTypeSchema("Evidence"),
+  narrative: TextValueSchema.optional(),
+  name: TextValueSchema.optional(),
+  description: TextValueSchema.optional(),
+  genre: TextValueSchema.optional(),
+  audience: TextValueSchema.optional(),
+});
+
+export const EndorsementSubjectSchema = passthroughObject({
+  id: UriValueSchema.optional(),
+  type: singleTypeSchema("EndorsementSubject"),
+  endorsementComment: TextValueSchema.optional(),
+});
+
+export const CredentialSubjectSchema = passthroughObject({
+  id: UriValueSchema.optional(),
+});
+
+export const ProfileSchema: z.ZodType<Profile> = passthroughObject({
+  id: UriValueSchema,
+  type: singleTypeSchema("Profile"),
+  name: TextValueSchema.optional(),
+  url: UriValueSchema.optional(),
+  phone: TextValueSchema.optional(),
+  description: TextValueSchema.optional(),
+  endorsement: z.lazy(() => oneOrMany(EndorsementCredentialSchema)).optional(),
+  endorsementJwt: oneOrMany(CompactJwsValueSchema).optional(),
+  image: ImageSchema.optional(),
+  email: TextValueSchema.optional(),
+  address: AddressSchema.optional(),
+  otherIdentifier: oneOrMany(IdentifierEntrySchema).optional(),
+  official: TextValueSchema.optional(),
+  parentOrg: z.lazy(() => ProfileSchema).optional(),
+  familyName: TextValueSchema.optional(),
+  givenName: TextValueSchema.optional(),
+  additionalName: TextValueSchema.optional(),
+  patronymicName: TextValueSchema.optional(),
+  honorificPrefix: TextValueSchema.optional(),
+  honorificSuffix: TextValueSchema.optional(),
+  familyNamePrefix: TextValueSchema.optional(),
+  dateOfBirth: z.iso.date().optional(),
+});
+
+export const ProfileRefSchema: z.ZodType<ProfileRef> = z.lazy(() => z.union([ProfileSchema, UriValueSchema]));
+
+export const EndorsementCredentialSchema: z.ZodType<EndorsementCredential> = passthroughObject({
+  "@context": OpenBadgesEndorsementCredentialContextSchema,
+  type: credentialTypeSchema(["EndorsementCredential"]),
+  id: UriValueSchema,
+  name: TextValueSchema,
+  description: TextValueSchema.optional(),
+  credentialSubject: EndorsementSubjectSchema,
+  awardedDate: z.iso.datetime().optional(),
+  issuer: ProfileRefSchema,
+  validFrom: z.iso.datetime(),
+  validUntil: z.iso.datetime().optional(),
+  proof: oneOrMany(ProofSchema).optional(),
+  credentialSchema: oneOrMany(CredentialSchemaSchema).optional(),
+  credentialStatus: CredentialStatusSchema.optional(),
+  refreshService: RefreshServiceSchema.optional(),
+  termsOfUse: oneOrMany(TermsOfUseSchema).optional(),
+  evidence: oneOrMany(EvidenceSchema).optional(),
+});
+
+export const AchievementSchema = passthroughObject({
+  id: UriValueSchema,
+  type: singleTypeSchema("Achievement"),
+  alignment: oneOrMany(AlignmentSchema).optional(),
+  achievementType: localizedEnumValueSchema(ACHIEVEMENT_TYPES).optional(),
+  creator: ProfileSchema.optional(),
+  creditsAvailable: z.number().optional(),
+  criteria: CriteriaSchema,
+  description: TextValueSchema,
+  endorsement: oneOrMany(EndorsementCredentialSchema).optional(),
+  endorsementJwt: oneOrMany(CompactJwsValueSchema).optional(),
+  fieldOfStudy: TextValueSchema.optional(),
+  humanCode: TextValueSchema.optional(),
+  image: ImageSchema.optional(),
+  inLanguage: TextValueSchema.optional(),
+  name: TextValueSchema,
+  otherIdentifier: oneOrMany(IdentifierEntrySchema).optional(),
+  related: oneOrMany(RelatedSchema).optional(),
+  resultDescription: oneOrMany(ResultDescriptionSchema).optional(),
+  specialization: TextValueSchema.optional(),
+  tag: oneOrMany(TextValueSchema).optional(),
+  version: TextValueSchema.optional(),
+});
+
+export const IdentityObjectSchema = passthroughObject({
+  type: singleTypeSchema("IdentityObject"),
+  hashed: z.boolean().optional(),
+  identityHash: TextValueSchema.optional(),
+  identityType: localizedEnumValueSchema(IDENTIFIER_TYPES).optional(),
+  salt: TextValueSchema.optional(),
+});
+
+export const ResultSchema = passthroughObject({
+  type: singleTypeSchema("Result"),
+  achievedLevel: TextValueSchema.optional(),
+  alignment: oneOrMany(AlignmentSchema).optional(),
+  resultDescription: TextValueSchema.optional(),
+  status: ResultStatusTypeSchema.optional(),
+  value: TextValueSchema.optional(),
+});
+
+export const AchievementSubjectSchema = passthroughObject({
+  id: UriValueSchema.optional(),
+  type: singleTypeSchema("AchievementSubject"),
+  activityEndDate: z.iso.date().optional(),
+  activityStartDate: z.iso.date().optional(),
+  creditsEarned: z.number().optional(),
+  achievement: AchievementSchema,
+  identifier: oneOrMany(IdentityObjectSchema).optional(),
+  image: ImageSchema.optional(),
+  licenseNumber: TextValueSchema.optional(),
+  narrative: TextValueSchema.optional(),
+  result: oneOrMany(ResultSchema).optional(),
+  role: TextValueSchema.optional(),
+  source: ProfileSchema.optional(),
+  term: TextValueSchema.optional(),
+});
+
+export const AchievementCredentialSchema = passthroughObject({
+  "@context": OpenBadgesAchievementCredentialContextSchema,
+  id: UriValueSchema,
+  type: credentialTypeSchema(["AchievementCredential", "OpenBadgeCredential"]),
+  name: TextValueSchema.optional(),
+  description: TextValueSchema.optional(),
+  image: ImageSchema.optional(),
+  awardedDate: z.iso.datetime().optional(),
+  credentialSubject: AchievementSubjectSchema,
+  endorsement: oneOrMany(EndorsementCredentialSchema).optional(),
+  endorsementJwt: oneOrMany(CompactJwsValueSchema).optional(),
+  issuer: ProfileRefSchema,
+  validFrom: z.iso.datetime(),
+  validUntil: z.iso.datetime().optional(),
+  proof: oneOrMany(ProofSchema).optional(),
+  credentialSchema: oneOrMany(CredentialSchemaSchema).optional(),
+  credentialStatus: CredentialStatusSchema.optional(),
+  refreshService: RefreshServiceSchema.optional(),
+  termsOfUse: oneOrMany(TermsOfUseSchema).optional(),
+  evidence: oneOrMany(EvidenceSchema).optional(),
+});
+
+export const OpenBadgeCredentialSchema = AchievementCredentialSchema;
+
+export const VerifiableCredentialSchema = passthroughObject({
+  "@context": OpenBadgesVerifiableCredentialContextSchema,
+  id: UriValueSchema.optional(),
+  type: singleTypeSchema("VerifiableCredential"),
+  issuer: ProfileRefSchema,
+  validFrom: z.iso.datetime(),
+  validUntil: z.iso.datetime().optional(),
+  credentialSubject: CredentialSubjectSchema,
+  proof: oneOrMany(ProofSchema).optional(),
+  credentialSchema: oneOrMany(CredentialSchemaSchema).optional(),
+  credentialStatus: CredentialStatusSchema.optional(),
+  refreshService: RefreshServiceSchema.optional(),
+  termsOfUse: oneOrMany(TermsOfUseSchema).optional(),
+  evidence: oneOrMany(EvidenceSchema).optional(),
+});
+
+export const GetOpenBadgeCredentialsResponseSchema = z
+  .object({
+    credential: oneOrMany(AchievementCredentialSchema).optional(),
+    compactJwsString: oneOrMany(CompactJwsValueSchema).optional(),
+  })
+  .strict();
+
+export { OpenBadgesV30ContextUrlSchema };
+export { CredentialSchemaSchema, CredentialStatusSchema, ProofSchema, RefreshServiceSchema, TermsOfUseSchema };
+// Inferred types from exported Zod validators.
+export type IdentifierTypeEnum = z.infer<typeof IdentifierTypeEnumSchema>;
+export type AchievementType = z.infer<typeof AchievementTypeSchema>;
+export type AlignmentTargetType = z.infer<typeof AlignmentTargetTypeSchema>;
+export type ResultType = z.infer<typeof ResultTypeSchema>;
+export type ResultStatusType = z.infer<typeof ResultStatusTypeSchema>;
+export type OpenBadgesAchievementCredentialContext = z.infer<typeof OpenBadgesAchievementCredentialContextSchema>;
+export type OpenBadgesEndorsementCredentialContext = z.infer<typeof OpenBadgesEndorsementCredentialContextSchema>;
+export type OpenBadgesVerifiableCredentialContext = z.infer<typeof OpenBadgesVerifiableCredentialContextSchema>;
+export type Image = z.infer<typeof ImageSchema>;
+export type GeoCoordinates = z.infer<typeof GeoCoordinatesSchema>;
+export type Address = z.infer<typeof AddressSchema>;
+export type IdentifierEntry = z.infer<typeof IdentifierEntrySchema>;
+export type Criteria = z.infer<typeof CriteriaSchema>;
+export type Alignment = z.infer<typeof AlignmentSchema>;
+export type Related = z.infer<typeof RelatedSchema>;
+export type RubricCriterionLevel = z.infer<typeof RubricCriterionLevelSchema>;
+export type ResultDescription = z.infer<typeof ResultDescriptionSchema>;
+export type Evidence = z.infer<typeof EvidenceSchema>;
+export type EndorsementSubject = z.infer<typeof EndorsementSubjectSchema>;
+export type CredentialSubject = z.infer<typeof CredentialSubjectSchema>;
+export type Achievement = z.infer<typeof AchievementSchema>;
+export type IdentityObject = z.infer<typeof IdentityObjectSchema>;
+export type Result = z.infer<typeof ResultSchema>;
+export type AchievementSubject = z.infer<typeof AchievementSubjectSchema>;
+export type AchievementCredential = z.infer<typeof AchievementCredentialSchema>;
+export type OpenBadgeCredential = z.infer<typeof OpenBadgeCredentialSchema>;
+export type VerifiableCredential = z.infer<typeof VerifiableCredentialSchema>;
+export type GetOpenBadgeCredentialsResponse = z.infer<typeof GetOpenBadgeCredentialsResponseSchema>;