@learncard/types 5.19.0 → 5.21.0

package/dist/types.esm.js

@@ -138,14 +138,22 @@ var UnsignedVCValidator = z.object({
 }).catchall(z.any());
 var ProofValidator = z.object({
   type: z.string(),
-  created: z.string(),
+  created: z.string().optional(),
   challenge: z.string().optional(),
   domain: z.string().optional(),
   nonce: z.string().optional(),
   proofPurpose: z.string(),
   verificationMethod: z.string(),
   jws: z.string().optional()
-}).catchall(z.any());
+}).catchall(z.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())
 });
@@ -581,7 +589,7 @@ var PaginatedEncryptedCredentialRecordsValidator = PaginationResponseValidator.e
 });
 
 // src/lcn.ts
-import { z as z11 } from "zod/v4";
+import { z as z12 } from "zod/v4";
 
 // src/queries.ts
 import { z as z10 } from "zod/v4";
@@ -622,48 +630,249 @@ var StringQuery = z10.union([
   })
 ]);
 
+// src/credential-refresh.ts
+import { z as z11 } from "zod/v4";
+var LearnCardRefreshAuthorizationValidator = z11.object({ type: z11.literal("LearnCardDIDAuth") }).catchall(z11.any());
+var ManagedCredentialRefreshServiceValidator = z11.object({
+  id: z11.string().min(1),
+  type: z11.literal("LearnCardCredentialRefresh2026"),
+  authorization: LearnCardRefreshAuthorizationValidator.optional()
+}).catchall(z11.any());
+var StandardCredentialRefreshServiceValidator = z11.object({
+  id: z11.string().min(1),
+  type: z11.literal("1EdTechCredentialRefresh")
+}).catchall(z11.any());
+var SupportedCredentialRefreshServiceValidator = z11.union([
+  ManagedCredentialRefreshServiceValidator,
+  StandardCredentialRefreshServiceValidator
+]);
+var AllocateCredentialRefreshInputValidator = z11.object({
+  holder: z11.object({
+    profileId: z11.string().optional(),
+    did: z11.string().min(1)
+  }),
+  credentialId: z11.string().min(1)
+});
+var AllocateCredentialRefreshResultValidator = z11.object({
+  refreshId: z11.string().min(1),
+  refreshService: ManagedCredentialRefreshServiceValidator.extend({
+    authorization: LearnCardRefreshAuthorizationValidator
+  })
+});
+var ManagedCredentialRefreshReceiptValidator = z11.object({
+  refreshId: z11.string().min(1),
+  refreshService: ManagedCredentialRefreshServiceValidator,
+  credentialId: z11.string().min(1),
+  issuerDid: z11.string().min(1),
+  holderDid: z11.string().min(1),
+  credentialStatus: CredentialStatusValidator.or(
+    CredentialStatusValidator.array()
+  ).optional()
+}).strip();
+var InboxCredentialRefreshReceiptValidator = ManagedCredentialRefreshReceiptValidator.omit(
+  { holderDid: true }
+).extend({ holderDid: z11.string().min(1).optional() });
+var CredentialRefreshSigningModeValidator = z11.enum(["issuer-signed", "signing-authority"]);
+var PublishCredentialRefreshBaseFields = {
+  refreshId: z11.string().min(1),
+  notifyHolder: z11.boolean().optional(),
+  updateSummary: z11.string().optional(),
+  idempotencyKey: z11.string().optional()
+};
+var PublishIssuerSignedRefreshValidator = z11.object({
+  ...PublishCredentialRefreshBaseFields,
+  mode: z11.literal("issuer-signed"),
+  signedCredential: VCValidator
+});
+var PublishSigningAuthorityRefreshValidator = z11.object({
+  ...PublishCredentialRefreshBaseFields,
+  mode: z11.literal("signing-authority"),
+  credential: UnsignedVCValidator,
+  signingAuthority: z11.object({
+    type: z11.string().min(1)
+  }).catchall(z11.any())
+});
+var PublishCredentialRefreshInputValidator = z11.object({
+  ...PublishCredentialRefreshBaseFields,
+  mode: CredentialRefreshSigningModeValidator,
+  signedCredential: VCValidator.optional(),
+  credential: UnsignedVCValidator.optional(),
+  signingAuthority: z11.object({
+    type: z11.string().min(1)
+  }).catchall(z11.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 = z11.enum([
+  "queued",
+  "suppressed",
+  "not-applicable",
+  /** Publication succeeded, but the post-commit notification enqueue must be retried. */
+  "delivery-failed"
+]);
+var PublishCredentialRefreshResultValidator = z11.object({
+  refreshId: z11.string().min(1),
+  version: z11.number().int().positive(),
+  publishedAt: z11.string().min(1),
+  notification: PublishCredentialRefreshNotificationValidator
+});
+var CredentialRefreshVersionMetadataValidator = z11.object({
+  version: z11.number().int().positive(),
+  publishedAt: z11.string().min(1),
+  effectiveAt: z11.string().optional(),
+  etag: z11.string().optional(),
+  signingMode: CredentialRefreshSigningModeValidator.optional(),
+  updateSummary: z11.string().optional()
+});
+var GetCredentialRefreshHistoryInputValidator = z11.object({
+  refreshId: z11.string().min(1),
+  cursor: z11.string().optional(),
+  limit: z11.number().int().positive().optional()
+});
+var GetCredentialRefreshHistoryResultValidator = z11.object({
+  records: CredentialRefreshVersionMetadataValidator.array(),
+  hasMore: z11.boolean(),
+  cursor: z11.string().optional()
+});
+var CredentialRefreshChallengeValidator = z11.object({
+  challenge: z11.string().min(1),
+  expiresAt: z11.string().min(1),
+  domain: z11.string().optional(),
+  scheme: z11.literal("LearnCardDIDAuth").optional()
+});
+var PublicCredentialRefreshEnvelopeValidator = z11.object({
+  format: z11.literal("vc"),
+  credential: VCValidator,
+  etag: z11.string().optional()
+});
+var JweCredentialRefreshEnvelopeValidator = z11.object({
+  format: z11.literal("jwe"),
+  jwe: JWEValidator,
+  etag: z11.string().optional(),
+  /** Present on LearnCard-managed endpoints; optional for interoperable JWE services. */
+  version: z11.number().int().positive().optional()
+});
+var CredentialRefreshResponseEnvelopeValidator = z11.discriminatedUnion("format", [
+  PublicCredentialRefreshEnvelopeValidator,
+  JweCredentialRefreshEnvelopeValidator
+]);
+var CredentialRefreshFailureCodeValidator = z11.enum([
+  "UNAVAILABLE",
+  "TIMEOUT",
+  "UNSUPPORTED_SERVICE",
+  "UNAUTHORIZED",
+  "MALFORMED_RESPONSE",
+  "INVALID_PROOF",
+  "ISSUER_MISMATCH",
+  "ID_MISMATCH",
+  "ROLLBACK",
+  "REVOKED",
+  "UNSAFE_ENDPOINT"
+]);
+var CredentialRefreshUpdatedResultValidator = z11.object({
+  status: z11.literal("updated"),
+  credential: VCValidator,
+  etag: z11.string().optional(),
+  managedVersion: z11.number().int().positive().optional()
+});
+var CredentialRefreshUnchangedResultValidator = z11.object({
+  status: z11.literal("unchanged"),
+  checkedAt: z11.string().min(1),
+  etag: z11.string().optional()
+});
+var CredentialRefreshUnsupportedResultValidator = z11.object({
+  status: z11.literal("unsupported")
+});
+var CredentialRefreshFailedResultValidator = z11.object({
+  status: z11.literal("failed"),
+  code: CredentialRefreshFailureCodeValidator,
+  retryable: z11.boolean()
+});
+var CredentialRefreshResultValidator = z11.discriminatedUnion("status", [
+  CredentialRefreshUpdatedResultValidator,
+  CredentialRefreshUnchangedResultValidator,
+  CredentialRefreshUnsupportedResultValidator,
+  CredentialRefreshFailedResultValidator
+]);
+
 // src/lcn.ts
-var LCNProfileDisplayValidator = z11.object({
-  backgroundColor: z11.string().optional(),
-  backgroundImage: z11.string().optional(),
-  fadeBackgroundImage: z11.boolean().optional(),
-  repeatBackgroundImage: z11.boolean().optional(),
-  fontColor: z11.string().optional(),
-  accentColor: z11.string().optional(),
-  accentFontColor: z11.string().optional(),
-  idBackgroundImage: z11.string().optional(),
-  fadeIdBackgroundImage: z11.boolean().optional(),
-  idBackgroundColor: z11.string().optional(),
-  repeatIdBackgroundImage: z11.boolean().optional()
-});
-var ProfileVisibilityEnum = z11.enum(["public", "connections_only", "private"]);
-var AllowConnectionRequestsEnum = z11.enum(["anyone", "invite_only"]);
-var LCNProfileValidator = z11.object({
-  profileId: z11.string().min(3).max(40).describe("Unique, URL-safe identifier for the profile."),
-  displayName: z11.string().default("").describe("Human-readable display name for the profile."),
-  shortBio: z11.string().default("").describe("Short bio for the profile."),
-  bio: z11.string().default("").describe("Longer bio for the profile."),
-  did: z11.string().describe("Decentralized Identifier for the profile. (auto-assigned)"),
-  isPrivate: z11.boolean().optional().describe("Whether the profile is private or not and shows up in search results."),
+var LCNProfileDisplayValidator = z12.object({
+  backgroundColor: z12.string().optional(),
+  backgroundImage: z12.string().optional(),
+  fadeBackgroundImage: z12.boolean().optional(),
+  repeatBackgroundImage: z12.boolean().optional(),
+  fontColor: z12.string().optional(),
+  accentColor: z12.string().optional(),
+  accentFontColor: z12.string().optional(),
+  idBackgroundImage: z12.string().optional(),
+  fadeIdBackgroundImage: z12.boolean().optional(),
+  idBackgroundColor: z12.string().optional(),
+  repeatIdBackgroundImage: z12.boolean().optional()
+});
+var ProfileVisibilityEnum = z12.enum(["public", "connections_only", "private"]);
+var AllowConnectionRequestsEnum = z12.enum(["anyone", "invite_only"]);
+var LCNProfileValidator = z12.object({
+  profileId: z12.string().min(3).max(40).describe("Unique, URL-safe identifier for the profile."),
+  displayName: z12.string().default("").describe("Human-readable display name for the profile."),
+  shortBio: z12.string().default("").describe("Short bio for the profile."),
+  bio: z12.string().default("").describe("Longer bio for the profile."),
+  did: z12.string().describe("Decentralized Identifier for the profile. (auto-assigned)"),
+  isPrivate: z12.boolean().optional().describe("Whether the profile is private or not and shows up in search results."),
   profileVisibility: ProfileVisibilityEnum.default("public").optional().describe("Profile visibility: 'public', 'connections_only', or 'private'."),
-  showEmail: z11.boolean().default(false).optional().describe("Whether to show email to connections."),
+  showEmail: z12.boolean().default(false).optional().describe("Whether to show email to connections."),
   allowConnectionRequests: AllowConnectionRequestsEnum.default("anyone").optional().describe("Who can send connection requests: 'anyone' or 'invite_only'."),
-  email: z11.string().optional().describe("Contact email address for the profile. (deprecated)"),
-  image: z11.string().optional().describe("Profile image URL for the profile."),
-  heroImage: z11.string().optional().describe("Hero image URL for the profile."),
-  websiteLink: z11.string().optional().describe("Website link for the profile."),
-  isServiceProfile: z11.boolean().default(false).optional().describe("Whether the profile is a service profile or not."),
-  type: z11.string().optional().describe('Profile type: e.g. "person", "organization", "service".'),
-  notificationsWebhook: z11.string().url().startsWith("http").optional().describe("URL to send notifications to."),
+  email: z12.string().optional().describe("Contact email address for the profile. (deprecated)"),
+  image: z12.string().optional().describe("Profile image URL for the profile."),
+  heroImage: z12.string().optional().describe("Hero image URL for the profile."),
+  websiteLink: z12.string().optional().describe("Website link for the profile."),
+  isServiceProfile: z12.boolean().default(false).optional().describe("Whether the profile is a service profile or not."),
+  type: z12.string().optional().describe('Profile type: e.g. "person", "organization", "service".'),
+  notificationsWebhook: z12.string().url().startsWith("http").optional().describe("URL to send notifications to."),
   display: LCNProfileDisplayValidator.optional().describe("Display settings for the profile."),
-  highlightedCredentials: z11.array(z11.string()).max(5).optional().describe("Up to 5 unique boost URIs to highlight on the profile."),
-  role: z11.string().default("").optional().describe('Role of the profile: e.g. "teacher", "student".'),
-  dob: z11.string().default("").optional().describe('Date of birth of the profile: e.g. "1990-01-01".'),
-  country: z11.string().optional().describe("Country for the profile."),
-  locale: z11.string().optional().describe(
+  highlightedCredentials: z12.array(z12.string()).max(5).optional().describe("Up to 5 unique boost URIs to highlight on the profile."),
+  role: z12.string().default("").optional().describe('Role of the profile: e.g. "teacher", "student".'),
+  dob: z12.string().default("").optional().describe('Date of birth of the profile: e.g. "1990-01-01".'),
+  country: z12.string().optional().describe("Country for the profile."),
+  locale: z12.string().optional().describe(
     "BCP-47 language tag (e.g. 'es', 'fr', 'ar') \u2014 the user's preferred language for server-sent notifications and emails."
   ),
-  approved: z11.boolean().optional().describe("Approval status for the profile.")
+  approved: z12.boolean().optional().describe("Approval status for the profile.")
 });
 var LCNPublicProfileValidator = LCNProfileValidator.pick({
   profileId: true,
@@ -675,30 +884,30 @@ var LCNPublicProfileValidator = LCNProfileValidator.pick({
   isServiceProfile: true,
   display: true
 });
-var LCNConnectionPromptStatusValidator = z11.enum(["PENDING", "SKIPPED", "CONNECTED"]);
-var LCNConnectionPromptSurfaceValidator = z11.enum(["POST_CLAIM", "NOTIFICATION"]);
-var LCNConnectionPromptActionStatusValidator = z11.enum([
+var LCNConnectionPromptStatusValidator = z12.enum(["PENDING", "SKIPPED", "CONNECTED"]);
+var LCNConnectionPromptSurfaceValidator = z12.enum(["POST_CLAIM", "NOTIFICATION"]);
+var LCNConnectionPromptActionStatusValidator = z12.enum([
   "PENDING",
   "SKIPPED",
   "CONNECTED",
   "STALE"
 ]);
-var LCNConnectionPromptValidator = z11.object({
-  promptId: z11.string().uuid(),
+var LCNConnectionPromptValidator = z12.object({
+  promptId: z12.string().uuid(),
   status: LCNConnectionPromptStatusValidator,
   surface: LCNConnectionPromptSurfaceValidator,
-  triggerId: z11.string(),
-  triggeredAt: z11.iso.datetime(),
-  updatedAt: z11.iso.datetime(),
+  triggerId: z12.string(),
+  triggeredAt: z12.iso.datetime(),
+  updatedAt: z12.iso.datetime(),
   counterpart: LCNPublicProfileValidator
 });
-var LCNConnectionPromptActionResultValidator = z11.object({
-  promptId: z11.string().uuid(),
+var LCNConnectionPromptActionResultValidator = z12.object({
+  promptId: z12.string().uuid(),
   status: LCNConnectionPromptActionStatusValidator
 });
-var LCNConnectionPromptMetadataValidator = z11.object({
-  promptId: z11.string().uuid(),
-  counterpartProfileId: z11.string()
+var LCNConnectionPromptMetadataValidator = z12.object({
+  promptId: z12.string().uuid(),
+  counterpartProfileId: z12.string()
 });
 var LCNAuthedProfileValidator = LCNPublicProfileValidator.extend({
   bio: LCNProfileValidator.shape.bio,
@@ -709,22 +918,22 @@ var LCNAuthedProfileValidator = LCNPublicProfileValidator.extend({
 });
 var LCNConnectionProfileValidator = LCNAuthedProfileValidator.extend({
   email: LCNProfileValidator.shape.email,
-  connectedAt: z11.iso.datetime().optional().describe("When the viewer and this profile became connected.")
+  connectedAt: z12.iso.datetime().optional().describe("When the viewer and this profile became connected.")
 });
-var LCNVisibleProfileValidator = z11.union([
+var LCNVisibleProfileValidator = z12.union([
   LCNConnectionProfileValidator.strict(),
   LCNAuthedProfileValidator.strict(),
   LCNPublicProfileValidator.strict(),
   LCNProfileValidator
 ]);
-var LCNProfileQueryValidator = z11.object({
+var LCNProfileQueryValidator = z12.object({
   profileId: StringQuery,
   displayName: StringQuery,
   shortBio: StringQuery,
   bio: StringQuery,
   email: StringQuery,
   websiteLink: StringQuery,
-  isServiceProfile: z11.boolean(),
+  isServiceProfile: z12.boolean(),
   type: StringQuery
 }).partial();
 var PaginatedLCNProfilesValidator = PaginationResponseValidator.extend({
@@ -733,26 +942,26 @@ var PaginatedLCNProfilesValidator = PaginationResponseValidator.extend({
 var PaginatedVisibleLCNProfilesValidator = PaginationResponseValidator.extend({
   records: LCNVisibleProfileValidator.array()
 });
-var LCNProfileConnectionStatusEnum = z11.enum([
+var LCNProfileConnectionStatusEnum = z12.enum([
   "CONNECTED",
   "PENDING_REQUEST_SENT",
   "PENDING_REQUEST_RECEIVED",
   "NOT_CONNECTED"
 ]);
-var LCNProfileManagerValidator = z11.object({
-  id: z11.string(),
-  created: z11.string(),
-  displayName: z11.string().default("").optional(),
-  shortBio: z11.string().default("").optional(),
-  bio: z11.string().default("").optional(),
-  email: z11.string().optional(),
-  image: z11.string().optional(),
-  heroImage: z11.string().optional()
+var LCNProfileManagerValidator = z12.object({
+  id: z12.string(),
+  created: z12.string(),
+  displayName: z12.string().default("").optional(),
+  shortBio: z12.string().default("").optional(),
+  bio: z12.string().default("").optional(),
+  email: z12.string().optional(),
+  image: z12.string().optional(),
+  heroImage: z12.string().optional()
 });
 var PaginatedLCNProfileManagersValidator = PaginationResponseValidator.extend({
-  records: LCNProfileManagerValidator.extend({ did: z11.string() }).array()
+  records: LCNProfileManagerValidator.extend({ did: z12.string() }).array()
 });
-var LCNProfileManagerQueryValidator = z11.object({
+var LCNProfileManagerQueryValidator = z12.object({
   id: StringQuery,
   displayName: StringQuery,
   shortBio: StringQuery,
@@ -760,105 +969,105 @@ var LCNProfileManagerQueryValidator = z11.object({
   email: StringQuery
 }).partial();
 var PaginatedLCNProfilesAndManagersValidator = PaginationResponseValidator.extend({
-  records: z11.object({
+  records: z12.object({
     profile: LCNProfileValidator,
-    manager: LCNProfileManagerValidator.extend({ did: z11.string() }).optional()
+    manager: LCNProfileManagerValidator.extend({ did: z12.string() }).optional()
   }).array()
 });
-var SentCredentialInfoValidator = z11.object({
-  uri: z11.string(),
-  to: z11.string(),
-  from: z11.string(),
-  sent: z11.iso.datetime(),
-  received: z11.iso.datetime().optional(),
-  metadata: z11.record(z11.string(), z11.unknown()).optional()
-});
-var BoostPermissionsValidator = z11.object({
-  role: z11.string(),
-  canView: z11.boolean().default(true),
-  canEdit: z11.boolean(),
-  canIssue: z11.boolean(),
-  canRevoke: z11.boolean(),
-  canManagePermissions: z11.boolean(),
-  canIssueChildren: z11.string(),
-  canCreateChildren: z11.string(),
-  canEditChildren: z11.string(),
-  canRevokeChildren: z11.string(),
-  canManageChildrenPermissions: z11.string(),
-  canManageChildrenProfiles: z11.boolean().optional(),
-  canViewAnalytics: z11.boolean()
-});
-var BoostPermissionsQueryValidator = z11.object({
+var SentCredentialInfoValidator = z12.object({
+  uri: z12.string(),
+  to: z12.string(),
+  from: z12.string(),
+  sent: z12.iso.datetime(),
+  received: z12.iso.datetime().optional(),
+  metadata: z12.record(z12.string(), z12.unknown()).optional()
+});
+var BoostPermissionsValidator = z12.object({
+  role: z12.string(),
+  canView: z12.boolean().default(true),
+  canEdit: z12.boolean(),
+  canIssue: z12.boolean(),
+  canRevoke: z12.boolean(),
+  canManagePermissions: z12.boolean(),
+  canIssueChildren: z12.string(),
+  canCreateChildren: z12.string(),
+  canEditChildren: z12.string(),
+  canRevokeChildren: z12.string(),
+  canManageChildrenPermissions: z12.string(),
+  canManageChildrenProfiles: z12.boolean().optional(),
+  canViewAnalytics: z12.boolean()
+});
+var BoostPermissionsQueryValidator = z12.object({
   role: StringQuery,
-  canView: z11.boolean(),
-  canEdit: z11.boolean(),
-  canIssue: z11.boolean(),
-  canRevoke: z11.boolean(),
-  canManagePermissions: z11.boolean(),
+  canView: z12.boolean(),
+  canEdit: z12.boolean(),
+  canIssue: z12.boolean(),
+  canRevoke: z12.boolean(),
+  canManagePermissions: z12.boolean(),
   canIssueChildren: StringQuery,
   canCreateChildren: StringQuery,
   canEditChildren: StringQuery,
   canRevokeChildren: StringQuery,
   canManageChildrenPermissions: StringQuery,
-  canManageChildrenProfiles: z11.boolean(),
-  canViewAnalytics: z11.boolean()
+  canManageChildrenProfiles: z12.boolean(),
+  canViewAnalytics: z12.boolean()
 }).partial();
-var ClaimHookTypeValidator = z11.enum(["GRANT_PERMISSIONS", "ADD_ADMIN", "AUTO_CONNECT"]);
-var ClaimHookValidator = z11.discriminatedUnion("type", [
-  z11.object({
-    type: z11.literal(ClaimHookTypeValidator.enum.GRANT_PERMISSIONS),
-    data: z11.object({
-      claimUri: z11.string(),
-      targetUri: z11.string(),
+var ClaimHookTypeValidator = z12.enum(["GRANT_PERMISSIONS", "ADD_ADMIN", "AUTO_CONNECT"]);
+var ClaimHookValidator = z12.discriminatedUnion("type", [
+  z12.object({
+    type: z12.literal(ClaimHookTypeValidator.enum.GRANT_PERMISSIONS),
+    data: z12.object({
+      claimUri: z12.string(),
+      targetUri: z12.string(),
       permissions: BoostPermissionsValidator.partial()
     })
   }),
-  z11.object({
-    type: z11.literal(ClaimHookTypeValidator.enum.ADD_ADMIN),
-    data: z11.object({ claimUri: z11.string(), targetUri: z11.string() })
+  z12.object({
+    type: z12.literal(ClaimHookTypeValidator.enum.ADD_ADMIN),
+    data: z12.object({ claimUri: z12.string(), targetUri: z12.string() })
   }),
-  z11.object({
-    type: z11.literal(ClaimHookTypeValidator.enum.AUTO_CONNECT),
-    data: z11.object({ claimUri: z11.string(), targetUri: z11.string() })
+  z12.object({
+    type: z12.literal(ClaimHookTypeValidator.enum.AUTO_CONNECT),
+    data: z12.object({ claimUri: z12.string(), targetUri: z12.string() })
   })
 ]);
-var ClaimHookQueryValidator = z11.object({
+var ClaimHookQueryValidator = z12.object({
   type: StringQuery,
-  data: z11.object({
+  data: z12.object({
     claimUri: StringQuery,
     targetUri: StringQuery,
     permissions: BoostPermissionsQueryValidator.partial()
   }).partial()
 });
-var FullClaimHookValidator = z11.object({ id: z11.string(), createdAt: z11.string(), updatedAt: z11.string() }).and(ClaimHookValidator);
+var FullClaimHookValidator = z12.object({ id: z12.string(), createdAt: z12.string(), updatedAt: z12.string() }).and(ClaimHookValidator);
 var PaginatedClaimHooksValidator = PaginationResponseValidator.extend({
   records: FullClaimHookValidator.array()
 });
-var LCNBoostStatus = z11.enum(["DRAFT", "PROVISIONAL", "LIVE"]);
-var BoostValidator = z11.object({
-  uri: z11.string(),
-  name: z11.string().optional(),
-  type: z11.string().optional(),
-  category: z11.string().optional(),
-  created: z11.string().optional(),
+var LCNBoostStatus = z12.enum(["DRAFT", "PROVISIONAL", "LIVE"]);
+var BoostValidator = z12.object({
+  uri: z12.string(),
+  name: z12.string().optional(),
+  type: z12.string().optional(),
+  category: z12.string().optional(),
+  created: z12.string().optional(),
   status: LCNBoostStatus.optional(),
-  autoConnectRecipients: z11.boolean().optional(),
-  meta: z11.record(z11.string(), z11.any()).optional(),
+  autoConnectRecipients: z12.boolean().optional(),
+  meta: z12.record(z12.string(), z12.any()).optional(),
   claimPermissions: BoostPermissionsValidator.optional(),
   defaultPermissions: BoostPermissionsValidator.optional(),
-  allowAnyoneToCreateChildren: z11.boolean().optional()
+  allowAnyoneToCreateChildren: z12.boolean().optional()
 });
-var BaseBoostQueryValidator = z11.object({
+var BaseBoostQueryValidator = z12.object({
   uri: StringQuery,
   name: StringQuery,
   type: StringQuery,
   category: StringQuery,
-  meta: z11.record(z11.string(), StringQuery),
-  status: LCNBoostStatus.or(z11.object({ $in: LCNBoostStatus.array() })),
-  autoConnectRecipients: z11.boolean()
+  meta: z12.record(z12.string(), StringQuery),
+  status: LCNBoostStatus.or(z12.object({ $in: LCNBoostStatus.array() })),
+  autoConnectRecipients: z12.boolean()
 }).partial();
-var BoostQueryValidator = z11.union([
-  z11.object({
+var BoostQueryValidator = z12.union([
+  z12.object({
     $or: BaseBoostQueryValidator.array()
   }),
   BaseBoostQueryValidator
@@ -866,99 +1075,105 @@ var BoostQueryValidator = z11.union([
 var PaginatedBoostsValidator = PaginationResponseValidator.extend({
   records: BoostValidator.array()
 });
-var BoostRecipientValidator = z11.object({
+var BoostRecipientValidator = z12.object({
   to: LCNVisibleProfileValidator,
-  from: z11.string(),
-  received: z11.string().optional(),
-  uri: z11.string().optional(),
-  status: z11.enum(["active", "revoked", "suspended"]).optional()
+  from: z12.string(),
+  received: z12.string().optional(),
+  uri: z12.string().optional(),
+  status: z12.enum(["active", "revoked", "suspended"]).optional()
 });
 var PaginatedBoostRecipientsValidator = PaginationResponseValidator.extend({
   records: BoostRecipientValidator.array()
 });
-var BoostRecipientWithChildrenValidator = z11.object({
+var BoostRecipientWithChildrenValidator = z12.object({
   to: LCNVisibleProfileValidator,
-  from: z11.string(),
-  received: z11.string().optional(),
-  boostUris: z11.array(z11.string()),
-  credentialUris: z11.array(z11.string()).optional(),
-  status: z11.enum(["active", "revoked", "suspended"]).optional()
+  from: z12.string(),
+  received: z12.string().optional(),
+  boostUris: z12.array(z12.string()),
+  credentialUris: z12.array(z12.string()).optional(),
+  status: z12.enum(["active", "revoked", "suspended"]).optional()
 });
 var PaginatedBoostRecipientsWithChildrenValidator = PaginationResponseValidator.extend({
   records: BoostRecipientWithChildrenValidator.array()
 });
-var LCNBoostClaimLinkSigningAuthorityValidator = z11.object({
-  endpoint: z11.string(),
-  name: z11.string(),
-  did: z11.string().optional()
+var LCNBoostClaimLinkSigningAuthorityValidator = z12.object({
+  endpoint: z12.string(),
+  name: z12.string(),
+  did: z12.string().optional()
 });
-var LCNBoostClaimLinkOptionsValidator = z11.object({
-  ttlSeconds: z11.number().optional(),
-  totalUses: z11.number().optional()
+var LCNBoostClaimLinkOptionsValidator = z12.object({
+  ttlSeconds: z12.number().optional(),
+  totalUses: z12.number().optional()
 });
-var LCNSigningAuthorityValidator = z11.object({
-  endpoint: z11.string()
+var LCNSigningAuthorityValidator = z12.object({
+  endpoint: z12.string()
 });
-var LCNSigningAuthorityForUserValidator = z11.object({
+var LCNSigningAuthorityForUserValidator = z12.object({
   signingAuthority: LCNSigningAuthorityValidator,
-  relationship: z11.object({
-    name: z11.string().max(15).regex(/^[a-z0-9-]+$/, {
+  relationship: z12.object({
+    name: z12.string().max(15).regex(/^[a-z0-9-]+$/, {
       message: "The input string must contain only lowercase letters, numbers, and hyphens."
     }),
-    did: z11.string(),
-    isPrimary: z11.boolean().optional()
+    did: z12.string(),
+    isPrimary: z12.boolean().optional()
   })
 });
-var AutoBoostConfigValidator = z11.object({
-  boostUri: z11.string(),
-  signingAuthority: z11.object({
-    endpoint: z11.string(),
-    name: z11.string()
+var AutoBoostConfigValidator = z12.object({
+  boostUri: z12.string(),
+  signingAuthority: z12.object({
+    endpoint: z12.string(),
+    name: z12.string()
   })
 });
 var SendBoostTemplateValidator = BoostValidator.partial().omit({ uri: true, claimPermissions: true }).extend({
   credential: VCValidator.or(UnsignedVCValidator),
   claimPermissions: BoostPermissionsValidator.partial().optional(),
-  skills: z11.array(
-    z11.object({
-      frameworkId: z11.string(),
-      id: z11.string(),
-      proficiencyLevel: z11.number().optional()
+  skills: z12.array(
+    z12.object({
+      frameworkId: z12.string(),
+      id: z12.string(),
+      proficiencyLevel: z12.number().optional()
     })
   ).min(1).optional()
 });
-var SendBrandingOptionsValidator = z11.object({
-  issuerName: z11.string().optional().describe("Name of the issuing organization"),
-  issuerLogoUrl: z11.string().url().optional().describe("Logo URL of the issuing organization"),
-  credentialName: z11.string().optional().describe("Display name for the credential"),
-  recipientName: z11.string().optional().describe("Name of the recipient for personalization")
+var SendBrandingOptionsValidator = z12.object({
+  issuerName: z12.string().optional().describe("Name of the issuing organization"),
+  issuerLogoUrl: z12.string().url().optional().describe("Logo URL of the issuing organization"),
+  credentialName: z12.string().optional().describe("Display name for the credential"),
+  recipientName: z12.string().optional().describe("Name of the recipient for personalization")
 });
-var GuardianStatusValidator = z11.enum([
+var GuardianStatusValidator = z12.enum([
   "AWAITING_GUARDIAN",
   "GUARDIAN_APPROVED",
   "GUARDIAN_REJECTED"
 ]);
-var SendOptionsValidator = z11.object({
-  webhookUrl: z11.string().url().optional().describe("Webhook URL to receive claim notifications"),
-  suppressDelivery: z11.boolean().optional().describe("If true, returns claimUrl without sending email/SMS"),
+var SendOptionsValidator = z12.object({
+  webhookUrl: z12.string().url().optional().describe("Webhook URL to receive claim notifications"),
+  suppressDelivery: z12.boolean().optional().describe("If true, returns claimUrl without sending email/SMS"),
   branding: SendBrandingOptionsValidator.optional().describe("Branding for email/SMS delivery"),
-  guardianEmail: z11.string().email().optional().describe("Guardian email that must approve before student can claim"),
-  expiresInDays: z11.number().int().min(1).max(720).optional().describe(
+  guardianEmail: z12.string().email().optional().describe("Guardian email that must approve before student can claim"),
+  expiresInDays: z12.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 = z11.object({
-  type: z11.literal("boost"),
-  recipient: z11.string().describe("Profile ID, DID, email, or phone number (auto-detected)"),
-  contractUri: z11.string().optional(),
-  templateUri: z11.string().optional(),
+var SendBoostInputValidator = z12.object({
+  type: z12.literal("boost"),
+  recipient: z12.string().describe("Profile ID, DID, email, or phone number (auto-detected)"),
+  contractUri: z12.string().optional(),
+  templateUri: z12.string().optional(),
   template: SendBoostTemplateValidator.optional(),
   signedCredential: VCValidator.optional(),
   options: SendOptionsValidator.optional().describe(
     "Options for email/phone recipients (Universal Inbox)"
   ),
-  templateData: z11.record(z11.string(), z11.unknown()).optional(),
-  integrationId: z11.string().optional().describe("Integration ID for activity tracking")
+  templateData: z12.record(z12.string(), z12.unknown()).optional(),
+  integrationId: z12.string().optional().describe("Integration ID for activity tracking"),
+  refresh: z12.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: z12.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"]
@@ -973,248 +1188,298 @@ var SendBoostInputValidator = z11.object({
     message: "guardianEmail must differ from recipient (self-approval not allowed)",
     path: ["options", "guardianEmail"]
   }
-);
-var SendInboxResponseValidator = z11.object({
-  issuanceId: z11.string(),
-  status: z11.enum(["PENDING", "ISSUED", "EXPIRED", "DELIVERED", "CLAIMED"]),
-  claimUrl: z11.string().url().optional().describe("Present when suppressDelivery=true"),
+).refine((data) => !data.idempotencyKey || data.refresh === true, {
+  message: "idempotencyKey is only supported with refresh: true.",
+  path: ["idempotencyKey"]
+});
+var SendInboxResponseValidator = z12.object({
+  refresh: InboxCredentialRefreshReceiptValidator.optional(),
+  issuanceId: z12.string(),
+  status: z12.enum(["PENDING", "ISSUED", "EXPIRED", "DELIVERED", "CLAIMED"]),
+  claimUrl: z12.string().url().optional().describe("Present when suppressDelivery=true"),
   guardianStatus: GuardianStatusValidator.optional().describe(
     "Present when guardianEmail was specified"
   )
 });
-var SendBoostResponseValidator = z11.object({
-  type: z11.literal("boost"),
-  credentialUri: z11.string(),
-  uri: z11.string(),
-  activityId: z11.string().describe("Links to the activity lifecycle for this issuance"),
+var SendBoostResponseValidator = z12.object({
+  type: z12.literal("boost"),
+  credentialUri: z12.string(),
+  uri: z12.string(),
+  activityId: z12.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"
   )
 });
-var SendInputValidator = z11.discriminatedUnion("type", [SendBoostInputValidator]);
-var SendResponseValidator = z11.discriminatedUnion("type", [SendBoostResponseValidator]);
-var ConsentFlowTermsStatusValidator = z11.enum(["live", "stale", "withdrawn"]);
-var ConsentFlowContractValidator = z11.object({
-  read: z11.object({
-    anonymize: z11.boolean().optional(),
-    credentials: z11.object({
-      categories: z11.record(
-        z11.string(),
-        z11.object({
-          required: z11.boolean(),
-          defaultEnabled: z11.boolean().optional()
+var PrepareRefreshableSendInputValidator = z12.object({
+  recipient: z12.string(),
+  templateUri: z12.string().optional(),
+  template: SendBoostTemplateValidator.optional(),
+  contractUri: z12.string().optional(),
+  templateData: z12.record(z12.string(), z12.unknown()).optional(),
+  integrationId: z12.string().optional(),
+  /** Credential ID to allocate for; generated server-side when omitted. */
+  credentialId: z12.string().min(1).optional(),
+  idempotencyKey: z12.string().min(1).max(200).optional()
+}).refine((data) => Boolean(data.templateUri) !== Boolean(data.template), {
+  message: "Provide exactly one of templateUri or template."
+});
+var PrepareRefreshableSendResultValidator = z12.object({
+  boostUri: z12.string(),
+  credentialId: z12.string(),
+  refreshId: z12.string(),
+  refreshService: ManagedCredentialRefreshServiceValidator,
+  /** The DID to use as credentialSubject.id (recipient DID, or the profile's did:web). */
+  holderDid: z12.string(),
+  /** Present when this idempotencyKey already completed: return it without signing. */
+  completed: SendBoostResponseValidator.optional()
+});
+var SendInputValidator = z12.discriminatedUnion("type", [SendBoostInputValidator]);
+var SendResponseValidator = z12.discriminatedUnion("type", [SendBoostResponseValidator]);
+var ConsentFlowTermsStatusValidator = z12.enum(["live", "stale", "withdrawn"]);
+var ConsentFlowContractValidator = z12.object({
+  read: z12.object({
+    anonymize: z12.boolean().optional(),
+    credentials: z12.object({
+      categories: z12.record(
+        z12.string(),
+        z12.object({
+          required: z12.boolean(),
+          defaultEnabled: z12.boolean().optional()
         })
       ).default({})
     }).prefault({ categories: {} }),
-    personal: z11.record(
-      z11.string(),
-      z11.object({ required: z11.boolean(), defaultEnabled: z11.boolean().optional() })
+    personal: z12.record(
+      z12.string(),
+      z12.object({ required: z12.boolean(), defaultEnabled: z12.boolean().optional() })
     ).default({})
   }).prefault({ credentials: { categories: {} }, personal: {} }),
-  write: z11.object({
-    credentials: z11.object({
-      categories: z11.record(
-        z11.string(),
-        z11.object({
-          required: z11.boolean(),
-          defaultEnabled: z11.boolean().optional()
+  write: z12.object({
+    credentials: z12.object({
+      categories: z12.record(
+        z12.string(),
+        z12.object({
+          required: z12.boolean(),
+          defaultEnabled: z12.boolean().optional()
         })
       ).default({})
     }).prefault({ categories: {} }),
-    personal: z11.record(
-      z11.string(),
-      z11.object({ required: z11.boolean(), defaultEnabled: z11.boolean().optional() })
+    personal: z12.record(
+      z12.string(),
+      z12.object({ required: z12.boolean(), defaultEnabled: z12.boolean().optional() })
     ).default({})
   }).prefault({ credentials: { categories: {} }, personal: {} })
 });
-var ConsentFlowContractDetailsValidator = z11.object({
+var ConsentFlowContractDetailsValidator = z12.object({
   contract: ConsentFlowContractValidator,
   owner: LCNProfileValidator,
-  name: z11.string(),
-  subtitle: z11.string().optional(),
-  description: z11.string().optional(),
-  reasonForAccessing: z11.string().optional(),
-  image: z11.string().optional(),
-  uri: z11.string(),
-  needsGuardianConsent: z11.boolean().optional(),
-  redirectUrl: z11.string().optional(),
-  frontDoorBoostUri: z11.string().optional(),
-  createdAt: z11.string(),
-  updatedAt: z11.string(),
-  expiresAt: z11.string().optional(),
-  autoBoosts: z11.string().array().optional(),
-  writers: z11.array(LCNProfileValidator).optional()
-});
-var ConsentFlowContractRequestStatusValidator = z11.enum(["pending", "accepted", "denied"]).nullable();
-var ConsentFlowContractRequestReadStatusValidator = z11.enum(["unseen", "seen"]).nullable();
-var ConsentFlowContractRequestForProfileValidator = z11.object({
+  name: z12.string(),
+  subtitle: z12.string().optional(),
+  description: z12.string().optional(),
+  reasonForAccessing: z12.string().optional(),
+  image: z12.string().optional(),
+  uri: z12.string(),
+  needsGuardianConsent: z12.boolean().optional(),
+  redirectUrl: z12.string().optional(),
+  frontDoorBoostUri: z12.string().optional(),
+  createdAt: z12.string(),
+  updatedAt: z12.string(),
+  expiresAt: z12.string().optional(),
+  autoBoosts: z12.string().array().optional(),
+  writers: z12.array(LCNProfileValidator).optional()
+});
+var ConsentFlowContractRequestStatusValidator = z12.enum(["pending", "accepted", "denied"]).nullable();
+var ConsentFlowContractRequestReadStatusValidator = z12.enum(["unseen", "seen"]).nullable();
+var ConsentFlowContractRequestForProfileValidator = z12.object({
   profile: LCNProfileValidator,
   status: ConsentFlowContractRequestStatusValidator,
   readStatus: ConsentFlowContractRequestReadStatusValidator.optional()
 });
-var ConsentFlowContractRequestForProfileListValidator = z11.array(
+var ConsentFlowContractRequestForProfileListValidator = z12.array(
   ConsentFlowContractRequestForProfileValidator
 );
 var PaginatedConsentFlowContractsValidator = PaginationResponseValidator.extend({
   records: ConsentFlowContractDetailsValidator.omit({ owner: true }).array()
 });
-var ConsentFlowContractDataValidator = z11.object({
-  credentials: z11.object({ categories: z11.record(z11.string(), z11.string().array()).default({}) }),
-  personal: z11.record(z11.string(), z11.string()).default({}),
-  date: z11.string()
+var ConsentFlowContractDataValidator = z12.object({
+  credentials: z12.object({ categories: z12.record(z12.string(), z12.string().array()).default({}) }),
+  personal: z12.record(z12.string(), z12.string()).default({}),
+  date: z12.string()
 });
 var PaginatedConsentFlowDataValidator = PaginationResponseValidator.extend({
   records: ConsentFlowContractDataValidator.array()
 });
-var ConsentFlowContractDataForDidValidator = z11.object({
-  credentials: z11.object({ category: z11.string(), uri: z11.string() }).array(),
-  personal: z11.record(z11.string(), z11.string()).default({}),
-  date: z11.string(),
-  contractUri: z11.string()
-});
-var PaginatedConsentFlowDataForDidValidator = PaginationResponseValidator.extend({
-  records: ConsentFlowContractDataForDidValidator.array()
-});
-var ConsentFlowTermValidator = z11.object({
-  sharing: z11.boolean().optional(),
-  shared: z11.string().array().optional(),
-  shareAll: z11.boolean().optional(),
-  shareUntil: z11.string().optional()
-});
-var ConsentFlowTermsValidator = z11.object({
-  read: z11.object({
-    anonymize: z11.boolean().optional(),
-    credentials: z11.object({
-      shareAll: z11.boolean().optional(),
-      sharing: z11.boolean().optional(),
-      categories: z11.record(z11.string(), ConsentFlowTermValidator).default({})
+var ConsentFlowTermValidator = z12.object({
+  sharing: z12.boolean().optional(),
+  shared: z12.string().array().optional(),
+  shareAll: z12.boolean().optional(),
+  shareUntil: z12.string().optional()
+});
+var ConsentFlowTermsValidator = z12.object({
+  read: z12.object({
+    anonymize: z12.boolean().optional(),
+    credentials: z12.object({
+      shareAll: z12.boolean().optional(),
+      sharing: z12.boolean().optional(),
+      categories: z12.record(z12.string(), ConsentFlowTermValidator).default({})
     }).prefault({ categories: {} }),
-    personal: z11.record(z11.string(), z11.string()).default({})
+    personal: z12.record(z12.string(), z12.string()).default({})
   }).prefault({ credentials: { categories: {} }, personal: {} }),
-  write: z11.object({
-    credentials: z11.object({ categories: z11.record(z11.string(), z11.boolean()).default({}) }).prefault({ categories: {} }),
-    personal: z11.record(z11.string(), z11.boolean()).default({})
+  write: z12.object({
+    credentials: z12.object({ categories: z12.record(z12.string(), z12.boolean()).default({}) }).prefault({ categories: {} }),
+    personal: z12.record(z12.string(), z12.boolean()).default({})
   }).prefault({ credentials: { categories: {} }, personal: {} }),
-  deniedWriters: z11.array(z11.string()).optional()
+  deniedWriters: z12.array(z12.string()).optional()
 });
 var PaginatedConsentFlowTermsValidator = PaginationResponseValidator.extend({
-  records: z11.object({
-    expiresAt: z11.string().optional(),
-    oneTime: z11.boolean().optional(),
+  records: z12.object({
+    expiresAt: z12.string().optional(),
+    oneTime: z12.boolean().optional(),
     terms: ConsentFlowTermsValidator,
     contract: ConsentFlowContractDetailsValidator,
-    uri: z11.string(),
+    uri: z12.string(),
     consenter: LCNProfileValidator,
     status: ConsentFlowTermsStatusValidator
   }).array()
 });
-var ConsentFlowContractQueryValidator = z11.object({
-  read: z11.object({
-    anonymize: z11.boolean().optional(),
-    credentials: z11.object({
-      categories: z11.record(z11.string(), z11.object({ required: z11.boolean().optional() })).optional()
+var ConsentFlowGuardianApprovalValidator = z12.object({
+  guardianProfileId: z12.string(),
+  guardianDid: z12.string(),
+  approvedAt: z12.string().datetime(),
+  contractUpdatedAt: z12.string()
+});
+var ConsentFlowContractDataForDidValidator = z12.object({
+  credentials: z12.object({ category: z12.string(), uri: z12.string() }).array(),
+  personal: z12.record(z12.string(), z12.string()).default({}),
+  date: z12.string(),
+  createdAt: z12.string().optional(),
+  contractUpdatedAt: z12.string(),
+  contractExpiresAt: z12.string().optional(),
+  reasonForAccessing: z12.string().optional(),
+  guardian: z12.object({
+    required: z12.boolean(),
+    approved: z12.boolean(),
+    approval: ConsentFlowGuardianApprovalValidator.optional()
+  }),
+  contractUri: z12.string(),
+  termsUri: z12.string(),
+  status: ConsentFlowTermsStatusValidator,
+  expiresAt: z12.string().optional(),
+  terms: ConsentFlowTermsValidator
+});
+var PaginatedConsentFlowDataForDidValidator = PaginationResponseValidator.extend({
+  records: ConsentFlowContractDataForDidValidator.array()
+});
+var ConsentFlowContractQueryValidator = z12.object({
+  read: z12.object({
+    anonymize: z12.boolean().optional(),
+    credentials: z12.object({
+      categories: z12.record(z12.string(), z12.object({ required: z12.boolean().optional() })).optional()
     }).optional(),
-    personal: z11.record(z11.string(), z11.object({ required: z11.boolean().optional() })).optional()
+    personal: z12.record(z12.string(), z12.object({ required: z12.boolean().optional() })).optional()
   }).optional(),
-  write: z11.object({
-    credentials: z11.object({
-      categories: z11.record(z11.string(), z11.object({ required: z11.boolean().optional() })).optional()
+  write: z12.object({
+    credentials: z12.object({
+      categories: z12.record(z12.string(), z12.object({ required: z12.boolean().optional() })).optional()
     }).optional(),
-    personal: z11.record(z11.string(), z11.object({ required: z11.boolean().optional() })).optional()
+    personal: z12.record(z12.string(), z12.object({ required: z12.boolean().optional() })).optional()
   }).optional()
 });
-var ConsentFlowDataQueryValidator = z11.object({
-  anonymize: z11.boolean().optional(),
-  credentials: z11.object({ categories: z11.record(z11.string(), z11.boolean()).optional() }).optional(),
-  personal: z11.record(z11.string(), z11.boolean()).optional()
+var ConsentFlowDataQueryValidator = z12.object({
+  anonymize: z12.boolean().optional(),
+  credentials: z12.object({ categories: z12.record(z12.string(), z12.boolean()).optional() }).optional(),
+  personal: z12.record(z12.string(), z12.boolean()).optional()
 });
-var ConsentFlowDataForDidQueryValidator = z11.object({
-  credentials: z11.object({ categories: z11.record(z11.string(), z11.boolean()).optional() }).optional(),
-  personal: z11.record(z11.string(), z11.boolean()).optional(),
+var ConsentFlowDataForDidQueryValidator = z12.object({
+  credentials: z12.object({ categories: z12.record(z12.string(), z12.boolean()).optional() }).optional(),
+  personal: z12.record(z12.string(), z12.boolean()).optional(),
   id: StringQuery.optional()
 });
-var ConsentFlowTermsQueryValidator = z11.object({
-  read: z11.object({
-    anonymize: z11.boolean().optional(),
-    credentials: z11.object({
-      shareAll: z11.boolean().optional(),
-      sharing: z11.boolean().optional(),
-      categories: z11.record(z11.string(), ConsentFlowTermValidator.optional()).optional()
+var ConsentFlowTermsQueryValidator = z12.object({
+  read: z12.object({
+    anonymize: z12.boolean().optional(),
+    credentials: z12.object({
+      shareAll: z12.boolean().optional(),
+      sharing: z12.boolean().optional(),
+      categories: z12.record(z12.string(), ConsentFlowTermValidator.optional()).optional()
     }).optional(),
-    personal: z11.record(z11.string(), z11.string()).optional()
+    personal: z12.record(z12.string(), z12.string()).optional()
   }).optional(),
-  write: z11.object({
-    credentials: z11.object({ categories: z11.record(z11.string(), z11.boolean()).optional() }).optional(),
-    personal: z11.record(z11.string(), z11.boolean()).optional()
+  write: z12.object({
+    credentials: z12.object({ categories: z12.record(z12.string(), z12.boolean()).optional() }).optional(),
+    personal: z12.record(z12.string(), z12.boolean()).optional()
   }).optional()
 });
-var ConsentFlowTransactionActionValidator = z11.enum([
+var ConsentFlowTransactionActionValidator = z12.enum([
   "consent",
   "update",
   "sync",
   "withdraw",
   "write"
 ]);
-var ConsentFlowTransactionsQueryValidator = z11.object({
+var ConsentFlowTransactionsQueryValidator = z12.object({
   terms: ConsentFlowTermsQueryValidator.optional(),
   action: ConsentFlowTransactionActionValidator.or(
     ConsentFlowTransactionActionValidator.array()
   ).optional(),
-  date: z11.object({ $gt: z11.string() }).or(z11.object({ $lt: z11.string() })).or(z11.object({ $eq: z11.string() })).optional(),
-  expiresAt: z11.object({ $gt: z11.string() }).or(z11.object({ $lt: z11.string() })).or(z11.object({ $eq: z11.string() })).optional(),
-  oneTime: z11.boolean().optional()
+  date: z12.object({ $gt: z12.string() }).or(z12.object({ $lt: z12.string() })).or(z12.object({ $eq: z12.string() })).optional(),
+  expiresAt: z12.object({ $gt: z12.string() }).or(z12.object({ $lt: z12.string() })).or(z12.object({ $eq: z12.string() })).optional(),
+  oneTime: z12.boolean().optional()
 });
-var ConsentFlowTransactionValidator = z11.object({
-  expiresAt: z11.string().optional(),
-  oneTime: z11.boolean().optional(),
+var ConsentFlowTransactionValidator = z12.object({
+  expiresAt: z12.string().optional(),
+  oneTime: z12.boolean().optional(),
   terms: ConsentFlowTermsValidator.optional(),
-  id: z11.string(),
+  guardianApproval: ConsentFlowGuardianApprovalValidator.optional(),
+  id: z12.string(),
   action: ConsentFlowTransactionActionValidator,
-  date: z11.string(),
-  uris: z11.string().array().optional()
+  date: z12.string(),
+  uris: z12.string().array().optional()
 });
-var HolderExportConsentRecordValidator = z11.object({
-  termsUri: z11.string(),
+var HolderExportConsentRecordValidator = z12.object({
+  termsUri: z12.string(),
   status: ConsentFlowTermsStatusValidator,
   contract: ConsentFlowContractDetailsValidator,
   terms: ConsentFlowTermsValidator,
   transactions: ConsentFlowTransactionValidator.array()
 });
-var HolderExportMetadataValidator = z11.object({
+var HolderExportMetadataValidator = z12.object({
   consentRecords: HolderExportConsentRecordValidator.array(),
-  truncated: z11.boolean().optional(),
-  warnings: z11.string().array().optional(),
-  limits: z11.object({
-    maxConsentRecords: z11.number(),
-    maxTransactionsPerConsentRecord: z11.number()
+  truncated: z12.boolean().optional(),
+  warnings: z12.string().array().optional(),
+  limits: z12.object({
+    maxConsentRecords: z12.number(),
+    maxTransactionsPerConsentRecord: z12.number()
   }).optional()
 });
 var PaginatedConsentFlowTransactionsValidator = PaginationResponseValidator.extend({
   records: ConsentFlowTransactionValidator.array()
 });
-var BaseSkillFrameworkQueryValidator = z11.object({
+var BaseSkillFrameworkQueryValidator = z12.object({
   id: StringQuery,
   name: StringQuery,
   description: StringQuery,
   sourceURI: StringQuery,
   status: StringQuery
 }).partial();
-var SkillFrameworkQueryValidator = z11.union([
-  z11.object({ $or: BaseSkillFrameworkQueryValidator.array() }),
+var SkillFrameworkQueryValidator = z12.union([
+  z12.object({ $or: BaseSkillFrameworkQueryValidator.array() }),
   BaseSkillFrameworkQueryValidator
 ]);
-var ContractCredentialValidator = z11.object({
-  credentialUri: z11.string(),
-  termsUri: z11.string(),
-  contractUri: z11.string(),
-  boostUri: z11.string(),
-  category: z11.string().optional(),
-  date: z11.string()
+var ContractCredentialValidator = z12.object({
+  credentialUri: z12.string(),
+  termsUri: z12.string(),
+  contractUri: z12.string(),
+  boostUri: z12.string(),
+  category: z12.string().optional(),
+  date: z12.string()
 });
 var PaginatedContractCredentialsValidator = PaginationResponseValidator.extend({
   records: ContractCredentialValidator.array()
 });
-var LCNNotificationTypeEnumValidator = z11.enum([
+var LCNNotificationTypeEnumValidator = z12.enum([
   "CONNECTION_REQUEST",
   "CONNECTION_REQUEST_EXPIRED_INVITE",
   "CONNECTION_ACCEPTED",
@@ -1243,15 +1508,15 @@ var LCNNotificationTypeEnumValidator = z11.enum([
   "CREDENTIAL_UNSUSPENDED",
   "CREDENTIAL_REFRESHED"
 ]);
-var LCNNotificationMessageValidator = z11.object({
-  title: z11.string().optional(),
-  body: z11.string().optional()
+var LCNNotificationMessageValidator = z12.object({
+  title: z12.string().optional(),
+  body: z12.string().optional()
 });
-var LCNInboxContactMethodValidator = z11.object({
-  type: z11.string(),
-  value: z11.string()
+var LCNInboxContactMethodValidator = z12.object({
+  type: z12.string(),
+  value: z12.string()
 });
-var LCNInboxStatusEnumValidator = z11.enum([
+var LCNInboxStatusEnumValidator = z12.enum([
   "PENDING",
   "ISSUED",
   "EXPIRED",
@@ -1260,162 +1525,166 @@ var LCNInboxStatusEnumValidator = z11.enum([
   /* DEPRECATED — use ISSUED */
   "CLAIMED"
 ]);
-var LCNNotificationInboxValidator = z11.object({
-  issuanceId: z11.string(),
+var LCNNotificationInboxValidator = z12.object({
+  issuanceId: z12.string(),
   status: LCNInboxStatusEnumValidator,
-  recipient: z11.object({
+  recipient: z12.object({
     contactMethod: LCNInboxContactMethodValidator.optional(),
-    learnCardId: z11.string().optional()
+    learnCardId: z12.string().optional()
   }),
-  timestamp: z11.iso.datetime().optional()
+  timestamp: z12.iso.datetime().optional()
 });
-var LCNNotificationMetadataValidator = z11.object({
+var LCNNotificationMetadataValidator = z12.object({
   connectionPrompt: LCNConnectionPromptMetadataValidator.optional()
-}).catchall(z11.unknown());
-var LCNNotificationDataValidator = z11.object({
-  vcUris: z11.array(z11.string()).optional(),
-  vpUris: z11.array(z11.string()).optional(),
+}).catchall(z12.unknown());
+var LCNNotificationDataValidator = z12.object({
+  vcUris: z12.array(z12.string()).optional(),
+  vpUris: z12.array(z12.string()).optional(),
   transaction: ConsentFlowTransactionValidator.optional(),
   inbox: LCNNotificationInboxValidator.optional(),
   metadata: LCNNotificationMetadataValidator.optional()
 }).loose();
-var LCNNotificationValidator = z11.object({
+var LCNNotificationValidator = z12.object({
   type: LCNNotificationTypeEnumValidator,
-  to: LCNProfileValidator.partial().and(z11.object({ did: z11.string() })),
-  from: z11.union([z11.string(), LCNProfileValidator.partial().and(z11.object({ did: z11.string() }))]),
+  to: LCNProfileValidator.partial().and(z12.object({ did: z12.string() })),
+  from: z12.union([z12.string(), LCNProfileValidator.partial().and(z12.object({ did: z12.string() }))]),
   message: LCNNotificationMessageValidator.optional(),
   data: LCNNotificationDataValidator.optional(),
-  sent: z11.iso.datetime().optional(),
-  webhookUrl: z11.string().optional()
+  sent: z12.iso.datetime().optional(),
+  webhookUrl: z12.string().optional()
 });
 var AUTH_GRANT_AUDIENCE_DOMAIN_PREFIX = "auth-grant:";
-var AuthGrantValidator = z11.object({
-  id: z11.string(),
-  name: z11.string(),
-  description: z11.string().optional(),
-  challenge: z11.string().startsWith(AUTH_GRANT_AUDIENCE_DOMAIN_PREFIX).min(10, { message: "Challenge is too short" }).max(100, { message: "Challenge is too long" }),
-  status: z11.enum(["revoked", "active"], {
+var ACT_AS_HEADER = "X-LearnCard-Act-As";
+var AuthGrantValidator = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  description: z12.string().optional(),
+  challenge: z12.string().startsWith(AUTH_GRANT_AUDIENCE_DOMAIN_PREFIX).min(10, { message: "Challenge is too short" }).max(100, { message: "Challenge is too long" }),
+  status: z12.enum(["revoked", "active"], {
     error: /* @__PURE__ */ __name((issue) => {
       if (issue.code === "invalid_value") return "Status must be either active or revoked";
       return "Status is required";
     }, "error")
   }),
-  scope: z11.string(),
-  createdAt: z11.iso.datetime({ error: "createdAt must be a valid ISO 8601 datetime string" }),
-  expiresAt: z11.iso.datetime({ error: "expiresAt must be a valid ISO 8601 datetime string" }).nullish().optional()
-});
-var FlatAuthGrantValidator = z11.object({ id: z11.string() }).catchall(z11.any());
-var AuthGrantStatusValidator = z11.enum(["active", "revoked"]);
-var AuthGrantQueryValidator = z11.object({
+  scope: z12.string(),
+  actAs: z12.string().optional(),
+  createdAt: z12.iso.datetime({ error: "createdAt must be a valid ISO 8601 datetime string" }),
+  expiresAt: z12.iso.datetime({ error: "expiresAt must be a valid ISO 8601 datetime string" }).nullish().optional()
+});
+var FlatAuthGrantValidator = z12.object({ id: z12.string() }).catchall(z12.any());
+var AuthGrantStatusValidator = z12.enum(["active", "revoked"]);
+var AuthGrantQueryValidator = z12.object({
   id: StringQuery,
   name: StringQuery,
   description: StringQuery,
   status: AuthGrantStatusValidator
 }).partial();
-var contactMethodBase = z11.object({
-  id: z11.string(),
-  isVerified: z11.boolean(),
-  verifiedAt: z11.string().optional(),
-  isPrimary: z11.boolean(),
-  createdAt: z11.string()
-});
-var ContactMethodValidator = z11.discriminatedUnion("type", [
-  z11.object({
-    type: z11.literal("email"),
-    value: z11.string().email()
+var contactMethodBase = z12.object({
+  id: z12.string(),
+  isVerified: z12.boolean(),
+  verifiedAt: z12.string().optional(),
+  isPrimary: z12.boolean(),
+  createdAt: z12.string()
+});
+var ContactMethodValidator = z12.discriminatedUnion("type", [
+  z12.object({
+    type: z12.literal("email"),
+    value: z12.string().email()
   }).merge(contactMethodBase),
-  z11.object({
-    type: z11.literal("phone"),
-    value: z11.string()
+  z12.object({
+    type: z12.literal("phone"),
+    value: z12.string()
     // Can be improved with a regex later
   }).merge(contactMethodBase)
 ]);
-var createContactMethodBase = z11.object({
-  isVerified: z11.boolean().optional(),
-  isPrimary: z11.boolean().optional()
-});
-var ContactMethodCreateValidator = z11.discriminatedUnion("type", [
-  z11.object({
-    type: z11.literal("email"),
-    value: z11.string().email()
+var createContactMethodBase = z12.object({
+  isVerified: z12.boolean().optional(),
+  isPrimary: z12.boolean().optional()
+});
+var ContactMethodCreateValidator = z12.discriminatedUnion("type", [
+  z12.object({
+    type: z12.literal("email"),
+    value: z12.string().email()
   }).merge(createContactMethodBase),
-  z11.object({
-    type: z11.literal("phone"),
-    value: z11.string()
+  z12.object({
+    type: z12.literal("phone"),
+    value: z12.string()
   }).merge(createContactMethodBase)
 ]);
-var ContactMethodQueryValidator = z11.discriminatedUnion("type", [
-  z11.object({
-    type: z11.literal("email"),
-    value: z11.string().email()
+var ContactMethodQueryValidator = z12.discriminatedUnion("type", [
+  z12.object({
+    type: z12.literal("email"),
+    value: z12.string().email()
   }),
-  z11.object({
-    type: z11.literal("phone"),
-    value: z11.string()
+  z12.object({
+    type: z12.literal("phone"),
+    value: z12.string()
   })
 ]);
-var ContactMethodVerificationRequestValidator = z11.object({
-  value: z11.string(),
-  type: z11.enum(["email", "phone"])
+var ContactMethodVerificationRequestValidator = z12.object({
+  value: z12.string(),
+  type: z12.enum(["email", "phone"])
 });
-var ContactMethodVerificationValidator = z11.object({
-  token: z11.string()
+var ContactMethodVerificationValidator = z12.object({
+  token: z12.string()
 });
-var SetPrimaryContactMethodValidator = z11.object({
-  contactMethodId: z11.string()
+var SetPrimaryContactMethodValidator = z12.object({
+  contactMethodId: z12.string()
 });
-var CreateContactMethodSessionValidator = z11.object({
+var CreateContactMethodSessionValidator = z12.object({
   contactMethod: ContactMethodVerificationRequestValidator,
-  otpChallenge: z11.string()
+  otpChallenge: z12.string()
 });
-var CreateContactMethodSessionResponseValidator = z11.object({
-  sessionJwt: z11.string()
+var CreateContactMethodSessionResponseValidator = z12.object({
+  sessionJwt: z12.string()
 });
-var InboxCredentialValidator = z11.object({
-  id: z11.string(),
-  credential: z11.string().optional(),
-  isSigned: z11.boolean(),
+var InboxCredentialValidator = z12.object({
+  refresh: InboxCredentialRefreshReceiptValidator.optional(),
+  refreshId: z12.string().optional(),
+  id: z12.string(),
+  credential: z12.string().optional(),
+  isSigned: z12.boolean(),
   currentStatus: LCNInboxStatusEnumValidator,
-  isAccepted: z11.boolean().optional(),
-  expiresAt: z11.string(),
-  createdAt: z11.string(),
-  finalizedAt: z11.string().optional(),
-  expiredAt: z11.string().optional(),
-  credentialName: z11.string().optional(),
-  achievementType: z11.string().optional(),
-  issuerDid: z11.string(),
-  webhookUrl: z11.string().optional(),
-  boostUri: z11.string().optional(),
-  activityId: z11.string().optional(),
-  integrationId: z11.string().optional(),
-  signingAuthority: z11.object({
-    endpoint: z11.string().optional(),
-    name: z11.string().optional()
+  isAccepted: z12.boolean().optional(),
+  expiresAt: z12.string(),
+  createdAt: z12.string(),
+  finalizedAt: z12.string().optional(),
+  expiredAt: z12.string().optional(),
+  credentialName: z12.string().optional(),
+  achievementType: z12.string().optional(),
+  issuerDid: z12.string(),
+  webhookUrl: z12.string().optional(),
+  boostUri: z12.string().optional(),
+  activityId: z12.string().optional(),
+  integrationId: z12.string().optional(),
+  signingAuthority: z12.object({
+    endpoint: z12.string().optional(),
+    name: z12.string().optional()
   }).optional(),
   // Guardian gate fields (all optional — absent on pre-existing credentials)
-  guardianEmail: z11.string().email().optional(),
+  guardianEmail: z12.string().email().optional(),
   guardianStatus: GuardianStatusValidator.optional(),
-  guardianApprovedAt: z11.string().optional(),
-  guardianApprovedByDid: z11.string().optional()
+  guardianApprovedAt: z12.string().optional(),
+  guardianApprovedByDid: z12.string().optional()
 });
-var PaginatedInboxCredentialsValidator = z11.object({
-  hasMore: z11.boolean(),
-  records: z11.array(InboxCredentialValidator),
-  cursor: z11.string().optional()
+var PaginatedInboxCredentialsValidator = z12.object({
+  hasMore: z12.boolean(),
+  records: z12.array(InboxCredentialValidator),
+  cursor: z12.string().optional()
 });
-var InboxCredentialQueryValidator = z11.object({
+var InboxCredentialQueryValidator = z12.object({
   currentStatus: LCNInboxStatusEnumValidator,
-  id: z11.string(),
-  isSigned: z11.boolean(),
-  isAccepted: z11.boolean().optional(),
-  issuerDid: z11.string(),
-  boostUri: z11.string()
+  id: z12.string(),
+  isSigned: z12.boolean(),
+  isAccepted: z12.boolean().optional(),
+  issuerDid: z12.string(),
+  boostUri: z12.string()
 }).partial();
-var IssueInboxSigningAuthorityValidator = z11.object({
-  endpoint: z11.string().url(),
-  name: z11.string()
+var IssueInboxSigningAuthorityValidator = z12.object({
+  endpoint: z12.string().url(),
+  name: z12.string()
 });
-var IssueInboxCredentialValidator = z11.object({
+var IssueInboxCredentialValidator = z12.object({
   // === CORE DATA (Required) ===
   // WHAT is being sent and WHO is it for?
   recipient: ContactMethodQueryValidator.describe("The recipient of the credential"),
@@ -1423,53 +1692,60 @@ var IssueInboxCredentialValidator = z11.object({
   credential: VCValidator.or(VPValidator).or(UnsignedVCValidator).optional().describe(
     "The credential to issue. If not signed, the users default signing authority will be used, or the specified signing authority in the configuration."
   ),
-  templateUri: z11.string().optional().describe(
+  templateUri: z12.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: z12.boolean().optional().describe(
+    "Allocate managed refresh before signing. Requires unsigned content and a registered signing authority; binds the holder on claim."
+  ),
+  idempotencyKey: z12.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: z11.object({
+  configuration: z12.object({
+    guardianEmail: z12.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."
     ),
-    webhookUrl: z11.string().url().optional().describe("The webhook URL to receive credential issuance events."),
-    expiresInDays: z11.number().int().min(1).max(720).optional().describe(
+    webhookUrl: z12.string().url().optional().describe("The webhook URL to receive credential issuance events."),
+    expiresInDays: z12.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: z11.record(z11.string(), z11.unknown()).optional().describe(
+    templateData: z12.record(z12.string(), z12.unknown()).optional().describe(
       "Template data to render into the boost credential template using Mustache syntax. Only used when boostUri is provided."
     ),
     // --- For User-Facing Delivery (Email/SMS) ---
-    delivery: z11.object({
-      suppress: z11.boolean().optional().default(false).describe(
+    delivery: z12.object({
+      suppress: z12.boolean().optional().default(false).describe(
         "Whether to suppress delivery of the credential to the recipient. If true, the email/sms will not be sent to the recipient. Useful if you would like to manually send claim link to your users."
       ),
-      template: z11.object({
-        id: z11.enum(["universal-inbox-claim"]).optional().describe(
+      template: z12.object({
+        id: z12.enum(["universal-inbox-claim"]).optional().describe(
           "The template ID to use for the credential delivery. If not provided, the default template will be used."
         ),
-        model: z11.object({
-          issuer: z11.object({
-            name: z11.string().optional().describe(
+        model: z12.object({
+          issuer: z12.object({
+            name: z12.string().optional().describe(
               'The name of the organization (e.g., "State University").'
             ),
-            logoUrl: z11.string().url().optional().describe(
+            logoUrl: z12.string().url().optional().describe(
               "The URL of the organization's logo."
             )
           }).optional(),
-          credential: z11.object({
-            name: z11.string().optional().describe(
+          credential: z12.object({
+            name: z12.string().optional().describe(
               'The name of the credential (e.g., "Bachelor of Science").'
             ),
-            type: z11.string().optional().describe(
+            type: z12.string().optional().describe(
               'The type of the credential (e.g., "degree", "certificate").'
             )
           }).optional(),
-          recipient: z11.object({
-            name: z11.string().optional().describe(
+          recipient: z12.object({
+            name: z12.string().optional().describe(
               'The name of the recipient (e.g., "John Doe").'
             )
           }).optional()
@@ -1485,74 +1761,187 @@ var IssueInboxCredentialValidator = z11.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"]
-});
-var IssueInboxCredentialResponseValidator = z11.object({
-  issuanceId: z11.string(),
+}).refine(
+  (data) => !data.configuration?.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 = z12.object({
+  refresh: InboxCredentialRefreshReceiptValidator.optional(),
+  issuanceId: z12.string(),
   status: LCNInboxStatusEnumValidator,
   recipient: ContactMethodQueryValidator,
-  claimUrl: z11.string().url().optional(),
-  recipientDid: z11.string().optional()
+  claimUrl: z12.string().url().optional(),
+  recipientDid: z12.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: z12.boolean().optional() }).optional()
 });
-var CredentialNameRefValidator = z11.object({ name: z11.string() }).passthrough();
-var ClaimInboxCredentialValidator = z11.object({
+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 = z12.object({
+  ...IssueInboxCredentialValidator.shape,
+  configuration: InboxBatchItemConfigurationValidator.optional(),
+  idempotencyKey: z12.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."
+);
+var IssueInboxCredentialBatchValidator = z12.object({
+  requestId: z12.string().min(1).max(256).optional(),
+  items: z12.array(IssueInboxCredentialBatchItemValidator).min(1).max(100),
+  configuration: InboxBatchConfigurationValidator.optional()
+}).superRefine((batch, ctx) => {
+  batch.items.forEach((item, index) => {
+    const itemGuardian = item.configuration?.guardianEmail;
+    const guardian = itemGuardian === null ? void 0 : itemGuardian ?? batch.configuration?.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 = z12.enum([
+  "DUPLICATE_KEY",
+  "IDEMPOTENCY_MISMATCH",
+  "IN_PROGRESS",
+  "UNCONFIRMED"
+]);
+var IssueInboxCredentialBatchItemResultValidator = z12.discriminatedUnion("success", [
+  IssueInboxCredentialResponseValidator.extend({
+    success: z12.literal(true),
+    index: z12.number().int().nonnegative(),
+    deduplicated: z12.boolean().optional(),
+    guardianStatus: GuardianStatusValidator.optional(),
+    idempotencyKey: z12.string().optional()
+  }),
+  z12.object({
+    success: z12.literal(false),
+    index: z12.number().int().nonnegative(),
+    idempotencyKey: z12.string().optional(),
+    recipient: ContactMethodQueryValidator.optional(),
+    error: z12.object({
+      code: z12.string(),
+      message: z12.string(),
+      reason: InboxBatchErrorReasonValidator.optional()
+    }),
+    issuanceId: z12.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: z12.string().url().optional().describe(
+      "Claim URL of the completed issuance, if available, when replay storage could not be confirmed."
+    )
+  })
+]);
+var IssueInboxCredentialBatchResponseValidator = z12.object({
+  results: z12.array(IssueInboxCredentialBatchItemResultValidator),
+  summary: z12.object({
+    total: z12.number(),
+    succeeded: z12.number(),
+    failed: z12.number(),
+    deduplicated: z12.number()
+  })
+});
+var InboxBatchReceiptValidator = z12.object({
+  batchId: z12.string(),
+  status: z12.enum(["QUEUED", "PROCESSING", "COMPLETED", "NEEDS_RECONCILIATION"]),
+  createdAt: z12.string()
+});
+var InboxBatchStatusValidator = z12.object({
+  batchId: z12.string(),
+  createdAt: z12.string(),
+  done: z12.boolean().describe(
+    "True when no queued or processing items remain, including unconfirmed outcomes."
+  ),
+  status: z12.enum(["QUEUED", "PROCESSING", "COMPLETED", "NEEDS_RECONCILIATION"]),
+  items: z12.array(
+    z12.object({
+      index: z12.number().int().nonnegative(),
+      state: z12.enum(["QUEUED", "PROCESSING", "COMPLETED", "NEEDS_RECONCILIATION"]),
+      result: IssueInboxCredentialBatchItemResultValidator.optional()
+    })
+  ),
+  summary: IssueInboxCredentialBatchResponseValidator.shape.summary.extend({
+    completed: z12.number(),
+    pending: z12.number(),
+    unconfirmed: z12.number()
+  })
+});
+var CredentialNameRefValidator = z12.object({ name: z12.string() }).passthrough();
+var ClaimInboxCredentialValidator = z12.object({
   credential: VCValidator.or(VPValidator).or(UnsignedVCValidator).or(CredentialNameRefValidator).describe("The credential to issue, or a { name } reference to resolve a boost template."),
-  configuration: z11.object({
-    publishableKey: z11.string(),
-    expiresInDays: z11.number().int().min(1).max(720).optional().describe(
+  configuration: z12.object({
+    publishableKey: z12.string(),
+    expiresInDays: z12.number().int().min(1).max(720).optional().describe(
       "Inbox claim window in days. Defaults to 720; use a shorter window for sensitive records."
     ),
-    signingAuthorityName: z11.string().optional(),
-    listingId: z11.string().optional(),
-    listingSlug: z11.string().optional()
+    signingAuthorityName: z12.string().optional(),
+    listingId: z12.string().optional(),
+    listingSlug: z12.string().optional()
   }).optional()
 });
-var LCNDomainOrOriginValidator = z11.union([
-  z11.string().regex(
+var LCNDomainOrOriginValidator = z12.union([
+  z12.string().regex(
     /^(?:(?:[a-zA-Z0-9-]{1,63}\.)+[a-zA-Z]{2,63}|localhost|\d{1,3}(?:\.\d{1,3}){3})(?::\d{1,5})?$/,
     {
       message: "Must be a valid domain (incl. subdomains), localhost, or IPv4, optionally with port"
     }
   ),
-  z11.string().regex(
+  z12.string().regex(
     /^https?:\/\/(?:(?:[a-zA-Z0-9-]{1,63}\.)+[a-zA-Z]{2,63}|localhost|\d{1,3}(?:\.\d{1,3}){3})(?::\d{1,5})?$/,
     { message: "Must be a valid http(s) origin" }
   )
 ]);
-var LCNIntegrationStatusEnum = z11.enum(["setup", "active", "paused"]);
-var LCNIntegrationValidator = z11.object({
-  id: z11.string(),
-  name: z11.string(),
-  description: z11.string().optional(),
-  publishableKey: z11.string(),
-  whitelistedDomains: z11.array(LCNDomainOrOriginValidator).default([]),
+var LCNIntegrationStatusEnum = z12.enum(["setup", "active", "paused"]);
+var LCNIntegrationValidator = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  description: z12.string().optional(),
+  publishableKey: z12.string(),
+  whitelistedDomains: z12.array(LCNDomainOrOriginValidator).default([]),
   // Setup/onboarding status
   status: LCNIntegrationStatusEnum.default("setup"),
-  guideType: z11.string().optional(),
-  guideState: z11.record(z11.string(), z11.any()).optional(),
+  guideType: z12.string().optional(),
+  guideState: z12.record(z12.string(), z12.any()).optional(),
   // Timestamps
-  createdAt: z11.string().optional(),
-  updatedAt: z11.string().optional()
-});
-var LCNIntegrationCreateValidator = z11.object({
-  name: z11.string(),
-  description: z11.string().optional(),
-  whitelistedDomains: z11.array(LCNDomainOrOriginValidator).default([]),
-  guideType: z11.string().optional()
-});
-var LCNIntegrationUpdateValidator = z11.object({
-  name: z11.string().optional(),
-  description: z11.string().optional(),
-  whitelistedDomains: z11.array(LCNDomainOrOriginValidator).optional(),
-  rotatePublishableKey: z11.boolean().optional(),
+  createdAt: z12.string().optional(),
+  updatedAt: z12.string().optional()
+});
+var LCNIntegrationCreateValidator = z12.object({
+  name: z12.string(),
+  description: z12.string().optional(),
+  whitelistedDomains: z12.array(LCNDomainOrOriginValidator).default([]),
+  guideType: z12.string().optional()
+});
+var LCNIntegrationUpdateValidator = z12.object({
+  name: z12.string().optional(),
+  description: z12.string().optional(),
+  whitelistedDomains: z12.array(LCNDomainOrOriginValidator).optional(),
+  rotatePublishableKey: z12.boolean().optional(),
   // Setup/onboarding updates
   status: LCNIntegrationStatusEnum.optional(),
-  guideType: z11.string().optional(),
-  guideState: z11.record(z11.string(), z11.any()).optional()
+  guideType: z12.string().optional(),
+  guideState: z12.record(z12.string(), z12.any()).optional()
 });
-var LCNIntegrationQueryValidator = z11.object({
+var LCNIntegrationQueryValidator = z12.object({
   id: StringQuery,
   name: StringQuery,
   description: StringQuery,
@@ -1562,117 +1951,117 @@ var LCNIntegrationQueryValidator = z11.object({
 var PaginatedLCNIntegrationsValidator = PaginationResponseValidator.extend({
   records: LCNIntegrationValidator.array()
 });
-var ClaimTokenValidator = z11.object({
-  token: z11.string(),
-  contactMethodId: z11.string(),
-  autoVerifyContactMethod: z11.boolean().optional().default(false),
-  createdAt: z11.string(),
-  expiresAt: z11.string(),
-  used: z11.boolean()
-});
-var TagValidator = z11.object({
-  id: z11.string(),
-  name: z11.string().min(1),
-  slug: z11.string().min(1),
-  createdAt: z11.string().optional(),
-  updatedAt: z11.string().optional()
-});
-var SkillStatusEnum = z11.enum(["active", "archived"]);
-var SkillValidator = z11.object({
-  id: z11.string(),
-  statement: z11.string(),
-  description: z11.string().optional(),
-  code: z11.string().optional(),
-  icon: z11.string().optional(),
-  type: z11.string().default("skill"),
+var ClaimTokenValidator = z12.object({
+  token: z12.string(),
+  contactMethodId: z12.string(),
+  autoVerifyContactMethod: z12.boolean().optional().default(false),
+  createdAt: z12.string(),
+  expiresAt: z12.string(),
+  used: z12.boolean()
+});
+var TagValidator = z12.object({
+  id: z12.string(),
+  name: z12.string().min(1),
+  slug: z12.string().min(1),
+  createdAt: z12.string().optional(),
+  updatedAt: z12.string().optional()
+});
+var SkillStatusEnum = z12.enum(["active", "archived"]);
+var SkillValidator = z12.object({
+  id: z12.string(),
+  statement: z12.string(),
+  description: z12.string().optional(),
+  code: z12.string().optional(),
+  icon: z12.string().optional(),
+  type: z12.string().default("skill"),
   status: SkillStatusEnum.default("active"),
-  frameworkId: z11.string().optional(),
-  createdAt: z11.string().optional(),
-  updatedAt: z11.string().optional()
+  frameworkId: z12.string().optional(),
+  createdAt: z12.string().optional(),
+  updatedAt: z12.string().optional()
 });
-var BaseSkillQueryValidator = z11.object({
+var BaseSkillQueryValidator = z12.object({
   id: StringQuery,
   statement: StringQuery,
   description: StringQuery,
   code: StringQuery,
   type: StringQuery,
-  status: SkillStatusEnum.or(z11.object({ $in: SkillStatusEnum.array() }))
+  status: SkillStatusEnum.or(z12.object({ $in: SkillStatusEnum.array() }))
 }).partial();
-var SkillQueryValidator = z11.union([
-  z11.object({
+var SkillQueryValidator = z12.union([
+  z12.object({
     $or: BaseSkillQueryValidator.array()
   }),
   BaseSkillQueryValidator
 ]);
-var SkillSemanticSearchInputValidator = z11.object({
-  text: z11.string().min(1),
-  frameworkId: z11.string().optional(),
-  limit: z11.number().int().min(1).max(200).default(50)
+var SkillSemanticSearchInputValidator = z12.object({
+  text: z12.string().min(1),
+  frameworkId: z12.string().optional(),
+  limit: z12.number().int().min(1).max(200).default(50)
 });
 var SkillSemanticSearchResultItemValidator = SkillValidator.extend({
-  score: z11.number()
+  score: z12.number()
 });
-var SkillSemanticSearchResultValidator = z11.object({
+var SkillSemanticSearchResultValidator = z12.object({
   records: SkillSemanticSearchResultItemValidator.array()
 });
-var SkillFrameworkStatusEnum = z11.enum(["active", "archived"]);
-var SkillFrameworkValidator = z11.object({
-  id: z11.string(),
-  name: z11.string(),
-  description: z11.string().optional(),
-  image: z11.string().optional(),
-  sourceURI: z11.string().url().optional(),
-  isPublic: z11.boolean().default(false),
+var SkillFrameworkStatusEnum = z12.enum(["active", "archived"]);
+var SkillFrameworkValidator = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  description: z12.string().optional(),
+  image: z12.string().optional(),
+  sourceURI: z12.string().url().optional(),
+  isPublic: z12.boolean().default(false),
   status: SkillFrameworkStatusEnum.default("active"),
-  createdAt: z11.string().optional(),
-  updatedAt: z11.string().optional()
+  createdAt: z12.string().optional(),
+  updatedAt: z12.string().optional()
 });
 var PaginatedSkillFrameworksValidator = PaginationResponseValidator.extend({
   records: SkillFrameworkValidator.array()
 });
 var SkillTreeNodeValidator = SkillValidator.extend({
-  children: z11.array(z11.lazy(() => SkillTreeNodeValidator)),
-  hasChildren: z11.boolean(),
-  childrenCursor: z11.string().nullable().optional()
-});
-var PaginatedSkillTreeValidator = z11.object({
-  hasMore: z11.boolean(),
-  cursor: z11.string().nullable(),
-  records: z11.array(SkillTreeNodeValidator)
-});
-var SkillTreeNodeInputValidator = z11.lazy(
-  () => z11.object({
-    id: z11.string().optional(),
-    statement: z11.string(),
-    description: z11.string().optional(),
-    code: z11.string().optional(),
-    icon: z11.string().optional(),
-    type: z11.string().optional(),
+  children: z12.array(z12.lazy(() => SkillTreeNodeValidator)),
+  hasChildren: z12.boolean(),
+  childrenCursor: z12.string().nullable().optional()
+});
+var PaginatedSkillTreeValidator = z12.object({
+  hasMore: z12.boolean(),
+  cursor: z12.string().nullable(),
+  records: z12.array(SkillTreeNodeValidator)
+});
+var SkillTreeNodeInputValidator = z12.lazy(
+  () => z12.object({
+    id: z12.string().optional(),
+    statement: z12.string(),
+    description: z12.string().optional(),
+    code: z12.string().optional(),
+    icon: z12.string().optional(),
+    type: z12.string().optional(),
     status: SkillStatusEnum.optional(),
-    children: z11.array(SkillTreeNodeInputValidator).optional()
+    children: z12.array(SkillTreeNodeInputValidator).optional()
   })
 );
-var LinkProviderFrameworkInputValidator = z11.object({
-  frameworkId: z11.string()
-});
-var CreateManagedFrameworkInputValidator = z11.object({
-  id: z11.string().optional(),
-  name: z11.string().min(1),
-  description: z11.string().optional(),
-  image: z11.string().optional(),
-  sourceURI: z11.string().url().optional(),
-  isPublic: z11.boolean().optional(),
+var LinkProviderFrameworkInputValidator = z12.object({
+  frameworkId: z12.string()
+});
+var CreateManagedFrameworkInputValidator = z12.object({
+  id: z12.string().optional(),
+  name: z12.string().min(1),
+  description: z12.string().optional(),
+  image: z12.string().optional(),
+  sourceURI: z12.string().url().optional(),
+  isPublic: z12.boolean().optional(),
   status: SkillFrameworkStatusEnum.optional(),
-  skills: z11.array(SkillTreeNodeInputValidator).optional(),
-  boostUris: z11.array(z11.string()).optional()
-});
-var UpdateFrameworkInputValidator = z11.object({
-  id: z11.string(),
-  name: z11.string().min(1).optional(),
-  description: z11.string().optional(),
-  image: z11.string().optional(),
-  sourceURI: z11.string().url().optional(),
-  isPublic: z11.boolean().optional(),
+  skills: z12.array(SkillTreeNodeInputValidator).optional(),
+  boostUris: z12.array(z12.string()).optional()
+});
+var UpdateFrameworkInputValidator = z12.object({
+  id: z12.string(),
+  name: z12.string().min(1).optional(),
+  description: z12.string().optional(),
+  image: z12.string().optional(),
+  sourceURI: z12.string().url().optional(),
+  isPublic: z12.boolean().optional(),
   status: SkillFrameworkStatusEnum.optional()
 }).refine(
   (data) => data.name !== void 0 || data.description !== void 0 || data.image !== void 0 || data.sourceURI !== void 0 || data.isPublic !== void 0 || data.status !== void 0,
@@ -1681,38 +2070,38 @@ var UpdateFrameworkInputValidator = z11.object({
     path: ["name"]
   }
 );
-var DeleteFrameworkInputValidator = z11.object({ id: z11.string() });
-var CreateManagedFrameworkBatchInputValidator = z11.object({
-  frameworks: z11.array(
+var DeleteFrameworkInputValidator = z12.object({ id: z12.string() });
+var CreateManagedFrameworkBatchInputValidator = z12.object({
+  frameworks: z12.array(
     CreateManagedFrameworkInputValidator.extend({
-      skills: z11.array(SkillTreeNodeInputValidator).optional()
+      skills: z12.array(SkillTreeNodeInputValidator).optional()
     })
   ).min(1)
 });
-var SkillFrameworkAdminInputValidator = z11.object({
-  frameworkId: z11.string(),
-  profileId: z11.string()
+var SkillFrameworkAdminInputValidator = z12.object({
+  frameworkId: z12.string(),
+  profileId: z12.string()
 });
-var SkillFrameworkIdInputValidator = z11.object({ frameworkId: z11.string() });
+var SkillFrameworkIdInputValidator = z12.object({ frameworkId: z12.string() });
 var SkillFrameworkAdminsValidator = LCNProfileValidator.array();
-var SyncFrameworkInputValidator = z11.object({ id: z11.string() });
-var AddTagInputValidator = z11.object({
-  slug: z11.string().min(1),
-  name: z11.string().min(1)
+var SyncFrameworkInputValidator = z12.object({ id: z12.string() });
+var AddTagInputValidator = z12.object({
+  slug: z12.string().min(1),
+  name: z12.string().min(1)
 });
-var CreateSkillInputValidator = z11.object({
-  frameworkId: z11.string(),
+var CreateSkillInputValidator = z12.object({
+  frameworkId: z12.string(),
   skill: SkillTreeNodeInputValidator,
-  parentId: z11.string().nullable().optional()
-});
-var UpdateSkillInputValidator = z11.object({
-  frameworkId: z11.string(),
-  id: z11.string(),
-  statement: z11.string().optional(),
-  description: z11.string().optional(),
-  code: z11.string().optional(),
-  icon: z11.string().optional(),
-  type: z11.string().optional(),
+  parentId: z12.string().nullable().optional()
+});
+var UpdateSkillInputValidator = z12.object({
+  frameworkId: z12.string(),
+  id: z12.string(),
+  statement: z12.string().optional(),
+  description: z12.string().optional(),
+  code: z12.string().optional(),
+  icon: z12.string().optional(),
+  type: z12.string().optional(),
   status: SkillStatusEnum.optional()
 }).refine(
   (data) => data.statement !== void 0 || data.description !== void 0 || data.code !== void 0 || data.icon !== void 0 || data.type !== void 0 || data.status !== void 0,
@@ -1721,56 +2110,56 @@ var UpdateSkillInputValidator = z11.object({
     path: ["statement"]
   }
 );
-var SkillDeletionStrategyValidator = z11.enum(["recursive", "reparent"]);
-var DeleteSkillInputValidator = z11.object({
-  frameworkId: z11.string(),
-  id: z11.string(),
+var SkillDeletionStrategyValidator = z12.enum(["recursive", "reparent"]);
+var DeleteSkillInputValidator = z12.object({
+  frameworkId: z12.string(),
+  id: z12.string(),
   strategy: SkillDeletionStrategyValidator.optional().default("reparent")
 });
-var CreateSkillsBatchInputValidator = z11.object({
-  frameworkId: z11.string(),
-  skills: z11.array(SkillTreeNodeInputValidator).min(1),
-  parentId: z11.string().nullable().optional()
+var CreateSkillsBatchInputValidator = z12.object({
+  frameworkId: z12.string(),
+  skills: z12.array(SkillTreeNodeInputValidator).min(1),
+  parentId: z12.string().nullable().optional()
 });
-var ReplaceSkillFrameworkSkillsInputValidator = z11.object({
-  frameworkId: z11.string(),
-  skills: z11.array(SkillTreeNodeInputValidator).min(0)
+var ReplaceSkillFrameworkSkillsInputValidator = z12.object({
+  frameworkId: z12.string(),
+  skills: z12.array(SkillTreeNodeInputValidator).min(0)
 });
-var ReplaceSkillFrameworkSkillsResultValidator = z11.object({
-  created: z11.number().int().min(0),
-  updated: z11.number().int().min(0),
-  deleted: z11.number().int().min(0),
-  unchanged: z11.number().int().min(0),
-  total: z11.number().int().min(0)
+var ReplaceSkillFrameworkSkillsResultValidator = z12.object({
+  created: z12.number().int().min(0),
+  updated: z12.number().int().min(0),
+  deleted: z12.number().int().min(0),
+  unchanged: z12.number().int().min(0),
+  total: z12.number().int().min(0)
 });
-var CountSkillsInputValidator = z11.object({
-  frameworkId: z11.string(),
-  skillId: z11.string().optional(),
-  recursive: z11.boolean().optional().default(false),
-  onlyCountCompetencies: z11.boolean().optional().default(false)
+var CountSkillsInputValidator = z12.object({
+  frameworkId: z12.string(),
+  skillId: z12.string().optional(),
+  recursive: z12.boolean().optional().default(false),
+  onlyCountCompetencies: z12.boolean().optional().default(false)
 });
-var CountSkillsResultValidator = z11.object({
-  count: z11.number().int().min(0)
+var CountSkillsResultValidator = z12.object({
+  count: z12.number().int().min(0)
 });
-var GetFullSkillTreeInputValidator = z11.object({
-  frameworkId: z11.string()
+var GetFullSkillTreeInputValidator = z12.object({
+  frameworkId: z12.string()
 });
-var GetFullSkillTreeResultValidator = z11.object({
-  skills: z11.array(SkillTreeNodeValidator)
+var GetFullSkillTreeResultValidator = z12.object({
+  skills: z12.array(SkillTreeNodeValidator)
 });
-var GetSkillPathInputValidator = z11.object({
-  frameworkId: z11.string(),
-  skillId: z11.string()
+var GetSkillPathInputValidator = z12.object({
+  frameworkId: z12.string(),
+  skillId: z12.string()
 });
-var GetSkillPathResultValidator = z11.object({
-  path: z11.array(SkillValidator)
+var GetSkillPathResultValidator = z12.object({
+  path: z12.array(SkillValidator)
 });
-var FrameworkWithSkillsValidator = z11.object({
+var FrameworkWithSkillsValidator = z12.object({
   framework: SkillFrameworkValidator,
   skills: PaginatedSkillTreeValidator
 });
-var AppListingStatusValidator = z11.enum(["DRAFT", "PENDING_REVIEW", "LISTED", "ARCHIVED"]);
-var LaunchTypeValidator = z11.enum([
+var AppListingStatusValidator = z12.enum(["DRAFT", "PENDING_REVIEW", "LISTED", "ARCHIVED"]);
+var LaunchTypeValidator = z12.enum([
   "EMBEDDED_IFRAME",
   "SECOND_SCREEN",
   "DIRECT_LINK",
@@ -1778,43 +2167,43 @@ var LaunchTypeValidator = z11.enum([
   "SERVER_HEADLESS",
   "AI_TUTOR"
 ]);
-var PromotionLevelValidator = z11.enum([
+var PromotionLevelValidator = z12.enum([
   "FEATURED_CAROUSEL",
   "CURATED_LIST",
   "STANDARD",
   "DEMOTED"
 ]);
-var AgeRatingValidator = z11.enum(["4+", "9+", "12+", "17+"]);
-var AppStoreListingSubmitterValidator = z11.object({
-  profileId: z11.string(),
-  displayName: z11.string(),
-  email: z11.string().optional()
-});
-var AppStoreListingValidator = z11.object({
-  listing_id: z11.string(),
-  slug: z11.string().optional(),
-  display_name: z11.string(),
-  tagline: z11.string(),
-  full_description: z11.string(),
-  icon_url: z11.string(),
+var AgeRatingValidator = z12.enum(["4+", "9+", "12+", "17+"]);
+var AppStoreListingSubmitterValidator = z12.object({
+  profileId: z12.string(),
+  displayName: z12.string(),
+  email: z12.string().optional()
+});
+var AppStoreListingValidator = z12.object({
+  listing_id: z12.string(),
+  slug: z12.string().optional(),
+  display_name: z12.string(),
+  tagline: z12.string(),
+  full_description: z12.string(),
+  icon_url: z12.string(),
   app_listing_status: AppListingStatusValidator,
   launch_type: LaunchTypeValidator,
-  launch_config_json: z11.string(),
-  category: z11.string().optional(),
-  promo_video_url: z11.string().optional(),
+  launch_config_json: z12.string(),
+  category: z12.string().optional(),
+  promo_video_url: z12.string().optional(),
   promotion_level: PromotionLevelValidator.optional(),
-  ios_app_store_id: z11.string().optional(),
-  android_app_store_id: z11.string().optional(),
-  privacy_policy_url: z11.string().optional(),
-  terms_url: z11.string().optional(),
-  highlights: z11.array(z11.string()).optional(),
-  screenshots: z11.array(z11.string()).optional(),
-  hero_background_color: z11.string().optional(),
-  min_age: z11.number().int().min(0).max(18).optional(),
+  ios_app_store_id: z12.string().optional(),
+  android_app_store_id: z12.string().optional(),
+  privacy_policy_url: z12.string().optional(),
+  terms_url: z12.string().optional(),
+  highlights: z12.array(z12.string()).optional(),
+  screenshots: z12.array(z12.string()).optional(),
+  hero_background_color: z12.string().optional(),
+  min_age: z12.number().int().min(0).max(18).optional(),
   age_rating: AgeRatingValidator.optional(),
-  submitted_at: z11.string().optional(),
+  submitted_at: z12.string().optional(),
   submitter: AppStoreListingSubmitterValidator.optional(),
-  contact_email: z11.string().email().optional()
+  contact_email: z12.string().email().optional()
 });
 var AppStoreListingCreateValidator = AppStoreListingValidator.omit({
   listing_id: true,
@@ -1827,7 +2216,7 @@ var AppStoreListingUpdateValidator = AppStoreListingValidator.partial().omit({
   promotion_level: true
 });
 var InstalledAppValidator = AppStoreListingValidator.extend({
-  installed_at: z11.string()
+  installed_at: z12.string()
 });
 var PaginatedAppStoreListingsValidator = PaginationResponseValidator.extend({
   records: AppStoreListingValidator.array()
@@ -1835,111 +2224,111 @@ var PaginatedAppStoreListingsValidator = PaginationResponseValidator.extend({
 var PaginatedInstalledAppsValidator = PaginationResponseValidator.extend({
   records: InstalledAppValidator.array()
 });
-var AppBoostValidator = z11.object({
-  templateAlias: z11.string().min(1).max(50).regex(/^[a-z0-9-]+$/),
-  boostUri: z11.string()
+var AppBoostValidator = z12.object({
+  templateAlias: z12.string().min(1).max(50).regex(/^[a-z0-9-]+$/),
+  boostUri: z12.string()
 });
-var SendCredentialEventValidator = z11.object({
-  type: z11.literal("send-credential"),
-  templateAlias: z11.string(),
-  templateData: z11.record(z11.string(), z11.unknown()).optional(),
-  preventDuplicateClaim: z11.boolean().optional()
+var SendCredentialEventValidator = z12.object({
+  type: z12.literal("send-credential"),
+  templateAlias: z12.string(),
+  templateData: z12.record(z12.string(), z12.unknown()).optional(),
+  preventDuplicateClaim: z12.boolean().optional()
 });
-var CheckCredentialEventValidator = z11.object({
-  type: z11.literal("check-credential"),
-  templateAlias: z11.string().optional(),
-  boostUri: z11.string().optional()
+var CheckCredentialEventValidator = z12.object({
+  type: z12.literal("check-credential"),
+  templateAlias: z12.string().optional(),
+  boostUri: z12.string().optional()
 }).refine((input) => Boolean(input.templateAlias) !== Boolean(input.boostUri), {
   message: "Exactly one of templateAlias or boostUri is required"
 });
-var CheckIssuanceStatusEventValidator = z11.object({
-  type: z11.literal("check-issuance-status"),
-  templateAlias: z11.string().optional(),
-  boostUri: z11.string().optional(),
-  recipient: z11.string()
+var CheckIssuanceStatusEventValidator = z12.object({
+  type: z12.literal("check-issuance-status"),
+  templateAlias: z12.string().optional(),
+  boostUri: z12.string().optional(),
+  recipient: z12.string()
 }).refine((input) => Boolean(input.templateAlias) !== Boolean(input.boostUri), {
   message: "Exactly one of templateAlias or boostUri is required"
 });
-var GetTemplateRecipientsEventValidator = z11.object({
-  type: z11.literal("get-template-recipients"),
-  templateAlias: z11.string().optional(),
-  boostUri: z11.string().optional(),
-  limit: z11.number().optional(),
-  cursor: z11.string().optional()
+var GetTemplateRecipientsEventValidator = z12.object({
+  type: z12.literal("get-template-recipients"),
+  templateAlias: z12.string().optional(),
+  boostUri: z12.string().optional(),
+  limit: z12.number().optional(),
+  cursor: z12.string().optional()
 }).refine((input) => Boolean(input.templateAlias) !== Boolean(input.boostUri), {
   message: "Exactly one of templateAlias or boostUri is required"
 });
-var RequestLearnerContextEventValidator = z11.object({
-  type: z11.literal("request-learner-context"),
-  includeCredentials: z11.boolean().optional().default(true),
-  includePersonalData: z11.boolean().optional().default(false),
-  format: z11.enum(["prompt", "structured"]).optional().default("prompt"),
-  instructions: z11.string().optional(),
-  detailLevel: z11.enum(["compact", "expanded"]).optional().default("compact"),
-  waitForSync: z11.boolean().optional().default(false)
-});
-var SummaryCredentialKeywordValidator = z11.object({
-  occupations: z11.array(z11.string()).nullable(),
-  careers: z11.array(z11.string()).nullable(),
-  jobs: z11.array(z11.string()).nullable(),
-  skills: z11.array(z11.string()).nullable(),
-  fieldOfStudy: z11.string().nullable()
-});
-var SummaryCredentialDataValidator = z11.object({
-  title: z11.string().describe("Short, concise title for the learning session or credential"),
-  summary: z11.string().describe("Comprehensive summary of what happened during the session"),
-  learned: z11.array(z11.string()).describe("Bullet points of key knowledge gained"),
-  skills: z11.array(
-    z11.object({
-      title: z11.string().describe("Name of the skill category"),
-      description: z11.string().describe("Detailed description of what this skill category involves")
+var RequestLearnerContextEventValidator = z12.object({
+  type: z12.literal("request-learner-context"),
+  includeCredentials: z12.boolean().optional().default(true),
+  includePersonalData: z12.boolean().optional().default(false),
+  format: z12.enum(["prompt", "structured"]).optional().default("prompt"),
+  instructions: z12.string().optional(),
+  detailLevel: z12.enum(["compact", "expanded"]).optional().default("compact"),
+  waitForSync: z12.boolean().optional().default(false)
+});
+var SummaryCredentialKeywordValidator = z12.object({
+  occupations: z12.array(z12.string()).nullable(),
+  careers: z12.array(z12.string()).nullable(),
+  jobs: z12.array(z12.string()).nullable(),
+  skills: z12.array(z12.string()).nullable(),
+  fieldOfStudy: z12.string().nullable()
+});
+var SummaryCredentialDataValidator = z12.object({
+  title: z12.string().describe("Short, concise title for the learning session or credential"),
+  summary: z12.string().describe("Comprehensive summary of what happened during the session"),
+  learned: z12.array(z12.string()).describe("Bullet points of key knowledge gained"),
+  skills: z12.array(
+    z12.object({
+      title: z12.string().describe("Name of the skill category"),
+      description: z12.string().describe("Detailed description of what this skill category involves")
     })
   ).describe("Categorized skills learned during the session"),
-  nextSteps: z11.array(
-    z11.object({
-      title: z11.string().describe("Title of the suggested next step"),
-      description: z11.string().describe("Description explaining why this next step is recommended"),
+  nextSteps: z12.array(
+    z12.object({
+      title: z12.string().describe("Title of the suggested next step"),
+      description: z12.string().describe("Description explaining why this next step is recommended"),
       keywords: SummaryCredentialKeywordValidator.optional().describe(
         "Optional taxonomy keywords for occupations/careers/jobs/skills/fieldOfStudy. Omit if not relevant."
       )
     })
   ).describe("Recommended follow-up activities or learning modules"),
-  reflections: z11.array(
-    z11.object({
-      title: z11.string().describe("Title of the reflection"),
-      description: z11.string().describe("Detailed description of what this reflection involves")
+  reflections: z12.array(
+    z12.object({
+      title: z12.string().describe("Title of the reflection"),
+      description: z12.string().describe("Detailed description of what this reflection involves")
     })
   ).describe("Reflections on the learning experience")
 });
-var SendAiSessionCredentialEventValidator = z11.object({
-  type: z11.literal("send-ai-session-credential"),
-  sessionTitle: z11.string(),
+var SendAiSessionCredentialEventValidator = z12.object({
+  type: z12.literal("send-ai-session-credential"),
+  sessionTitle: z12.string(),
   summaryData: SummaryCredentialDataValidator,
-  metadata: z11.record(z11.string(), z11.unknown()).optional()
-});
-var SendNotificationEventValidator = z11.object({
-  type: z11.literal("send-notification"),
-  title: z11.string().optional(),
-  body: z11.string().optional(),
-  actionPath: z11.string().optional(),
-  category: z11.string().optional(),
-  priority: z11.enum(["normal", "high"]).optional()
-});
-var counterKeyValidator = z11.string().min(1).max(64).regex(/^[a-zA-Z0-9_-]+$/, "Key must be alphanumeric with _ or -");
-var IncrementCounterEventValidator = z11.object({
-  type: z11.literal("increment-counter"),
+  metadata: z12.record(z12.string(), z12.unknown()).optional()
+});
+var SendNotificationEventValidator = z12.object({
+  type: z12.literal("send-notification"),
+  title: z12.string().optional(),
+  body: z12.string().optional(),
+  actionPath: z12.string().optional(),
+  category: z12.string().optional(),
+  priority: z12.enum(["normal", "high"]).optional()
+});
+var counterKeyValidator = z12.string().min(1).max(64).regex(/^[a-zA-Z0-9_-]+$/, "Key must be alphanumeric with _ or -");
+var IncrementCounterEventValidator = z12.object({
+  type: z12.literal("increment-counter"),
   key: counterKeyValidator,
-  amount: z11.number().int().finite()
+  amount: z12.number().int().finite()
 });
-var GetCounterEventValidator = z11.object({
-  type: z11.literal("get-counter"),
+var GetCounterEventValidator = z12.object({
+  type: z12.literal("get-counter"),
   key: counterKeyValidator
 });
-var GetCountersEventValidator = z11.object({
-  type: z11.literal("get-counters"),
-  keys: z11.array(counterKeyValidator).min(1).max(50).optional()
+var GetCountersEventValidator = z12.object({
+  type: z12.literal("get-counters"),
+  keys: z12.array(counterKeyValidator).min(1).max(50).optional()
 });
-var AppEventValidator = z11.discriminatedUnion("type", [
+var AppEventValidator = z12.discriminatedUnion("type", [
   SendCredentialEventValidator,
   CheckCredentialEventValidator,
   CheckIssuanceStatusEventValidator,
@@ -1951,20 +2340,20 @@ var AppEventValidator = z11.discriminatedUnion("type", [
   GetCounterEventValidator,
   GetCountersEventValidator
 ]);
-var AppEventInputValidator = z11.object({
-  listingId: z11.string(),
+var AppEventInputValidator = z12.object({
+  listingId: z12.string(),
   event: AppEventValidator
 });
-var AppEventResponseValidator = z11.record(z11.string(), z11.unknown());
-var CredentialActivityEventTypeValidator = z11.enum([
+var AppEventResponseValidator = z12.record(z12.string(), z12.unknown());
+var CredentialActivityEventTypeValidator = z12.enum([
   "CREATED",
   "DELIVERED",
   "CLAIMED",
   "EXPIRED",
   "FAILED"
 ]);
-var CredentialActivityRecipientTypeValidator = z11.enum(["profile", "email", "phone"]);
-var CredentialActivitySourceTypeValidator = z11.enum([
+var CredentialActivityRecipientTypeValidator = z12.enum(["profile", "email", "phone"]);
+var CredentialActivitySourceTypeValidator = z12.enum([
   "send",
   "sendBoost",
   "sendCredential",
@@ -1975,44 +2364,45 @@ var CredentialActivitySourceTypeValidator = z11.enum([
   "acceptCredential",
   "appEvent"
 ]);
-var CredentialActivityValidator = z11.object({
-  id: z11.string(),
-  activityId: z11.string(),
+var CredentialActivityValidator = z12.object({
+  id: z12.string(),
+  activityId: z12.string(),
   eventType: CredentialActivityEventTypeValidator,
-  timestamp: z11.string(),
-  actorProfileId: z11.string().optional(),
+  timestamp: z12.string(),
+  actorProfileId: z12.string().optional(),
+  onBehalfOf: z12.string().optional(),
   recipientType: CredentialActivityRecipientTypeValidator,
-  recipientIdentifier: z11.string(),
-  boostUri: z11.string().optional(),
-  credentialUri: z11.string().optional(),
-  inboxCredentialId: z11.string().optional(),
-  integrationId: z11.string().optional(),
+  recipientIdentifier: z12.string(),
+  boostUri: z12.string().optional(),
+  credentialUri: z12.string().optional(),
+  inboxCredentialId: z12.string().optional(),
+  integrationId: z12.string().optional(),
   source: CredentialActivitySourceTypeValidator,
-  metadata: z11.record(z11.string(), z11.unknown()).optional(),
-  status: z11.enum(["active", "revoked", "suspended"]).optional()
+  metadata: z12.record(z12.string(), z12.unknown()).optional(),
+  status: z12.enum(["active", "revoked", "suspended"]).optional()
 });
 var CredentialActivityWithDetailsValidator = CredentialActivityValidator.extend({
-  boost: z11.object({
-    id: z11.string(),
-    name: z11.string().optional(),
-    category: z11.string().optional()
+  boost: z12.object({
+    id: z12.string(),
+    name: z12.string().optional(),
+    category: z12.string().optional()
   }).optional(),
-  recipientProfile: z11.object({
-    profileId: z11.string(),
-    displayName: z11.string().optional()
+  recipientProfile: z12.object({
+    profileId: z12.string(),
+    displayName: z12.string().optional()
   }).optional()
 });
 var PaginatedCredentialActivitiesValidator = PaginationResponseValidator.extend({
   records: CredentialActivityWithDetailsValidator.array()
 });
-var CredentialActivityStatsValidator = z11.object({
-  total: z11.number(),
-  created: z11.number(),
-  delivered: z11.number(),
-  claimed: z11.number(),
-  expired: z11.number(),
-  failed: z11.number(),
-  claimRate: z11.number()
+var CredentialActivityStatsValidator = z12.object({
+  total: z12.number(),
+  created: z12.number(),
+  delivered: z12.number(),
+  claimed: z12.number(),
+  expired: z12.number(),
+  failed: z12.number(),
+  claimRate: z12.number()
 });
 
 // src/auth.ts
@@ -2028,313 +2418,126 @@ var AuthSessionError = class extends Error {
 };
 
 // src/bitstring-status-list.ts
-import { z as z12 } from "zod/v4";
+import { z as z13 } from "zod/v4";
 var BITSTRING_STATUS_PURPOSES = ["revocation", "suspension"];
 var DEFAULT_BITSTRING_STATUS_LIST_SIZE = 131072;
-var BitstringStatusPurposeValidator = z12.enum(BITSTRING_STATUS_PURPOSES);
-var BitstringStatusListEntryValidator = z12.object({
-  id: z12.string().optional(),
-  type: z12.literal("BitstringStatusListEntry"),
+var BitstringStatusPurposeValidator = z13.enum(BITSTRING_STATUS_PURPOSES);
+var BitstringStatusListEntryValidator = z13.object({
+  id: z13.string().optional(),
+  type: z13.literal("BitstringStatusListEntry"),
   statusPurpose: BitstringStatusPurposeValidator,
-  statusListIndex: z12.string().or(z12.number().int().nonnegative()),
-  statusListCredential: z12.string()
+  statusListIndex: z13.string().or(z13.number().int().nonnegative()),
+  statusListCredential: z13.string()
 });
 var AllocatedBitstringStatusListEntryValidator = BitstringStatusListEntryValidator.extend({
-  id: z12.string()
+  id: z13.string()
 });
-var BitstringStatusListCredentialSubjectValidator = z12.object({
-  id: z12.string().optional(),
-  type: z12.literal("BitstringStatusList"),
+var BitstringStatusListCredentialSubjectValidator = z13.object({
+  id: z13.string().optional(),
+  type: z13.literal("BitstringStatusList"),
   statusPurpose: BitstringStatusPurposeValidator,
-  encodedList: z12.string()
+  encodedList: z13.string()
 });
-var AllocateCredentialStatusInputValidator = z12.object({
-  statusPurposes: z12.array(BitstringStatusPurposeValidator).optional(),
-  listSize: z12.number().int().positive().optional()
+var AllocateCredentialStatusInputValidator = z13.object({
+  statusPurposes: z13.array(BitstringStatusPurposeValidator).optional(),
+  listSize: z13.number().int().positive().optional()
 }).default({});
 
 // src/inAppMessages.ts
-import { z as z13 } from "zod";
-var inAppMessagePlatformValidator = z13.enum(["ios", "android", "web"]);
-var inAppMessageVersionSourceValidator = z13.enum(["native", "web", "capgo"]);
-var inAppMessageVersionOpValidator = z13.enum(["lt", "lte", "eq", "gte", "gt"]);
-var platformPredicateValidator = z13.object({ platform: z13.array(inAppMessagePlatformValidator).nonempty() }).strict();
-var rolePredicateValidator = z13.object({ role: z13.array(z13.string()).nonempty() }).strict();
-var versionPredicateValidator = z13.object({
-  version: z13.object({
+import { z as z14 } from "zod";
+var inAppMessagePlatformValidator = z14.enum(["ios", "android", "web"]);
+var inAppMessageVersionSourceValidator = z14.enum(["native", "web", "capgo"]);
+var inAppMessageVersionOpValidator = z14.enum(["lt", "lte", "eq", "gte", "gt"]);
+var platformPredicateValidator = z14.object({ platform: z14.array(inAppMessagePlatformValidator).nonempty() }).strict();
+var rolePredicateValidator = z14.object({ role: z14.array(z14.string()).nonempty() }).strict();
+var versionPredicateValidator = z14.object({
+  version: z14.object({
     source: inAppMessageVersionSourceValidator,
     op: inAppMessageVersionOpValidator,
-    value: z13.string()
+    value: z14.string()
   }).strict()
 }).strict();
-var inAppMessagePredicateValidator = z13.lazy(
-  () => z13.union([
+var inAppMessagePredicateValidator = z14.lazy(
+  () => z14.union([
     platformPredicateValidator,
     rolePredicateValidator,
     versionPredicateValidator,
-    z13.object({ all: z13.array(inAppMessagePredicateValidator) }).strict(),
-    z13.object({ any: z13.array(inAppMessagePredicateValidator) }).strict(),
-    z13.object({ not: inAppMessagePredicateValidator }).strict()
+    z14.object({ all: z14.array(inAppMessagePredicateValidator) }).strict(),
+    z14.object({ any: z14.array(inAppMessagePredicateValidator) }).strict(),
+    z14.object({ not: inAppMessagePredicateValidator }).strict()
   ])
 );
-var inAppMessageActionStyleValidator = z13.enum(["primary", "secondary", "positive", "dismiss"]).default("secondary");
-var internalLinkActionValidator = z13.object({ type: z13.literal("internalLink"), path: z13.string() }).passthrough();
-var externalLinkActionValidator = z13.object({ type: z13.literal("externalLink"), url: z13.string() }).passthrough();
-var appStoreActionValidator = z13.object({
-  type: z13.literal("appStore"),
-  iosUrl: z13.string().optional(),
-  androidUrl: z13.string().optional(),
-  webUrl: z13.string().optional()
+var inAppMessageActionStyleValidator = z14.enum(["primary", "secondary", "positive", "dismiss"]).default("secondary");
+var internalLinkActionValidator = z14.object({ type: z14.literal("internalLink"), path: z14.string() }).passthrough();
+var externalLinkActionValidator = z14.object({ type: z14.literal("externalLink"), url: z14.string() }).passthrough();
+var appStoreActionValidator = z14.object({
+  type: z14.literal("appStore"),
+  iosUrl: z14.string().optional(),
+  androidUrl: z14.string().optional(),
+  webUrl: z14.string().optional()
 }).passthrough();
-var capgoUpdateActionValidator = z13.object({ type: z13.literal("capgoUpdate") }).passthrough();
-var dismissActionValidator = z13.object({ type: z13.literal("dismiss") }).passthrough();
-var inAppMessageActionTargetValidator = z13.union([
+var capgoUpdateActionValidator = z14.object({ type: z14.literal("capgoUpdate") }).passthrough();
+var dismissActionValidator = z14.object({ type: z14.literal("dismiss") }).passthrough();
+var inAppMessageActionTargetValidator = z14.union([
   internalLinkActionValidator,
   externalLinkActionValidator,
   appStoreActionValidator,
   capgoUpdateActionValidator,
   dismissActionValidator
 ]);
-var inAppMessageActionValidator = z13.object({
-  label: z13.string(),
+var inAppMessageActionValidator = z14.object({
+  label: z14.string(),
   style: inAppMessageActionStyleValidator,
   action: inAppMessageActionTargetValidator,
   /** When true, the message closes after this action runs (default true). */
-  closeOnComplete: z13.boolean().default(true)
+  closeOnComplete: z14.boolean().default(true)
 }).passthrough();
-var inAppMessageMediaValidator = z13.object({
-  type: z13.enum(["youtube", "image", "gif"]),
-  url: z13.string(),
+var inAppMessageMediaValidator = z14.object({
+  type: z14.enum(["youtube", "image", "gif"]),
+  url: z14.string(),
   /** Aspect ratio hint, e.g. "16:9" or "1:1". Defaults to 16:9. */
-  aspect: z13.string().default("16:9"),
+  aspect: z14.string().default("16:9"),
   /** Alt text for images/gifs (accessibility). */
-  alt: z13.string().optional()
+  alt: z14.string().optional()
 }).passthrough();
-var inAppMessageFrequencyValidator = z13.union([
-  z13.literal("once"),
-  z13.literal("session"),
-  z13.literal("always"),
-  z13.object({ everyDays: z13.number().positive() }).strict()
+var inAppMessageFrequencyValidator = z14.union([
+  z14.literal("once"),
+  z14.literal("session"),
+  z14.literal("always"),
+  z14.object({ everyDays: z14.number().positive() }).strict()
 ]).default("once");
-var inAppMessagePresentationValidator = z13.enum(["modal", "banner", "toast"]).default("modal");
-var inAppMessageValidator = z13.object({
+var inAppMessagePresentationValidator = z14.enum(["modal", "banner", "toast"]).default("modal");
+var inAppMessageValidator = z14.object({
   /** Stable identifier — used to persist dismissal / frequency state. */
-  id: z13.string(),
+  id: z14.string(),
   /** Higher priority wins when multiple messages match. Default 0. */
-  priority: z13.number().default(0),
+  priority: z14.number().default(0),
   /** When false, the message is required/blocking (no dismiss affordance). */
-  dismissible: z13.boolean().default(true),
+  dismissible: z14.boolean().default(true),
   frequency: inAppMessageFrequencyValidator,
   presentation: inAppMessagePresentationValidator,
   media: inAppMessageMediaValidator.optional(),
   /** Optional emoji hero glyph — rendered only when `media` is not set. */
-  emoji: z13.string().optional(),
-  title: z13.string(),
-  body: z13.string().optional(),
-  actions: z13.array(inAppMessageActionValidator).default([]),
+  emoji: z14.string().optional(),
+  title: z14.string(),
+  body: z14.string().optional(),
+  actions: z14.array(inAppMessageActionValidator).default([]),
   /** Targeting predicate tree. Omitted → matches everyone. */
   targeting: inAppMessagePredicateValidator.optional(),
   /** Allow disabling a message without removing it from the flag. */
-  enabled: z13.boolean().default(true)
+  enabled: z14.boolean().default(true)
 }).passthrough();
-var inAppMessagesFlagValidator = z13.object({
-  version: z13.number().default(1),
-  messages: z13.array(inAppMessageValidator).default([])
+var inAppMessagesFlagValidator = z14.object({
+  version: z14.number().default(1),
+  messages: z14.array(inAppMessageValidator).default([])
 }).passthrough();
 var EMPTY_IN_APP_MESSAGES_FLAG = { version: 1, messages: [] };
 var parseInAppMessagesFlag = /* @__PURE__ */ __name((raw) => {
   const result = inAppMessagesFlagValidator.safeParse(raw);
   return result.success ? result.data : EMPTY_IN_APP_MESSAGES_FLAG;
 }, "parseInAppMessagesFlag");
-
-// src/credential-refresh.ts
-import { z as z14 } from "zod/v4";
-var LearnCardRefreshAuthorizationValidator = z14.object({ type: z14.literal("LearnCardDIDAuth") }).catchall(z14.any());
-var ManagedCredentialRefreshServiceValidator = z14.object({
-  id: z14.string().min(1),
-  type: z14.literal("LearnCardCredentialRefresh2026"),
-  authorization: LearnCardRefreshAuthorizationValidator.optional()
-}).catchall(z14.any());
-var StandardCredentialRefreshServiceValidator = z14.object({
-  id: z14.string().min(1),
-  type: z14.literal("1EdTechCredentialRefresh")
-}).catchall(z14.any());
-var SupportedCredentialRefreshServiceValidator = z14.union([
-  ManagedCredentialRefreshServiceValidator,
-  StandardCredentialRefreshServiceValidator
-]);
-var AllocateCredentialRefreshInputValidator = z14.object({
-  holder: z14.object({
-    profileId: z14.string().optional(),
-    did: z14.string().min(1)
-  }),
-  credentialId: z14.string().min(1)
-});
-var AllocateCredentialRefreshResultValidator = z14.object({
-  refreshId: z14.string().min(1),
-  refreshService: ManagedCredentialRefreshServiceValidator.extend({
-    authorization: LearnCardRefreshAuthorizationValidator
-  })
-});
-var CredentialRefreshSigningModeValidator = z14.enum(["issuer-signed", "signing-authority"]);
-var PublishCredentialRefreshBaseFields = {
-  refreshId: z14.string().min(1),
-  notifyHolder: z14.boolean().optional(),
-  updateSummary: z14.string().optional(),
-  idempotencyKey: z14.string().optional()
-};
-var PublishIssuerSignedRefreshValidator = z14.object({
-  ...PublishCredentialRefreshBaseFields,
-  mode: z14.literal("issuer-signed"),
-  signedCredential: VCValidator
-});
-var PublishSigningAuthorityRefreshValidator = z14.object({
-  ...PublishCredentialRefreshBaseFields,
-  mode: z14.literal("signing-authority"),
-  credential: UnsignedVCValidator,
-  signingAuthority: z14.object({
-    type: z14.string().min(1)
-  }).catchall(z14.any())
-});
-var PublishCredentialRefreshInputValidator = z14.object({
-  ...PublishCredentialRefreshBaseFields,
-  mode: CredentialRefreshSigningModeValidator,
-  signedCredential: VCValidator.optional(),
-  credential: UnsignedVCValidator.optional(),
-  signingAuthority: z14.object({
-    type: z14.string().min(1)
-  }).catchall(z14.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 = z14.enum([
-  "queued",
-  "suppressed",
-  "not-applicable",
-  /** Publication succeeded, but the post-commit notification enqueue must be retried. */
-  "delivery-failed"
-]);
-var PublishCredentialRefreshResultValidator = z14.object({
-  refreshId: z14.string().min(1),
-  version: z14.number().int().positive(),
-  publishedAt: z14.string().min(1),
-  notification: PublishCredentialRefreshNotificationValidator
-});
-var CredentialRefreshVersionMetadataValidator = z14.object({
-  version: z14.number().int().positive(),
-  publishedAt: z14.string().min(1),
-  effectiveAt: z14.string().optional(),
-  etag: z14.string().optional(),
-  signingMode: CredentialRefreshSigningModeValidator.optional(),
-  updateSummary: z14.string().optional()
-});
-var GetCredentialRefreshHistoryInputValidator = z14.object({
-  refreshId: z14.string().min(1),
-  cursor: z14.string().optional(),
-  limit: z14.number().int().positive().optional()
-});
-var GetCredentialRefreshHistoryResultValidator = z14.object({
-  records: CredentialRefreshVersionMetadataValidator.array(),
-  hasMore: z14.boolean(),
-  cursor: z14.string().optional()
-});
-var CredentialRefreshChallengeValidator = z14.object({
-  challenge: z14.string().min(1),
-  expiresAt: z14.string().min(1),
-  domain: z14.string().optional(),
-  scheme: z14.literal("LearnCardDIDAuth").optional()
-});
-var PublicCredentialRefreshEnvelopeValidator = z14.object({
-  format: z14.literal("vc"),
-  credential: VCValidator,
-  etag: z14.string().optional()
-});
-var JweCredentialRefreshEnvelopeValidator = z14.object({
-  format: z14.literal("jwe"),
-  jwe: JWEValidator,
-  etag: z14.string().optional(),
-  /** Present on LearnCard-managed endpoints; optional for interoperable JWE services. */
-  version: z14.number().int().positive().optional()
-});
-var CredentialRefreshResponseEnvelopeValidator = z14.discriminatedUnion("format", [
-  PublicCredentialRefreshEnvelopeValidator,
-  JweCredentialRefreshEnvelopeValidator
-]);
-var CredentialRefreshFailureCodeValidator = z14.enum([
-  "UNAVAILABLE",
-  "TIMEOUT",
-  "UNSUPPORTED_SERVICE",
-  "UNAUTHORIZED",
-  "MALFORMED_RESPONSE",
-  "INVALID_PROOF",
-  "ISSUER_MISMATCH",
-  "ID_MISMATCH",
-  "ROLLBACK",
-  "REVOKED",
-  "UNSAFE_ENDPOINT"
-]);
-var CredentialRefreshUpdatedResultValidator = z14.object({
-  status: z14.literal("updated"),
-  credential: VCValidator,
-  etag: z14.string().optional(),
-  managedVersion: z14.number().int().positive().optional()
-});
-var CredentialRefreshUnchangedResultValidator = z14.object({
-  status: z14.literal("unchanged"),
-  checkedAt: z14.string().min(1),
-  etag: z14.string().optional()
-});
-var CredentialRefreshUnsupportedResultValidator = z14.object({
-  status: z14.literal("unsupported")
-});
-var CredentialRefreshFailedResultValidator = z14.object({
-  status: z14.literal("failed"),
-  code: CredentialRefreshFailureCodeValidator,
-  retryable: z14.boolean()
-});
-var CredentialRefreshResultValidator = z14.discriminatedUnion("status", [
-  CredentialRefreshUpdatedResultValidator,
-  CredentialRefreshUnchangedResultValidator,
-  CredentialRefreshUnsupportedResultValidator,
-  CredentialRefreshFailedResultValidator
-]);
 export {
+  ACT_AS_HEADER,
   AUTH_GRANT_AUDIENCE_DOMAIN_PREFIX,
   AchievementCredentialValidator,
   AchievementCriteriaValidator,
@@ -2397,6 +2600,7 @@ export {
   ConsentFlowContractValidator,
   ConsentFlowDataForDidQueryValidator,
   ConsentFlowDataQueryValidator,
+  ConsentFlowGuardianApprovalValidator,
   ConsentFlowTermValidator,
   ConsentFlowTermsQueryValidator,
   ConsentFlowTermsStatusValidator,
@@ -2473,10 +2677,18 @@ export {
   IdentifierTypeValidator,
   IdentityObjectValidator,
   ImageValidator,
+  InboxBatchErrorReasonValidator,
+  InboxBatchReceiptValidator,
+  InboxBatchStatusValidator,
   InboxCredentialQueryValidator,
+  InboxCredentialRefreshReceiptValidator,
   InboxCredentialValidator,
   IncrementCounterEventValidator,
   InstalledAppValidator,
+  IssueInboxCredentialBatchItemResultValidator,
+  IssueInboxCredentialBatchItemValidator,
+  IssueInboxCredentialBatchResponseValidator,
+  IssueInboxCredentialBatchValidator,
   IssueInboxCredentialResponseValidator,
   IssueInboxCredentialValidator,
   IssueInboxSigningAuthorityValidator,
@@ -2525,6 +2737,7 @@ export {
   LaunchTypeValidator,
   LearnCardRefreshAuthorizationValidator,
   LinkProviderFrameworkInputValidator,
+  ManagedCredentialRefreshReceiptValidator,
   ManagedCredentialRefreshServiceValidator,
   PaginatedAppStoreListingsValidator,
   PaginatedBoostRecipientsValidator,
@@ -2551,6 +2764,8 @@ export {
   PaginatedVisibleLCNProfilesValidator,
   PaginationOptionsValidator,
   PaginationResponseValidator,
+  PrepareRefreshableSendInputValidator,
+  PrepareRefreshableSendResultValidator,
   ProfileValidator,
   ProfileVisibilityEnum,
   PromotionLevelValidator,
@@ -2576,6 +2791,7 @@ export {
   SendAiSessionCredentialEventValidator,
   SendBoostInputValidator,
   SendBoostResponseValidator,
+  SendBoostTemplateValidator,
   SendBrandingOptionsValidator,
   SendCredentialEventValidator,
   SendInboxResponseValidator,