@learncard/react 2.12.4 → 2.12.6

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

@@ -7400,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(),
@@ -7538,14 +7557,22 @@ var UnsignedVCValidator = object({
 }).catchall(any());
 var ProofValidator = object({
   type: string(),
-  created: string(),
+  created: string().optional(),
   challenge: string().optional(),
   domain: string().optional(),
   nonce: string().optional(),
   proofPurpose: string(),
   verificationMethod: string(),
   jws: string().optional()
-}).catchall(any());
+}).catchall(any()).superRefine((proof, ctx) => {
+  if (proof.created === void 0 && (proof.type !== "DataIntegrityProof" || proof.cryptosuite !== "ecdsa-rdfc-2019")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["created"],
+      message: "created is required for this proof suite"
+    });
+  }
+});
 var VCValidator = UnsignedVCValidator.extend({
   proof: ProofValidator.or(ProofValidator.array())
 });
@@ -8299,7 +8326,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"),
@@ -8421,15 +8451,6 @@ var ConsentFlowContractDataValidator = object({
 PaginationResponseValidator.extend({
   records: ConsentFlowContractDataValidator.array()
 });
-var ConsentFlowContractDataForDidValidator = object({
-  credentials: object({ category: string(), uri: string() }).array(),
-  personal: record(string(), string()).default({}),
-  date: string(),
-  contractUri: string()
-});
-PaginationResponseValidator.extend({
-  records: ConsentFlowContractDataForDidValidator.array()
-});
 var ConsentFlowTermValidator = object({
   sharing: boolean().optional(),
   shared: string().array().optional(),
@@ -8463,6 +8484,34 @@ PaginationResponseValidator.extend({
     status: ConsentFlowTermsStatusValidator
   }).array()
 });
+var ConsentFlowGuardianApprovalValidator = object({
+  guardianProfileId: string(),
+  guardianDid: string(),
+  approvedAt: string().datetime(),
+  contractUpdatedAt: string()
+});
+var ConsentFlowContractDataForDidValidator = object({
+  credentials: object({ category: string(), uri: string() }).array(),
+  personal: record(string(), string()).default({}),
+  date: string(),
+  createdAt: string().optional(),
+  contractUpdatedAt: string(),
+  contractExpiresAt: string().optional(),
+  reasonForAccessing: string().optional(),
+  guardian: object({
+    required: boolean(),
+    approved: boolean(),
+    approval: ConsentFlowGuardianApprovalValidator.optional()
+  }),
+  contractUri: string(),
+  termsUri: string(),
+  status: ConsentFlowTermsStatusValidator,
+  expiresAt: string().optional(),
+  terms: ConsentFlowTermsValidator
+});
+PaginationResponseValidator.extend({
+  records: ConsentFlowContractDataForDidValidator.array()
+});
 object({
   read: object({
     anonymize: boolean().optional(),
@@ -8523,6 +8572,7 @@ var ConsentFlowTransactionValidator = object({
   expiresAt: string().optional(),
   oneTime: boolean().optional(),
   terms: ConsentFlowTermsValidator.optional(),
+  guardianApproval: ConsentFlowGuardianApprovalValidator.optional(),
   id: string(),
   action: ConsentFlowTransactionActionValidator,
   date: string(),
@@ -8595,7 +8645,8 @@ var LCNNotificationTypeEnumValidator = _enum([
   "APP_NOTIFICATION",
   "CREDENTIAL_REVOKED",
   "CREDENTIAL_SUSPENDED",
-  "CREDENTIAL_UNSUSPENDED"
+  "CREDENTIAL_UNSUSPENDED",
+  "CREDENTIAL_REFRESHED"
 ]);
 var LCNNotificationMessageValidator = object({
   title: string().optional(),
@@ -8727,12 +8778,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(),
@@ -8786,7 +8841,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."
     ),
@@ -8849,6 +8906,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()
@@ -9474,6 +9534,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 };
-//# sourceMappingURL=types.esm-acda6d63.js.map
+//# sourceMappingURL=types.esm-35d4f5e9.js.map