@learncard/react 2.12.6 → 2.12.7

package/dist/esm/index43.js

@@ -3,5 +3,5 @@ import './icon.green.fat-arrow.png';
 import '@learncard/helpers';
 import './vc.check.svg';
 import './index-cb3a593b.js';
-import './types.esm-35d4f5e9.js';
+import './types.esm-434cff58.js';
 //# sourceMappingURL=index43.js.map

package/dist/esm/index46.js

@@ -1,6 +1,6 @@
-export { V as ValidationStateIndicator } from './VCVerificationPill-7cc43650.js';
+export { V as ValidationStateIndicator } from './VCVerificationPill-3e840476.js';
 import 'react';
-import './types.esm-35d4f5e9.js';
+import './types.esm-434cff58.js';
 import './RedXCircle.svg';
 import './GreenCheckCircle.svg';
 import './YellowWarningCircle.svg';

package/dist/esm/index7.js

@@ -1,11 +1,11 @@
 import 'react';
 import './i18n-35209bfa.js';
-export { C as CertDisplayCardSkillsCount, a as CertificateBackFace, b as CertificateDisplayCard, c as CertificateFrontFace } from './CertificateDisplayCard-0de68029.js';
+export { C as CertDisplayCardSkillsCount, a as CertificateBackFace, b as CertificateDisplayCard, c as CertificateFrontFace } from './CertificateDisplayCard-b5399522.js';
 import './index-cb3a593b.js';
-import './types.esm-35d4f5e9.js';
+import './types.esm-434cff58.js';
 import '@learncard/helpers';
 export { V as VERIFIER_STATES } from './VerifierStateBadgeAndText-f2bbd9fd.js';
-import './credential.helpers-d71e692a.js';
+import './credential.helpers-f4495f8f.js';
 import './index-28917993.js';
 import './PuzzlePiece-a3d9cc62.js';
 import './User-f5ea0f01.js';

package/dist/esm/{types.esm-35d4f5e9.js → types.esm-434cff58.js}

@@ -8007,6 +8007,201 @@ var StringQuery = union([
     $or: BaseStringQuery.array()
   })
 ]);
+var LearnCardRefreshAuthorizationValidator = object({ type: literal("LearnCardDIDAuth") }).catchall(any());
+var ManagedCredentialRefreshServiceValidator = object({
+  id: string().min(1),
+  type: literal("LearnCardCredentialRefresh2026"),
+  authorization: LearnCardRefreshAuthorizationValidator.optional()
+}).catchall(any());
+var StandardCredentialRefreshServiceValidator = object({
+  id: string().min(1),
+  type: literal("1EdTechCredentialRefresh")
+}).catchall(any());
+union([
+  ManagedCredentialRefreshServiceValidator,
+  StandardCredentialRefreshServiceValidator
+]);
+object({
+  holder: object({
+    profileId: string().optional(),
+    did: string().min(1)
+  }),
+  credentialId: string().min(1)
+});
+object({
+  refreshId: string().min(1),
+  refreshService: ManagedCredentialRefreshServiceValidator.extend({
+    authorization: LearnCardRefreshAuthorizationValidator
+  })
+});
+var ManagedCredentialRefreshReceiptValidator = object({
+  refreshId: string().min(1),
+  refreshService: ManagedCredentialRefreshServiceValidator,
+  credentialId: string().min(1),
+  issuerDid: string().min(1),
+  holderDid: string().min(1),
+  credentialStatus: CredentialStatusValidator.or(
+    CredentialStatusValidator.array()
+  ).optional()
+}).strip();
+var InboxCredentialRefreshReceiptValidator = ManagedCredentialRefreshReceiptValidator.omit(
+  { holderDid: true }
+).extend({ holderDid: string().min(1).optional() });
+var CredentialRefreshSigningModeValidator = _enum(["issuer-signed", "signing-authority"]);
+var PublishCredentialRefreshBaseFields = {
+  refreshId: string().min(1),
+  notifyHolder: boolean().optional(),
+  updateSummary: string().optional(),
+  idempotencyKey: string().optional()
+};
+object(__spreadProps(__spreadValues({}, PublishCredentialRefreshBaseFields), {
+  mode: literal("issuer-signed"),
+  signedCredential: VCValidator
+}));
+object(__spreadProps(__spreadValues({}, PublishCredentialRefreshBaseFields), {
+  mode: literal("signing-authority"),
+  credential: UnsignedVCValidator,
+  signingAuthority: object({
+    type: string().min(1)
+  }).catchall(any())
+}));
+object(__spreadProps(__spreadValues({}, PublishCredentialRefreshBaseFields), {
+  mode: CredentialRefreshSigningModeValidator,
+  signedCredential: VCValidator.optional(),
+  credential: UnsignedVCValidator.optional(),
+  signingAuthority: object({
+    type: string().min(1)
+  }).catchall(any()).optional()
+})).superRefine((input, ctx) => {
+  if (input.mode === "issuer-signed" && !input.signedCredential) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["signedCredential"],
+      message: "signedCredential is required for issuer-signed publication"
+    });
+  }
+  if (input.mode === "issuer-signed" && (input.credential !== void 0 || input.signingAuthority !== void 0)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["mode"],
+      message: "issuer-signed publication cannot include signing-authority fields"
+    });
+  }
+  if (input.mode === "signing-authority") {
+    if (input.signedCredential !== void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["signedCredential"],
+        message: "signing-authority publication cannot include signedCredential"
+      });
+    }
+    if (!input.credential) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["credential"],
+        message: "credential is required for signing-authority publication"
+      });
+    }
+    if (!input.signingAuthority) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["signingAuthority"],
+        message: "signingAuthority is required for signing-authority publication"
+      });
+    }
+  }
+});
+var PublishCredentialRefreshNotificationValidator = _enum([
+  "queued",
+  "suppressed",
+  "not-applicable",
+  /** Publication succeeded, but the post-commit notification enqueue must be retried. */
+  "delivery-failed"
+]);
+object({
+  refreshId: string().min(1),
+  version: number().int().positive(),
+  publishedAt: string().min(1),
+  notification: PublishCredentialRefreshNotificationValidator
+});
+var CredentialRefreshVersionMetadataValidator = object({
+  version: number().int().positive(),
+  publishedAt: string().min(1),
+  effectiveAt: string().optional(),
+  etag: string().optional(),
+  signingMode: CredentialRefreshSigningModeValidator.optional(),
+  updateSummary: string().optional()
+});
+object({
+  refreshId: string().min(1),
+  cursor: string().optional(),
+  limit: number().int().positive().optional()
+});
+object({
+  records: CredentialRefreshVersionMetadataValidator.array(),
+  hasMore: boolean(),
+  cursor: string().optional()
+});
+object({
+  challenge: string().min(1),
+  expiresAt: string().min(1),
+  domain: string().optional(),
+  scheme: literal("LearnCardDIDAuth").optional()
+});
+var PublicCredentialRefreshEnvelopeValidator = object({
+  format: literal("vc"),
+  credential: VCValidator,
+  etag: string().optional()
+});
+var JweCredentialRefreshEnvelopeValidator = object({
+  format: literal("jwe"),
+  jwe: JWEValidator,
+  etag: string().optional(),
+  /** Present on LearnCard-managed endpoints; optional for interoperable JWE services. */
+  version: number().int().positive().optional()
+});
+discriminatedUnion("format", [
+  PublicCredentialRefreshEnvelopeValidator,
+  JweCredentialRefreshEnvelopeValidator
+]);
+var CredentialRefreshFailureCodeValidator = _enum([
+  "UNAVAILABLE",
+  "TIMEOUT",
+  "UNSUPPORTED_SERVICE",
+  "UNAUTHORIZED",
+  "MALFORMED_RESPONSE",
+  "INVALID_PROOF",
+  "ISSUER_MISMATCH",
+  "ID_MISMATCH",
+  "ROLLBACK",
+  "REVOKED",
+  "UNSAFE_ENDPOINT"
+]);
+var CredentialRefreshUpdatedResultValidator = object({
+  status: literal("updated"),
+  credential: VCValidator,
+  etag: string().optional(),
+  managedVersion: number().int().positive().optional()
+});
+var CredentialRefreshUnchangedResultValidator = object({
+  status: literal("unchanged"),
+  checkedAt: string().min(1),
+  etag: string().optional()
+});
+var CredentialRefreshUnsupportedResultValidator = object({
+  status: literal("unsupported")
+});
+var CredentialRefreshFailedResultValidator = object({
+  status: literal("failed"),
+  code: CredentialRefreshFailureCodeValidator,
+  retryable: boolean()
+});
+discriminatedUnion("status", [
+  CredentialRefreshUpdatedResultValidator,
+  CredentialRefreshUnchangedResultValidator,
+  CredentialRefreshUnsupportedResultValidator,
+  CredentialRefreshFailedResultValidator
+]);
 var LCNProfileDisplayValidator = object({
   backgroundColor: string().optional(),
   backgroundImage: string().optional(),
@@ -8342,7 +8537,13 @@ var SendBoostInputValidator = object({
     "Options for email/phone recipients (Universal Inbox)"
   ),
   templateData: record(string(), unknown()).optional(),
-  integrationId: string().optional().describe("Integration ID for activity tracking")
+  integrationId: string().optional().describe("Integration ID for activity tracking"),
+  refresh: boolean().optional().describe(
+    "Request managed credential refresh for this send. Profile/DID recipients use immediate issuance; email/phone recipients use deferred Universal Inbox signing and bind the holder at claim."
+  ),
+  idempotencyKey: string().min(1).max(200).optional().describe(
+    "Caller-chosen key that makes a managed refresh send (refresh: true) safe to retry as a whole: retries with the same key reuse the same boost, refresh allocation and result. Reusing a key for a different request is rejected. With signedCredential, requires prior tRPC prepareRefreshableSend; direct REST callers omit the key and retry the exact signed credential and templateUri."
+  )
 }).refine((data) => data.templateUri || data.template || data.signedCredential, {
   message: "Either templateUri, template, or signedCredential must be provided.",
   path: ["templateUri"]
@@ -8358,8 +8559,12 @@ var SendBoostInputValidator = object({
     message: "guardianEmail must differ from recipient (self-approval not allowed)",
     path: ["options", "guardianEmail"]
   }
-);
+).refine((data) => !data.idempotencyKey || data.refresh === true, {
+  message: "idempotencyKey is only supported with refresh: true.",
+  path: ["idempotencyKey"]
+});
 var SendInboxResponseValidator = object({
+  refresh: InboxCredentialRefreshReceiptValidator.optional(),
   issuanceId: string(),
   status: _enum(["PENDING", "ISSUED", "EXPIRED", "DELIVERED", "CLAIMED"]),
   claimUrl: string().url().optional().describe("Present when suppressDelivery=true"),
@@ -8374,8 +8579,34 @@ var SendBoostResponseValidator = object({
   activityId: string().describe("Links to the activity lifecycle for this issuance"),
   inbox: SendInboxResponseValidator.optional().describe(
     "Present when sent via email/phone (Universal Inbox)"
+  ),
+  refresh: ManagedCredentialRefreshReceiptValidator.optional().describe(
+    "Present when managed refresh was requested: issuance metadata the issuer keeps to publish future updates"
   )
 });
+object({
+  recipient: string(),
+  templateUri: string().optional(),
+  template: SendBoostTemplateValidator.optional(),
+  contractUri: string().optional(),
+  templateData: record(string(), unknown()).optional(),
+  integrationId: string().optional(),
+  /** Credential ID to allocate for; generated server-side when omitted. */
+  credentialId: string().min(1).optional(),
+  idempotencyKey: string().min(1).max(200).optional()
+}).refine((data) => Boolean(data.templateUri) !== Boolean(data.template), {
+  message: "Provide exactly one of templateUri or template."
+});
+object({
+  boostUri: string(),
+  credentialId: string(),
+  refreshId: string(),
+  refreshService: ManagedCredentialRefreshServiceValidator,
+  /** The DID to use as credentialSubject.id (recipient DID, or the profile's did:web). */
+  holderDid: string(),
+  /** Present when this idempotencyKey already completed: return it without signing. */
+  completed: SendBoostResponseValidator.optional()
+});
 discriminatedUnion("type", [SendBoostInputValidator]);
 discriminatedUnion("type", [SendBoostResponseValidator]);
 var ConsentFlowTermsStatusValidator = _enum(["live", "stale", "withdrawn"]);
@@ -8706,6 +8937,7 @@ object({
     }, "error")
   }),
   scope: string(),
+  actAs: string().optional(),
   createdAt: datetime({ error: "createdAt must be a valid ISO 8601 datetime string" }),
   expiresAt: datetime({ error: "expiresAt must be a valid ISO 8601 datetime string" }).nullish().optional()
 });
@@ -8777,6 +9009,8 @@ object({
   sessionJwt: string()
 });
 var InboxCredentialValidator = object({
+  refresh: InboxCredentialRefreshReceiptValidator.optional(),
+  refreshId: string().optional(),
   id: string(),
   credential: string().optional(),
   isSigned: boolean(),
@@ -8820,7 +9054,7 @@ var IssueInboxSigningAuthorityValidator = object({
   endpoint: string().url(),
   name: string()
 });
-object({
+var IssueInboxCredentialValidator = object({
   // === CORE DATA (Required) ===
   // WHAT is being sent and WHO is it for?
   recipient: ContactMethodQueryValidator.describe("The recipient of the credential"),
@@ -8831,12 +9065,19 @@ object({
   templateUri: string().optional().describe(
     "URI of a boost template to use for issuance. The boost credential will be resolved and used. Mutually exclusive with credential field."
   ),
+  refresh: boolean().optional().describe(
+    "Allocate managed refresh before signing. Requires unsigned content and a registered signing authority; binds the holder on claim."
+  ),
+  idempotencyKey: string().min(1).max(200).optional(),
   // === OPTIONAL FEATURES ===
   // Add major, distinct features at the top level.
   //consentRequest: ConsentRequestValidator.optional(),
   // === PROCESS CONFIGURATION (Optional) ===
   // HOW should this issuance be handled?
   configuration: object({
+    guardianEmail: string().email().optional().describe(
+      "Require approval from this guardian before the recipient can claim. Must differ from the recipient email."
+    ),
     signingAuthority: IssueInboxSigningAuthorityValidator.optional().describe(
       "The signing authority to use for the credential. If not provided, the users default signing authority will be used if the credential is not signed."
     ),
@@ -8890,17 +9131,133 @@ object({
   }).optional().describe(
     "Configuration for the credential issuance. If not provided, the default configuration will be used."
   )
+}).refine((data) => !data.idempotencyKey || data.refresh === true, {
+  message: "idempotencyKey requires refresh: true."
 }).refine((data) => data.credential || data.templateUri, {
   message: "Either credential or templateUri must be provided.",
   path: ["credential"]
-});
-object({
+}).refine(
+  (data) => {
+    var _a2;
+    return !((_a2 = data.configuration) == null ? void 0 : _a2.guardianEmail) || data.recipient.type !== "email" || data.configuration.guardianEmail.toLowerCase() !== data.recipient.value.toLowerCase();
+  },
+  {
+    message: "guardianEmail must differ from recipient (self-approval not allowed)",
+    path: ["configuration", "guardianEmail"]
+  }
+);
+var IssueInboxCredentialResponseValidator = object({
+  refresh: InboxCredentialRefreshReceiptValidator.optional(),
   issuanceId: string(),
   status: LCNInboxStatusEnumValidator,
   recipient: ContactMethodQueryValidator,
   claimUrl: string().url().optional(),
   recipientDid: string().optional()
 });
+var InboxBatchConfigurationValidator = IssueInboxCredentialValidator.shape.configuration.unwrap().extend({
+  refresh: IssueInboxCredentialValidator.shape.refresh.describe(
+    "Enable managed refresh by default. An item configuration.refresh overrides this value, including false."
+  ),
+  delivery: IssueInboxCredentialValidator.shape.configuration.unwrap().shape.delivery.unwrap().extend({ suppress: boolean().optional() }).optional()
+});
+var InboxBatchItemConfigurationValidator = InboxBatchConfigurationValidator.extend({
+  guardianEmail: InboxBatchConfigurationValidator.shape.guardianEmail.nullable().describe(
+    "Require guardian approval, or set null to clear a batch-level guardianEmail for this item."
+  )
+});
+var IssueInboxCredentialBatchItemValidator = object(__spreadProps(__spreadValues({}, IssueInboxCredentialValidator.shape), {
+  configuration: InboxBatchItemConfigurationValidator.optional(),
+  idempotencyKey: string().max(256).optional()
+})).refine((data) => data.credential || data.templateUri, {
+  message: "Either credential or templateUri must be provided.",
+  path: ["credential"]
+}).describe(
+  "One issuance: provide credential or templateUri. Invalid input is rejected at submission with its item index."
+);
+object({
+  requestId: string().min(1).max(256).optional(),
+  items: array(IssueInboxCredentialBatchItemValidator).min(1).max(100),
+  configuration: InboxBatchConfigurationValidator.optional()
+}).superRefine((batch, ctx) => {
+  batch.items.forEach((item, index) => {
+    var _a2, _b;
+    const itemGuardian = (_a2 = item.configuration) == null ? void 0 : _a2.guardianEmail;
+    const guardian = itemGuardian === null ? void 0 : itemGuardian != null ? itemGuardian : (_b = batch.configuration) == null ? void 0 : _b.guardianEmail;
+    if (guardian && item.recipient.type === "email" && guardian.toLowerCase() === item.recipient.value.toLowerCase()) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["items", index, "configuration", "guardianEmail"],
+        message: "guardianEmail must differ from recipient (self-approval not allowed)"
+      });
+    }
+  });
+});
+var InboxBatchErrorReasonValidator = _enum([
+  "DUPLICATE_KEY",
+  "IDEMPOTENCY_MISMATCH",
+  "IN_PROGRESS",
+  "UNCONFIRMED"
+]);
+var IssueInboxCredentialBatchItemResultValidator = discriminatedUnion("success", [
+  IssueInboxCredentialResponseValidator.extend({
+    success: literal(true),
+    index: number().int().nonnegative(),
+    deduplicated: boolean().optional(),
+    guardianStatus: GuardianStatusValidator.optional(),
+    idempotencyKey: string().optional()
+  }),
+  object({
+    success: literal(false),
+    index: number().int().nonnegative(),
+    idempotencyKey: string().optional(),
+    recipient: ContactMethodQueryValidator.optional(),
+    error: object({
+      code: string(),
+      message: string(),
+      reason: InboxBatchErrorReasonValidator.optional()
+    }),
+    issuanceId: string().optional().describe(
+      "Present when issuance completed but replay storage could not be confirmed. Reconcile this issuance; do not issue again with a new key."
+    ),
+    claimUrl: string().url().optional().describe(
+      "Claim URL of the completed issuance, if available, when replay storage could not be confirmed."
+    )
+  })
+]);
+var IssueInboxCredentialBatchResponseValidator = object({
+  results: array(IssueInboxCredentialBatchItemResultValidator),
+  summary: object({
+    total: number(),
+    succeeded: number(),
+    failed: number(),
+    deduplicated: number()
+  })
+});
+object({
+  batchId: string(),
+  status: _enum(["QUEUED", "PROCESSING", "COMPLETED", "NEEDS_RECONCILIATION"]),
+  createdAt: string()
+});
+object({
+  batchId: string(),
+  createdAt: string(),
+  done: boolean().describe(
+    "True when no queued or processing items remain, including unconfirmed outcomes."
+  ),
+  status: _enum(["QUEUED", "PROCESSING", "COMPLETED", "NEEDS_RECONCILIATION"]),
+  items: array(
+    object({
+      index: number().int().nonnegative(),
+      state: _enum(["QUEUED", "PROCESSING", "COMPLETED", "NEEDS_RECONCILIATION"]),
+      result: IssueInboxCredentialBatchItemResultValidator.optional()
+    })
+  ),
+  summary: IssueInboxCredentialBatchResponseValidator.shape.summary.extend({
+    completed: number(),
+    pending: number(),
+    unconfirmed: number()
+  })
+});
 var CredentialNameRefValidator = object({ name: string() }).passthrough();
 object({
   credential: VCValidator.or(VPValidator).or(UnsignedVCValidator).or(CredentialNameRefValidator).describe("The credential to issue, or a { name } reference to resolve a boost template."),
@@ -9386,6 +9743,7 @@ var CredentialActivityValidator = object({
   eventType: CredentialActivityEventTypeValidator,
   timestamp: string(),
   actorProfileId: string().optional(),
+  onBehalfOf: string().optional(),
   recipientType: CredentialActivityRecipientTypeValidator,
   recipientIdentifier: string(),
   boostUri: string().optional(),
@@ -9534,188 +9892,6 @@ object({
   version: number().default(1),
   messages: array(inAppMessageValidator).default([])
 }).passthrough();
-var LearnCardRefreshAuthorizationValidator = object({ type: literal("LearnCardDIDAuth") }).catchall(any());
-var ManagedCredentialRefreshServiceValidator = object({
-  id: string().min(1),
-  type: literal("LearnCardCredentialRefresh2026"),
-  authorization: LearnCardRefreshAuthorizationValidator.optional()
-}).catchall(any());
-var StandardCredentialRefreshServiceValidator = object({
-  id: string().min(1),
-  type: literal("1EdTechCredentialRefresh")
-}).catchall(any());
-union([
-  ManagedCredentialRefreshServiceValidator,
-  StandardCredentialRefreshServiceValidator
-]);
-object({
-  holder: object({
-    profileId: string().optional(),
-    did: string().min(1)
-  }),
-  credentialId: string().min(1)
-});
-object({
-  refreshId: string().min(1),
-  refreshService: ManagedCredentialRefreshServiceValidator.extend({
-    authorization: LearnCardRefreshAuthorizationValidator
-  })
-});
-var CredentialRefreshSigningModeValidator = _enum(["issuer-signed", "signing-authority"]);
-var PublishCredentialRefreshBaseFields = {
-  refreshId: string().min(1),
-  notifyHolder: boolean().optional(),
-  updateSummary: string().optional(),
-  idempotencyKey: string().optional()
-};
-object(__spreadProps(__spreadValues({}, PublishCredentialRefreshBaseFields), {
-  mode: literal("issuer-signed"),
-  signedCredential: VCValidator
-}));
-object(__spreadProps(__spreadValues({}, PublishCredentialRefreshBaseFields), {
-  mode: literal("signing-authority"),
-  credential: UnsignedVCValidator,
-  signingAuthority: object({
-    type: string().min(1)
-  }).catchall(any())
-}));
-object(__spreadProps(__spreadValues({}, PublishCredentialRefreshBaseFields), {
-  mode: CredentialRefreshSigningModeValidator,
-  signedCredential: VCValidator.optional(),
-  credential: UnsignedVCValidator.optional(),
-  signingAuthority: object({
-    type: string().min(1)
-  }).catchall(any()).optional()
-})).superRefine((input, ctx) => {
-  if (input.mode === "issuer-signed" && !input.signedCredential) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["signedCredential"],
-      message: "signedCredential is required for issuer-signed publication"
-    });
-  }
-  if (input.mode === "issuer-signed" && (input.credential !== void 0 || input.signingAuthority !== void 0)) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["mode"],
-      message: "issuer-signed publication cannot include signing-authority fields"
-    });
-  }
-  if (input.mode === "signing-authority") {
-    if (input.signedCredential !== void 0) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["signedCredential"],
-        message: "signing-authority publication cannot include signedCredential"
-      });
-    }
-    if (!input.credential) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["credential"],
-        message: "credential is required for signing-authority publication"
-      });
-    }
-    if (!input.signingAuthority) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["signingAuthority"],
-        message: "signingAuthority is required for signing-authority publication"
-      });
-    }
-  }
-});
-var PublishCredentialRefreshNotificationValidator = _enum([
-  "queued",
-  "suppressed",
-  "not-applicable",
-  /** Publication succeeded, but the post-commit notification enqueue must be retried. */
-  "delivery-failed"
-]);
-object({
-  refreshId: string().min(1),
-  version: number().int().positive(),
-  publishedAt: string().min(1),
-  notification: PublishCredentialRefreshNotificationValidator
-});
-var CredentialRefreshVersionMetadataValidator = object({
-  version: number().int().positive(),
-  publishedAt: string().min(1),
-  effectiveAt: string().optional(),
-  etag: string().optional(),
-  signingMode: CredentialRefreshSigningModeValidator.optional(),
-  updateSummary: string().optional()
-});
-object({
-  refreshId: string().min(1),
-  cursor: string().optional(),
-  limit: number().int().positive().optional()
-});
-object({
-  records: CredentialRefreshVersionMetadataValidator.array(),
-  hasMore: boolean(),
-  cursor: string().optional()
-});
-object({
-  challenge: string().min(1),
-  expiresAt: string().min(1),
-  domain: string().optional(),
-  scheme: literal("LearnCardDIDAuth").optional()
-});
-var PublicCredentialRefreshEnvelopeValidator = object({
-  format: literal("vc"),
-  credential: VCValidator,
-  etag: string().optional()
-});
-var JweCredentialRefreshEnvelopeValidator = object({
-  format: literal("jwe"),
-  jwe: JWEValidator,
-  etag: string().optional(),
-  /** Present on LearnCard-managed endpoints; optional for interoperable JWE services. */
-  version: number().int().positive().optional()
-});
-discriminatedUnion("format", [
-  PublicCredentialRefreshEnvelopeValidator,
-  JweCredentialRefreshEnvelopeValidator
-]);
-var CredentialRefreshFailureCodeValidator = _enum([
-  "UNAVAILABLE",
-  "TIMEOUT",
-  "UNSUPPORTED_SERVICE",
-  "UNAUTHORIZED",
-  "MALFORMED_RESPONSE",
-  "INVALID_PROOF",
-  "ISSUER_MISMATCH",
-  "ID_MISMATCH",
-  "ROLLBACK",
-  "REVOKED",
-  "UNSAFE_ENDPOINT"
-]);
-var CredentialRefreshUpdatedResultValidator = object({
-  status: literal("updated"),
-  credential: VCValidator,
-  etag: string().optional(),
-  managedVersion: number().int().positive().optional()
-});
-var CredentialRefreshUnchangedResultValidator = object({
-  status: literal("unchanged"),
-  checkedAt: string().min(1),
-  etag: string().optional()
-});
-var CredentialRefreshUnsupportedResultValidator = object({
-  status: literal("unsupported")
-});
-var CredentialRefreshFailedResultValidator = object({
-  status: literal("failed"),
-  code: CredentialRefreshFailureCodeValidator,
-  retryable: boolean()
-});
-discriminatedUnion("status", [
-  CredentialRefreshUpdatedResultValidator,
-  CredentialRefreshUnchangedResultValidator,
-  CredentialRefreshUnsupportedResultValidator,
-  CredentialRefreshFailedResultValidator
-]);
 
 export { VerificationStatusEnum as V };
-//# sourceMappingURL=types.esm-35d4f5e9.js.map
+//# sourceMappingURL=types.esm-434cff58.js.map