@conform-ed/contracts 0.0.3

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

@@ -0,0 +1,124 @@
+import { z } from "zod";
+
+import { UriReferenceSchema, addIssue, asArray, collectDuplicates, looseObject, strictObject } from "../shared";
+
+export const VdexProfilesTypeSchema = z.enum([
+  "lax",
+  "hierarchicalTokenTerms",
+  "flatTokenTerms",
+  "glossaryOrDictionary",
+  "thesaurus",
+]);
+
+export const VdexIdentifierSchema = looseObject({
+  value: UriReferenceSchema,
+});
+
+export const VdexMediaLocatorSchema = looseObject({
+  value: UriReferenceSchema,
+});
+
+export const VdexLangStringSchema = looseObject({
+  value: z.string(),
+  language: z.string().optional(),
+});
+
+export const VdexLangStringBagSchema = looseObject({
+  langstring: z.array(VdexLangStringSchema).min(1),
+});
+
+export const VdexDescriptionSchema = VdexLangStringBagSchema;
+
+export const VdexVocabSchema = looseObject({
+  value: z.string(),
+  source: UriReferenceSchema,
+});
+
+export const VdexMetadataSchema = looseObject({});
+
+export const VdexMediaDescriptorSchema = looseObject({
+  mediaLocator: VdexMediaLocatorSchema,
+  interpretationNote: VdexDescriptionSchema.optional(),
+});
+
+export const VdexVocabIdentifierSchema = looseObject({
+  value: UriReferenceSchema,
+  isRegistered: z.boolean().optional(),
+});
+
+export const VdexTermRefSchema = looseObject({
+  value: UriReferenceSchema,
+  vocabularyIdentifier: UriReferenceSchema.optional(),
+});
+
+export const VdexTermSchema: z.ZodTypeAny = z.lazy(() =>
+  looseObject({
+    termIdentifier: VdexIdentifierSchema,
+    caption: VdexLangStringBagSchema.optional(),
+    description: VdexDescriptionSchema.optional(),
+    mediaDescriptor: z.array(VdexMediaDescriptorSchema).optional(),
+    metadata: z.array(VdexMetadataSchema).optional(),
+    term: z.array(VdexTermSchema).optional(),
+    orderSignificant: z.boolean().optional(),
+    validIndex: z.boolean().optional(),
+  }),
+);
+
+export const VdexRelationshipSchema = looseObject({
+  relationshipIdentifier: VdexIdentifierSchema.optional(),
+  sourceTerm: VdexTermRefSchema,
+  targetTerm: VdexTermRefSchema,
+  relationshipType: VdexVocabSchema.optional(),
+  metadata: z.array(VdexMetadataSchema).optional(),
+});
+
+type VdexTermLike = {
+  termIdentifier: { value: string };
+  term?: VdexTermLike[];
+};
+
+function collectVdexTermIdentifiers(term: VdexTermLike, into: string[]) {
+  into.push(term.termIdentifier.value);
+  for (const child of asArray(term.term)) {
+    collectVdexTermIdentifiers(child, into);
+  }
+}
+
+export const VdexSchema = looseObject({
+  vocabName: VdexLangStringBagSchema.optional(),
+  vocabIdentifier: VdexVocabIdentifierSchema.optional(),
+  term: z.array(VdexTermSchema).min(1),
+  relationship: z.array(VdexRelationshipSchema).optional(),
+  metadata: z.array(VdexMetadataSchema).optional(),
+  orderSignificant: z.boolean().optional(),
+  profileType: VdexProfilesTypeSchema.optional(),
+  language: z.string().optional(),
+}).superRefine((vdex, context) => {
+  const termIdentifiers: string[] = [];
+  for (const term of vdex.term) {
+    collectVdexTermIdentifiers(term as VdexTermLike, termIdentifiers);
+  }
+
+  for (const duplicate of collectDuplicates(termIdentifiers)) {
+    addIssue(context, ["term"], `Duplicate VDEX termIdentifier value: ${duplicate}`);
+  }
+});
+
+export const VdexDocumentSchema = strictObject({
+  vdex: VdexSchema,
+});
+// Inferred types from exported Zod validators.
+export type VdexProfilesType = z.infer<typeof VdexProfilesTypeSchema>;
+export type VdexIdentifier = z.infer<typeof VdexIdentifierSchema>;
+export type VdexMediaLocator = z.infer<typeof VdexMediaLocatorSchema>;
+export type VdexLangString = z.infer<typeof VdexLangStringSchema>;
+export type VdexLangStringBag = z.infer<typeof VdexLangStringBagSchema>;
+export type VdexDescription = z.infer<typeof VdexDescriptionSchema>;
+export type VdexVocab = z.infer<typeof VdexVocabSchema>;
+export type VdexMetadata = z.infer<typeof VdexMetadataSchema>;
+export type VdexMediaDescriptor = z.infer<typeof VdexMediaDescriptorSchema>;
+export type VdexVocabIdentifier = z.infer<typeof VdexVocabIdentifierSchema>;
+export type VdexTermRef = z.infer<typeof VdexTermRefSchema>;
+export type VdexRelationship = z.infer<typeof VdexRelationshipSchema>;
+export type Vdex = z.infer<typeof VdexSchema>;
+export type VdexDocument = z.infer<typeof VdexDocumentSchema>;

package/src/config.ts

@@ -0,0 +1,121 @@
+import { z } from "zod";
+
+export const SuiteNameSchema = z.enum(["lrs", "cmi5", "lti13"]);
+export const LogLevelSchema = z.enum(["error", "warn", "info", "debug"]);
+
+const RequirementIdArraySchema = z.array(z.string().min(1)).min(1);
+
+const TimeoutsSchema = z
+  .object({
+    connectMs: z.number().int().min(100).max(120_000).default(5_000),
+    readMs: z.number().int().min(100).max(120_000).default(30_000),
+    operationMs: z.number().int().min(100).max(600_000).default(120_000),
+    assertionMs: z.number().int().min(100).max(600_000).default(60_000),
+    retryMaxAttempts: z.number().int().min(0).max(10).default(2),
+    retryBackoffMs: z.number().int().min(0).max(60_000).default(1_000),
+  })
+  .default(() => ({
+    connectMs: 5_000,
+    readMs: 30_000,
+    operationMs: 120_000,
+    assertionMs: 60_000,
+    retryMaxAttempts: 2,
+    retryBackoffMs: 1_000,
+  }));
+
+const ArtifactsSchema = z.object({
+  outputDir: z.string().min(1),
+  summaryFile: z.string().min(1).default("summary.json"),
+  junitFile: z.string().min(1).default("junit.xml"),
+  requirementTraceFile: z.string().min(1).default("requirement-trace.json"),
+  runMetadataFile: z.string().min(1).default("run-metadata.json"),
+});
+
+const AdapterSchema = z
+  .object({
+    kind: z.literal("http").default("http"),
+    baseUrl: z.url(),
+    profileVersion: z
+      .string()
+      .regex(/^\d+\.\d+\.\d+$/u)
+      .default("1.0.0"),
+    auth: z
+      .object({
+        mode: z.enum(["none", "bearer"]).default("bearer"),
+        tokenFromEnv: z.string().min(1).optional(),
+      })
+      .default((): { mode: "none" | "bearer"; tokenFromEnv?: string } => ({
+        mode: "bearer" as const,
+      })),
+    requiredCapabilities: z.array(z.string().min(1)).default([]),
+  })
+  .nullable()
+  .default(null)
+  .superRefine((adapter, context) => {
+    if (!adapter) {
+      return;
+    }
+    if (adapter.auth.mode === "bearer" && !adapter.auth.tokenFromEnv) {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "adapter.auth.tokenFromEnv is required when adapter.auth.mode is bearer",
+        path: ["auth", "tokenFromEnv"],
+      });
+    }
+  });
+
+export const RunnerConfigSchema = z
+  .object({
+    contractVersion: z
+      .string()
+      .regex(/^\d+\.\d+\.\d+$/u)
+      .default("1.0.0"),
+    suite: z.object({
+      name: SuiteNameSchema,
+      target: z.string().min(1),
+    }),
+    sut: z.record(z.string(), z.unknown()),
+    auth: z.record(z.string(), z.unknown()).default({}),
+    selection: z
+      .object({
+        includeRequirementIds: RequirementIdArraySchema.optional(),
+        excludeRequirementIds: RequirementIdArraySchema.optional(),
+      })
+      .default({}),
+    timeouts: TimeoutsSchema,
+    artifacts: ArtifactsSchema,
+    debug: z
+      .object({
+        logLevel: LogLevelSchema.default("info"),
+        redactionEnabled: z.boolean().default(true),
+      })
+      .default((): { logLevel: z.infer<typeof LogLevelSchema>; redactionEnabled: boolean } => ({
+        logLevel: "info" as const,
+        redactionEnabled: true,
+      })),
+    adapter: AdapterSchema,
+    suiteConfig: z.record(z.string(), z.unknown()).default({}),
+  })
+  .superRefine((config, context) => {
+    if (config.suite.name === "cmi5") {
+      if (!["runtime", "package", "all"].includes(config.suite.target)) {
+        context.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "suite.target must be runtime, package, or all when suite.name is cmi5",
+          path: ["suite", "target"],
+        });
+      }
+      if (!config.adapter) {
+        context.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "adapter is required when suite.name is cmi5",
+          path: ["adapter"],
+        });
+      }
+    }
+  });
+
+export type RunnerConfig = z.infer<typeof RunnerConfigSchema>;
+// Inferred types from exported Zod validators.
+export type SuiteName = z.infer<typeof SuiteNameSchema>;
+export type LogLevel = z.infer<typeof LogLevelSchema>;

package/src/index.ts

@@ -0,0 +1,32 @@
+export * from "./config";
+export * from "./summary";
+export * from "./adapter";
+export * from "./cmi5";
+export * from "./qti/v3_0_1";
+export * from "./lti";
+export * as QtiV2_1 from "./qti/v2_1";
+export * as QtiV2_2 from "./qti/v2_2";
+export * as QtiV3_0_1 from "./qti/v3_0_1";
+export * as Cmi5 from "./cmi5";
+export * as Cmi5V1_0 from "./cmi5/v1_0";
+export * as Xapi from "./xapi";
+export * as XapiV1_0_3 from "./xapi/v1_0_3";
+export * as XapiV2_0 from "./xapi/v2_0";
+export * as Lti from "./lti";
+export * as LtiV1_3 from "./lti/v1_3";
+export * as LtiDeepLinkingV2_0 from "./lti/deep-linking/v2_0";
+export * as LtiAgsV2_0 from "./lti/ags/v2_0";
+export * as LtiNrpsV2_0 from "./lti/nrps/v2_0";
+export * as LtiProctoringV1_0 from "./lti/proctoring/v1_0";
+export * as CaliperV1_2 from "./caliper/v1_2";
+export { Caliper12DerivedZodTemplates } from "./caliper/v1_2";
+export * as CommonCartridgeV1_3 from "./common-cartridge/v1_3";
+export * as CommonCartridgeV1_4 from "./common-cartridge/v1_4";
+export * as CaseV1_1 from "./case/v1_1";
+export { Case11DerivedZodTemplates } from "./case/v1_1";
+export * as CatV1_0 from "./cat/v1_0";
+export { Cat10DerivedZodTemplates } from "./cat/v1_0";
+export * as ClrV2_0 from "./clr/v2_0";
+export * as OpenBadgesV3_0 from "./open-badges/v3_0";
+export * as OneRosterV1_2 from "./oneroster/v1_2";
+export * as VcDataModelV2_0 from "./vc-data-model/v2_0";

package/src/lti/ags/v2_0/index.ts

@@ -0,0 +1,97 @@
+export * from "../../shared";
+
+import { z } from "zod";
+
+import { NonEmptyStringSchema, UrlSchema, strictObject } from "../../shared";
+
+export const AgsScopeSchema = z.enum([
+  "https://purl.imsglobal.org/spec/lti-ags/scope/lineitem",
+  "https://purl.imsglobal.org/spec/lti-ags/scope/lineitem.readonly",
+  "https://purl.imsglobal.org/spec/lti-ags/scope/result.readonly",
+  "https://purl.imsglobal.org/spec/lti-ags/scope/score",
+]);
+
+export const EndpointSchema = strictObject({
+  scope: z.array(AgsScopeSchema).min(1),
+  lineitems: UrlSchema,
+  lineitem: UrlSchema.optional(),
+});
+
+export const LineItemSchema = strictObject({
+  id: UrlSchema.optional(),
+  label: NonEmptyStringSchema,
+  scoreMaximum: z.number().nonnegative(),
+  resourceId: NonEmptyStringSchema.optional(),
+  resourceLinkId: NonEmptyStringSchema.optional(),
+  tag: NonEmptyStringSchema.optional(),
+  startDateTime: z.iso.datetime().optional(),
+  endDateTime: z.iso.datetime().optional(),
+  gradesReleased: z.boolean().optional(),
+});
+
+export const ScoreProgressSchema = z.enum(["Completed", "Failed", "InProgress", "Initialized", "Submitted", "Started"]);
+export const GradingProgressSchema = z.enum(["Failed", "FullyGraded", "NotReady", "Pending", "PendingManual"]);
+
+export const ScoreSubmissionSchema = strictObject({
+  startedAt: z.iso.datetime().optional(),
+  submittedAt: z.iso.datetime().optional(),
+});
+
+export const ScoreSchema = strictObject({
+  userId: NonEmptyStringSchema,
+  scoreGiven: z.number().optional(),
+  scoreMaximum: z.number().optional(),
+  activityProgress: ScoreProgressSchema.optional(),
+  gradingProgress: GradingProgressSchema.optional(),
+  timestamp: z.iso.datetime().optional(),
+  submission: ScoreSubmissionSchema.optional(),
+  comment: z.string().optional(),
+  scorePublished: z.boolean().optional(),
+});
+
+export const ResultSchema = strictObject({
+  id: UrlSchema.optional(),
+  scoreOf: UrlSchema.optional(),
+  userId: NonEmptyStringSchema,
+  resultScore: z.number().optional(),
+  resultMaximum: z.number().optional(),
+  scoringUserId: NonEmptyStringSchema.optional(),
+  comment: z.string().optional(),
+});
+
+export namespace LtiAgsV2_0 {
+  export namespace Schemas {
+    export const Endpoint = EndpointSchema;
+    export const LineItem = LineItemSchema;
+    export const Score = ScoreSchema;
+    export const ScoreSubmission = ScoreSubmissionSchema;
+    export const Result = ResultSchema;
+    export const AgsScope = AgsScopeSchema;
+    export const ScoreProgress = ScoreProgressSchema;
+    export const GradingProgress = GradingProgressSchema;
+  }
+}
+
+export type LtiAgsV2_0Schemas = typeof LtiAgsV2_0.Schemas;
+
+export const LtiAgsV2_0DerivedZodTemplates = {
+  description: "LTI AGS v2.0 Zod schemas for normalized endpoint, line item, score, and result objects",
+  specLinks: {
+    main: "https://www.imsglobal.org/spec/lti-ags/v2p0/",
+  },
+  scope: "Assignment and Grade Services endpoint, line item, score, and result payloads",
+  claims: ["endpoint"],
+  notes: [
+    "The endpoint claim is modeled in normalized camelCase form with explicit scope validation.",
+    "Score and result payloads are strict JSON objects suitable for adapter/reference app contracts.",
+  ],
+} as const;
+// Inferred types from exported Zod validators.
+export type AgsScope = z.infer<typeof AgsScopeSchema>;
+export type Endpoint = z.infer<typeof EndpointSchema>;
+export type LineItem = z.infer<typeof LineItemSchema>;
+export type ScoreProgress = z.infer<typeof ScoreProgressSchema>;
+export type GradingProgress = z.infer<typeof GradingProgressSchema>;
+export type ScoreSubmission = z.infer<typeof ScoreSubmissionSchema>;
+export type Score = z.infer<typeof ScoreSchema>;
+export type Result = z.infer<typeof ResultSchema>;

package/src/lti/deep-linking/v2_0/index.ts

@@ -0,0 +1,100 @@
+export * from "../../shared";
+
+import { z } from "zod";
+
+import {
+  ContextSchema,
+  CustomParametersSchema,
+  ImageResourceSchema,
+  LaunchPresentationSchema,
+  LisSchema,
+  NonEmptyStringSchema,
+  ResourceLinkSchema,
+  RolesSchema,
+  UrlSchema,
+  LtiVersionSchema,
+  strictObject,
+} from "../../shared";
+import { LineItemSchema } from "../../ags/v2_0";
+
+export const ContentItemTypeSchema = z.enum(["file", "html", "image", "link", "ltiResourceLink"]);
+
+export const DeepLinkingSettingsSchema = strictObject({
+  deepLinkReturnUrl: UrlSchema,
+  acceptTypes: z.array(ContentItemTypeSchema).min(1),
+  acceptPresentationDocumentTargets: z.array(z.enum(["embed", "frame", "iframe", "popup", "tab", "window"])).optional(),
+  acceptMediaTypes: z.union([NonEmptyStringSchema, z.array(NonEmptyStringSchema).min(1)]).optional(),
+  acceptMultiple: z.boolean().optional(),
+  autoCreate: z.boolean().optional(),
+  title: z.string().optional(),
+  text: z.string().optional(),
+  data: z.string().optional(),
+});
+
+export const DeepLinkingRequestSchema = strictObject({
+  messageType: z.literal("LtiDeepLinkingRequest"),
+  version: LtiVersionSchema,
+  deploymentId: NonEmptyStringSchema,
+  deepLinkingSettings: DeepLinkingSettingsSchema,
+  subject: NonEmptyStringSchema.optional(),
+  resourceLink: ResourceLinkSchema.optional(),
+  context: ContextSchema.optional(),
+  roles: RolesSchema.optional(),
+  lis: LisSchema.optional(),
+  launchPresentation: LaunchPresentationSchema.optional(),
+  custom: CustomParametersSchema.optional(),
+});
+
+export const ContentItemSchema = strictObject({
+  type: ContentItemTypeSchema,
+  title: z.string().optional(),
+  text: z.string().optional(),
+  url: UrlSchema.optional(),
+  custom: CustomParametersSchema.optional(),
+  icon: ImageResourceSchema.optional(),
+  thumbnail: ImageResourceSchema.optional(),
+  lineItem: LineItemSchema.optional(),
+});
+
+export const DeepLinkingResponseSchema = strictObject({
+  messageType: z.literal("LtiDeepLinkingResponse"),
+  version: LtiVersionSchema,
+  deploymentId: NonEmptyStringSchema.optional(),
+  contentItems: z.array(ContentItemSchema).min(1),
+  data: z.string().optional(),
+  message: z.string().optional(),
+  log: z.string().optional(),
+  errorMessage: z.string().optional(),
+  errorLog: z.string().optional(),
+});
+
+export namespace LtiDeepLinkingV2_0 {
+  export namespace Schemas {
+    export const ContentItemType = ContentItemTypeSchema;
+    export const DeepLinkingSettings = DeepLinkingSettingsSchema;
+    export const DeepLinkingRequest = DeepLinkingRequestSchema;
+    export const ContentItem = ContentItemSchema;
+    export const DeepLinkingResponse = DeepLinkingResponseSchema;
+  }
+}
+
+export type LtiDeepLinkingV2_0Schemas = typeof LtiDeepLinkingV2_0.Schemas;
+
+export const LtiDeepLinkingV2_0DerivedZodTemplates = {
+  description: "LTI Deep Linking v2.0 Zod schemas for normalized request settings and response content items",
+  specLinks: {
+    main: "https://www.imsglobal.org/spec/lti-dl/v2p0/",
+  },
+  scope: "Deep linking request settings and response content items",
+  claims: ["deep_linking_settings", "content_items"],
+  notes: [
+    "Accept-media-types is intentionally permissive because implementations vary between comma-delimited strings and arrays.",
+    "Content items reuse the AGS line-item schema when a deep-linked resource declares grading metadata.",
+  ],
+} as const;
+// Inferred types from exported Zod validators.
+export type ContentItemType = z.infer<typeof ContentItemTypeSchema>;
+export type DeepLinkingSettings = z.infer<typeof DeepLinkingSettingsSchema>;
+export type DeepLinkingRequest = z.infer<typeof DeepLinkingRequestSchema>;
+export type ContentItem = z.infer<typeof ContentItemSchema>;
+export type DeepLinkingResponse = z.infer<typeof DeepLinkingResponseSchema>;

package/src/lti/index.ts

@@ -0,0 +1,26 @@
+export * from "./shared";
+export * from "./v1_3";
+export * from "./deep-linking/v2_0";
+export * from "./ags/v2_0";
+export * from "./nrps/v2_0";
+export * from "./proctoring/v1_0";
+
+export * as V1_3 from "./v1_3";
+export * as DeepLinkingV2_0 from "./deep-linking/v2_0";
+export * as AgsV2_0 from "./ags/v2_0";
+export * as NrpsV2_0 from "./nrps/v2_0";
+export * as ProctoringV1_0 from "./proctoring/v1_0";
+
+import { Lti13DerivedZodTemplates } from "./v1_3";
+import { LtiDeepLinkingV2_0DerivedZodTemplates } from "./deep-linking/v2_0";
+import { LtiAgsV2_0DerivedZodTemplates } from "./ags/v2_0";
+import { LtiNrpsV2_0DerivedZodTemplates } from "./nrps/v2_0";
+import { LtiProctoringV1_0DerivedZodTemplates } from "./proctoring/v1_0";
+
+export const LtiDerivedZodTemplates = {
+  core: Lti13DerivedZodTemplates,
+  deepLinking: LtiDeepLinkingV2_0DerivedZodTemplates,
+  ags: LtiAgsV2_0DerivedZodTemplates,
+  nrps: LtiNrpsV2_0DerivedZodTemplates,
+  proctoring: LtiProctoringV1_0DerivedZodTemplates,
+} as const;

package/src/lti/nrps/v2_0/index.ts

@@ -0,0 +1,69 @@
+export * from "../../shared";
+
+import { z } from "zod";
+
+import { NonEmptyStringSchema, UrlSchema, UriReferenceSchema, strictObject } from "../../shared";
+
+export const MembershipStatusSchema = z.enum(["Active", "Deleted", "Inactive"]);
+
+export const MembershipContextSchema = strictObject({
+  id: NonEmptyStringSchema,
+  label: NonEmptyStringSchema.optional(),
+  title: NonEmptyStringSchema.optional(),
+});
+
+export const NamesRoleServiceSchema = strictObject({
+  contextMembershipsUrl: UrlSchema,
+  serviceVersions: z.array(z.literal("2.0")).min(1),
+});
+
+export const MembershipSchema = strictObject({
+  status: MembershipStatusSchema.optional(),
+  name: z.string().optional(),
+  picture: UrlSchema.optional(),
+  givenName: z.string().optional(),
+  familyName: z.string().optional(),
+  middleName: z.string().optional(),
+  email: z.string().email().optional(),
+  userId: NonEmptyStringSchema,
+  lisPersonSourcedId: NonEmptyStringSchema.optional(),
+  roles: z.array(UriReferenceSchema).min(1),
+  roleScopeMentor: z.array(UriReferenceSchema).min(1).optional(),
+});
+
+export const MembershipContainerSchema = strictObject({
+  id: UrlSchema,
+  context: MembershipContextSchema,
+  members: z.array(MembershipSchema).min(1),
+});
+
+export namespace LtiNrpsV2_0 {
+  export namespace Schemas {
+    export const NamesRoleService = NamesRoleServiceSchema;
+    export const Membership = MembershipSchema;
+    export const MembershipContainer = MembershipContainerSchema;
+    export const MembershipContext = MembershipContextSchema;
+    export const MembershipStatus = MembershipStatusSchema;
+  }
+}
+
+export type LtiNrpsV2_0Schemas = typeof LtiNrpsV2_0.Schemas;
+
+export const LtiNrpsV2_0DerivedZodTemplates = {
+  description: "LTI NRPS v2.0 Zod schemas for normalized names/roles service and membership container payloads",
+  specLinks: {
+    main: "https://www.imsglobal.org/spec/lti-nrps/v2p0/",
+  },
+  scope: "Names and Roles Provisioning Service claim and membership container",
+  claims: ["namesroleservice"],
+  notes: [
+    "Member records keep the required userId and roles fields strict while leaving consented personal data optional.",
+    "The membership container matches the normalized JSON shape used by the adapter reference app.",
+  ],
+} as const;
+// Inferred types from exported Zod validators.
+export type MembershipStatus = z.infer<typeof MembershipStatusSchema>;
+export type MembershipContext = z.infer<typeof MembershipContextSchema>;
+export type NamesRoleService = z.infer<typeof NamesRoleServiceSchema>;
+export type Membership = z.infer<typeof MembershipSchema>;
+export type MembershipContainer = z.infer<typeof MembershipContainerSchema>;