@learncard/react 2.12.3 → 2.12.5

package/dist/esm/{types.esm-2762569e.js → types.esm-277415d8.js}

@@ -4223,15 +4223,6 @@ function _number(Class, params) {
     });
 }
 // @__NO_SIDE_EFFECTS__
-function _coercedNumber(Class, params) {
-    return new Class({
-        type: "number",
-        coerce: true,
-        checks: [],
-        ...normalizeParams(params),
-    });
-}
-// @__NO_SIDE_EFFECTS__
 function _int(Class, params) {
     return new Class({
         type: "number",
@@ -7409,9 +7400,28 @@ var _schemas = /*#__PURE__*/Object.freeze({
 
 config(en());
 
-var _a;
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var _a;
+var __defProp2 = Object.defineProperty;
+var __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
 var ContextValidator = array(string().or(record(string(), any())));
 object({
   type: string().optional(),
@@ -8308,7 +8318,10 @@ var SendOptionsValidator = object({
   webhookUrl: string().url().optional().describe("Webhook URL to receive claim notifications"),
   suppressDelivery: boolean().optional().describe("If true, returns claimUrl without sending email/SMS"),
   branding: SendBrandingOptionsValidator.optional().describe("Branding for email/SMS delivery"),
-  guardianEmail: string().email().optional().describe("Guardian email that must approve before student can claim")
+  guardianEmail: string().email().optional().describe("Guardian email that must approve before student can claim"),
+  expiresInDays: number().int().min(1).max(720).optional().describe(
+    "How many days the credential stays claimable in the Universal Inbox (default 30). Does not change the credential validity period."
+  )
 });
 var SendBoostInputValidator = object({
   type: literal("boost"),
@@ -8604,7 +8617,8 @@ var LCNNotificationTypeEnumValidator = _enum([
   "APP_NOTIFICATION",
   "CREDENTIAL_REVOKED",
   "CREDENTIAL_SUSPENDED",
-  "CREDENTIAL_UNSUSPENDED"
+  "CREDENTIAL_UNSUSPENDED",
+  "CREDENTIAL_REFRESHED"
 ]);
 var LCNNotificationMessageValidator = object({
   title: string().optional(),
@@ -8736,12 +8750,16 @@ object({
 });
 var InboxCredentialValidator = object({
   id: string(),
-  credential: string(),
+  credential: string().optional(),
   isSigned: boolean(),
   currentStatus: LCNInboxStatusEnumValidator,
   isAccepted: boolean().optional(),
   expiresAt: string(),
   createdAt: string(),
+  finalizedAt: string().optional(),
+  expiredAt: string().optional(),
+  credentialName: string().optional(),
+  achievementType: string().optional(),
   issuerDid: string(),
   webhookUrl: string().optional(),
   boostUri: string().optional(),
@@ -8795,7 +8813,9 @@ object({
       "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."
     ),
     webhookUrl: string().url().optional().describe("The webhook URL to receive credential issuance events."),
-    expiresInDays: number().min(1).max(365).optional().describe("The number of days the credential will be valid for."),
+    expiresInDays: number().int().min(1).max(720).optional().describe(
+      "How many days the encrypted inbox payload remains claimable. This does not change the credential validity period."
+    ),
     templateData: record(string(), unknown()).optional().describe(
       "Template data to render into the boost credential template using Mustache syntax. Only used when boostUri is provided."
     ),
@@ -8858,6 +8878,9 @@ object({
   credential: VCValidator.or(VPValidator).or(UnsignedVCValidator).or(CredentialNameRefValidator).describe("The credential to issue, or a { name } reference to resolve a boost template."),
   configuration: object({
     publishableKey: string(),
+    expiresInDays: number().int().min(1).max(720).optional().describe(
+      "Inbox claim window in days. Defaults to 720; use a shorter window for sensitive records."
+    ),
     signingAuthorityName: string().optional(),
     listingId: string().optional(),
     listingSlug: string().optional()
@@ -9483,6 +9506,188 @@ 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, ZodNumber as Z, _coercedNumber as _, url as a, _enum as b, literal as l, number as n, object as o, preprocess as p, string as s, union as u };
-//# sourceMappingURL=types.esm-2762569e.js.map
+export { VerificationStatusEnum as V };
+//# sourceMappingURL=types.esm-277415d8.js.map