@domino-sdk/relay 1.16.0 → 1.18.1

package/dist/{chunk-UJACD6K2.js → chunk-XSLRNFIY.js}

@@ -11,39 +11,71 @@ import {
   responseShape,
   rewardKey,
   tierRewardSchema
-} from "./chunk-46C33ASD.js";
+} from "./chunk-EMLDFUTV.js";
 
-// src/point-ledgers.ts
+// src/badges.ts
 import { z } from "zod";
-var pointLedgerPropertiesSchema = z.object({
+var badgePropertiesSchema = z.object({
   name: z.string().trim().min(1).max(120),
-  description: z.string().trim().max(1e3).default("")
+  description: z.string().trim().max(1e3).default(""),
+  image: z.string().url().max(2048)
+}).strict();
+var badgeDeclarationSchema = badgePropertiesSchema.extend({ key: identifier }).strict();
+var badgeSchema = badgePropertiesSchema.extend({ id: identifier, key: identifier.nullable() }).strip();
+var managedBadgeSchema = badgeSchema.extend({
+  archivedAt: z.number().int().nonnegative().nullable()
+});
+var createBadgeSchema = badgeDeclarationSchema.extend({ actionId: identifier }).strict();
+var badgeArtifactSchema = z.union([
+  badgeDeclarationSchema,
+  z.object({ code: z.string().min(1).max(2e6) }).strict()
+]);
+var memberBadgeSchema = z.object({
+  badge: badgeSchema,
+  awardedAt: z.number().int().nonnegative()
+});
+var memberBadgesSchema = z.object({
+  items: z.array(memberBadgeSchema)
+});
+var badgeMutationSchema = z.object({ actionId: identifier, reason: z.string().trim().min(1).max(1e3) }).strict();
+var badgeMutationResultSchema = z.object({
+  badge: identifier,
+  member: identifier,
+  awarded: z.boolean(),
+  changed: z.boolean()
+});
+
+// src/point-ledgers.ts
+import { z as z2 } from "zod";
+var pointLedgerPropertiesSchema = z2.object({
+  name: z2.string().trim().min(1).max(120),
+  description: z2.string().trim().max(1e3).default("")
 }).strict();
 var createPointLedgerSchema = pointLedgerPropertiesSchema.extend({ actionId: identifier, key: identifier.optional() }).strict();
 var pointLedgerSchema = pointLedgerPropertiesSchema.extend({
   id: identifier
 });
 var managedPointLedgerSchema = pointLedgerSchema.extend({
-  archivedAt: z.number().int().nonnegative().nullable()
+  archivedAt: z2.number().int().nonnegative().nullable()
 });
 var pointLedgerDeclarationSchema = pointLedgerPropertiesSchema.extend({ key: identifier }).strict();
-var pointLedgerArtifactSchema = z.union([
+var pointLedgerArtifactSchema = z2.union([
   pointLedgerDeclarationSchema,
-  z.object({ code: z.string().min(1).max(2e6) }).strict()
+  z2.object({ code: z2.string().min(1).max(2e6) }).strict()
 ]);
-var pointLedgerReferenceSchema = z.object({
+var pointLedgerReferenceSchema = z2.object({
   id: identifier,
   key: identifier.nullable(),
-  name: z.string()
+  name: z2.string()
 });
-var points = z.number().int().safe();
-var pointBalanceSchema = z.object({
+var points = z2.number().int().safe();
+var pointBalanceSchema = z2.object({
   ledger: pointLedgerReferenceSchema,
   balance: points,
   available: points
 });
-var pointBalancesSchema = z.object({
-  items: z.array(pointBalanceSchema)
+var pointBalancesSchema = z2.object({
+  items: z2.array(pointBalanceSchema)
 });
 var PointEntryKind = {
   /** Points a quest completion, an engagement settlement or an operator awarded. */
@@ -55,8 +87,8 @@ var PointEntryKind = {
   /** Undoes part or all of an award or a positive adjustment (`reverses`). */
   Reverse: "reverse"
 };
-var pointEntryKindSchema = z.string().min(1).max(64);
-var pointEntrySchema = z.object({
+var pointEntryKindSchema = z2.string().min(1).max(64);
+var pointEntrySchema = z2.object({
   id: identifier,
   amount: points,
   kind: pointEntryKindSchema,
@@ -65,64 +97,64 @@ var pointEntrySchema = z.object({
   quest: identifier.nullable(),
   reverses: identifier.nullable()
 });
-var pointHistoryQuerySchema = z.strictObject({
+var pointHistoryQuerySchema = z2.strictObject({
   ledger: identifier,
   cursor: pageCursorSchema.optional()
 });
-var pointHistoryPageSchema = z.object({
-  items: z.array(pointEntrySchema),
+var pointHistoryPageSchema = z2.object({
+  items: z2.array(pointEntrySchema),
   nextCursor: pageCursorSchema.nullable()
 });
 
 // src/engagement.ts
-import { z as z2 } from "zod";
-var amount = z2.number().int().safe().nonnegative();
-var engagementBudgetSchema = z2.strictObject({
-  scope: z2.enum(["member", "project"]),
+import { z as z3 } from "zod";
+var amount = z3.number().int().safe().nonnegative();
+var engagementBudgetSchema = z3.strictObject({
+  scope: z3.enum(["member", "project"]),
   period: calendarPeriodSchema,
   limit: amount
 });
-var engagementDefinitionSchema = z2.strictObject({
+var engagementDefinitionSchema = z3.strictObject({
   key: identifier,
   qualifiedBy: identifier,
   balance: identifier,
-  metrics: z2.array(contentMetricSchema).min(1).max(10).refine(
+  metrics: z3.array(contentMetricSchema).min(1).max(10).refine(
     (metrics) => new Set(metrics).size === metrics.length,
     "Metrics must be unique"
   ),
-  baseline: z2.literal("historical"),
-  maxAgeMs: z2.number().int().positive().max(864e5).default(36e5),
-  budgets: z2.array(engagementBudgetSchema).max(8).default([]).refine(
+  baseline: z3.literal("historical"),
+  maxAgeMs: z3.number().int().positive().max(864e5).default(36e5),
+  budgets: z3.array(engagementBudgetSchema).max(8).default([]).refine(
     (budgets) => new Set(budgets.map((b) => b.scope + ":" + b.period)).size === budgets.length,
     "Give each scope and period one budget"
   )
 });
-var engagementScoreInputSchema = z2.strictObject({
+var engagementScoreInputSchema = z3.strictObject({
   metrics: contentMetricsSchema,
   baseline: contentMetricsSchema
 });
-var engagementScoreSchema = z2.strictObject({
+var engagementScoreSchema = z3.strictObject({
   target: amount,
   baseline: amount
 });
-var engagementPublishSchema = z2.strictObject({
+var engagementPublishSchema = z3.strictObject({
   actionId: identifier,
-  code: z2.string().min(1).max(1e6)
+  code: z3.string().min(1).max(1e6)
 });
-var engagementRuleSchema = z2.strictObject({
+var engagementRuleSchema = z3.strictObject({
   version: identifier,
   definition: engagementDefinitionSchema,
   publishedAt: amount
 });
-var engagementPageQuerySchema = z2.strictObject({
+var engagementPageQuerySchema = z3.strictObject({
   rule: identifier,
-  content: z2.string().min(1).max(256),
+  content: z3.string().min(1).max(256),
   member: identifier.optional(),
   cursor: pageCursorSchema.optional()
 });
-var engagementSettlementSchema = z2.strictObject({
+var engagementSettlementSchema = z3.strictObject({
   id: identifier,
-  day: z2.string(),
+  day: z3.string(),
   observation: identifier,
   qualification: identifier,
   earned: amount,
@@ -132,9 +164,9 @@ var engagementSettlementSchema = z2.strictObject({
   entry: identifier.nullable(),
   createdAt: amount
 });
-var engagementPageSchema = z2.strictObject({
+var engagementPageSchema = z3.strictObject({
   rule: engagementRuleSchema,
-  account: z2.strictObject({
+  account: z3.strictObject({
     member: identifier,
     earned: amount,
     accounted: amount,
@@ -145,28 +177,28 @@ var engagementPageSchema = z2.strictObject({
     baseline: contentMetricsSchema,
     observation: identifier.nullable(),
     nextSettlementAt: amount.nullable(),
-    reason: z2.string().nullable()
+    reason: z3.string().nullable()
   }).nullable(),
-  items: z2.array(engagementSettlementSchema),
+  items: z3.array(engagementSettlementSchema),
   nextCursor: pageCursorSchema.nullable()
 });
-var engagementChangePreviewInputSchema = z2.strictObject({
-  code: z2.string().min(1).max(1e6)
+var engagementChangePreviewInputSchema = z3.strictObject({
+  code: z3.string().min(1).max(1e6)
 });
 var engagementChangeSchema = engagementPublishSchema.extend({
   expectedVersion: identifier,
   previewHash: identifier
 });
-var total = z2.string().regex(/^(0|[1-9][0-9]*)$/);
-var engagementChangePreviewSchema = z2.strictObject({
+var total = z3.string().regex(/^(0|[1-9][0-9]*)$/);
+var engagementChangePreviewSchema = z3.strictObject({
   rule: identifier,
   fromVersion: identifier,
   toVersion: identifier,
   previewHash: identifier,
   definition: engagementDefinitionSchema,
-  boundary: z2.literal("available-eligible-observation"),
-  settlement: z2.literal("deferred"),
-  summary: z2.strictObject({
+  boundary: z3.literal("available-eligible-observation"),
+  settlement: z3.literal("deferred"),
+  summary: z3.strictObject({
     knownAdmissions: amount,
     accounts: amount,
     uninitialized: amount,
@@ -180,13 +212,13 @@ var engagementChangePreviewSchema = z2.strictObject({
 var engagementVersionSchema = engagementRuleSchema.extend({
   previousVersion: identifier.nullable()
 });
-var engagementRuleVersionPageSchema = z2.object({
-  items: z2.array(
-    z2.object({
+var engagementRuleVersionPageSchema = z3.object({
+  items: z3.array(
+    z3.object({
       version: identifier,
-      definition: z2.object({
+      definition: z3.object({
         ...engagementDefinitionSchema.shape,
-        budgets: z2.array(z2.object(engagementBudgetSchema.shape)).max(8).default([])
+        budgets: z3.array(z3.object(engagementBudgetSchema.shape)).max(8).default([])
       }),
       publishedAt: amount,
       previousVersion: identifier.nullable()
@@ -194,19 +226,19 @@ var engagementRuleVersionPageSchema = z2.object({
   ),
   nextCursor: pageCursorSchema.nullable()
 });
-var engagementVersionPageSchema = z2.strictObject({
-  items: z2.array(engagementVersionSchema),
+var engagementVersionPageSchema = z3.strictObject({
+  items: z3.array(engagementVersionSchema),
   next: amount.nullable()
 });
-var engagementVersionQuerySchema = z2.strictObject({
+var engagementVersionQuerySchema = z3.strictObject({
   rule: identifier,
-  before: z2.coerce.number().int().positive().safe().optional()
+  before: z3.coerce.number().int().positive().safe().optional()
 });
-var engagementBoundaryPageSchema = z2.strictObject({
+var engagementBoundaryPageSchema = z3.strictObject({
   current: engagementRuleSchema.nullable(),
   requested: engagementRuleSchema,
-  items: z2.array(
-    z2.strictObject({
+  items: z3.array(
+    z3.strictObject({
       from: identifier,
       to: identifier,
       baseline: contentMetricsSchema,
@@ -222,137 +254,137 @@ var engagementArtifactSchema = engagementPublishSchema.omit({
 var deploymentEntry = engagementArtifactSchema.extend({
   rule: engagementRuleSchema
 });
-var engagementDeploymentEntrySchema = z2.discriminatedUnion("kind", [
-  deploymentEntry.extend({ kind: z2.literal("create") }),
-  deploymentEntry.extend({ kind: z2.literal("unchanged") }),
+var engagementDeploymentEntrySchema = z3.discriminatedUnion("kind", [
+  deploymentEntry.extend({ kind: z3.literal("create") }),
+  deploymentEntry.extend({ kind: z3.literal("unchanged") }),
   deploymentEntry.extend({
-    kind: z2.literal("change"),
+    kind: z3.literal("change"),
     change: engagementChangePreviewSchema
   })
 ]);
 
 // src/profiles.ts
-import { z as z3 } from "zod";
-var count = z3.number().int().nonnegative().safe();
-var profileVisibilitySchema = z3.enum([
+import { z as z4 } from "zod";
+var count = z4.number().int().nonnegative().safe();
+var profileVisibilitySchema = z4.enum([
   "private",
   "participants",
   "public"
 ]);
-var avatarProviderSchema = z3.enum(["x", "discord", "google"]);
-var profileDefaultProviderSchema = z3.enum(["x", "discord"]);
-var profileDefaultsSchema = z3.array(profileDefaultProviderSchema).max(profileDefaultProviderSchema.options.length).refine(
+var avatarProviderSchema = z4.enum(["x", "discord", "google"]);
+var profileDefaultProviderSchema = z4.enum(["x", "discord"]);
+var profileDefaultsSchema = z4.array(profileDefaultProviderSchema).max(profileDefaultProviderSchema.options.length).refine(
   (providers) => new Set(providers).size === providers.length,
   "List each provider once"
 );
-var avatarSeedSchema = z3.string().min(1).max(100);
-var profileAvatarSchema = z3.discriminatedUnion("source", [
-  z3.object({
-    source: z3.literal("upload"),
-    url: z3.string().url(),
+var avatarSeedSchema = z4.string().min(1).max(100);
+var profileAvatarSchema = z4.discriminatedUnion("source", [
+  z4.object({
+    source: z4.literal("upload"),
+    url: z4.string().url(),
     seed: avatarSeedSchema
   }),
-  z3.object({
-    source: z3.literal("account"),
+  z4.object({
+    source: z4.literal("account"),
     provider: avatarProviderSchema,
-    url: z3.string().url(),
+    url: z4.string().url(),
     seed: avatarSeedSchema
   }),
-  z3.object({ source: z3.literal("generated"), seed: avatarSeedSchema })
+  z4.object({ source: z4.literal("generated"), seed: avatarSeedSchema })
 ]);
-var profileSummarySchema = z3.object({
+var profileSummarySchema = z4.object({
   id: identifier,
-  name: z3.string(),
+  name: z4.string(),
   avatar: profileAvatarSchema
 });
 var invisible = /[\p{Cc}؜᠎​-‏‪-‮⁠-⁤⁦-⁩]/u;
-var displayNameSchema = z3.string().max(200).transform((value) => value.normalize("NFC").replace(/\s+/g, " ").trim()).pipe(
-  z3.string().min(1, "Enter a name").max(40, "Use at most 40 characters").refine((value) => !invisible.test(value), "Use visible characters only")
+var displayNameSchema = z4.string().max(200).transform((value) => value.normalize("NFC").replace(/\s+/g, " ").trim()).pipe(
+  z4.string().min(1, "Enter a name").max(40, "Use at most 40 characters").refine((value) => !invisible.test(value), "Use visible characters only")
 );
-var profileUpdateSchema = z3.object({
+var profileUpdateSchema = z4.object({
   displayName: displayNameSchema.nullable().optional(),
-  avatar: z3.discriminatedUnion("source", [
-    z3.object({
-      source: z3.literal("account"),
+  avatar: z4.discriminatedUnion("source", [
+    z4.object({
+      source: z4.literal("account"),
       provider: avatarProviderSchema
     }).strict(),
-    z3.object({ source: z3.literal("generated") }).strict()
+    z4.object({ source: z4.literal("generated") }).strict()
   ]).nullable().optional(),
-  hidden: z3.boolean().optional()
+  hidden: z4.boolean().optional()
 }).strict().refine(
   (value) => Object.values(value).some((field) => field !== void 0),
   "Change at least one field"
 );
 var ownProfileSchema = profileSummarySchema.extend({
   /** The name the member chose, or null for the default. */
-  displayName: z3.string().nullable(),
+  displayName: z4.string().nullable(),
   /** The avatar the member chose: `default` follows the project's defaults. */
-  avatarChoice: z3.enum(["default", "upload", "account", "generated"]),
+  avatarChoice: z4.enum(["default", "upload", "account", "generated"]),
   /** The account of an `account` choice. */
   avatarProvider: avatarProviderSchema.nullable(),
-  hidden: z3.boolean(),
+  hidden: z4.boolean(),
   /** An operator locked the name and avatar; the member can still hide the profile. */
-  locked: z3.boolean(),
+  locked: z4.boolean(),
   /** Who can see profiles in this project, so the app can explain it. */
   visibility: profileVisibilitySchema,
   /** The member's connected accounts a picture or name can come from. */
-  options: z3.array(
-    z3.object({
+  options: z4.array(
+    z4.object({
       provider: avatarProviderSchema,
-      name: z3.string().nullable(),
-      imageUrl: z3.string().url().nullable()
+      name: z4.string().nullable(),
+      imageUrl: z4.string().url().nullable()
     })
   )
 });
-var cursor = z3.string().min(1).max(512);
-var profileCompletionQuerySchema = z3.object({
-  limit: z3.coerce.number().int().min(1).max(100).default(20),
+var cursor = z4.string().min(1).max(512);
+var profileCompletionQuerySchema = z4.object({
+  limit: z4.coerce.number().int().min(1).max(100).default(20),
   cursor: cursor.optional()
 }).strict();
-var profileCompletionSchema = z3.object({
+var profileCompletionSchema = z4.object({
   quest: identifier,
   key: identifier.optional(),
-  title: z3.string(),
+  title: z4.string(),
   completions: count.positive(),
   /** Null for completions recorded before completion times were. */
   lastCompletedAt: count.nullable()
 });
-var profileCompletionPageSchema = z3.object({
-  items: z3.array(profileCompletionSchema),
+var profileCompletionPageSchema = z4.object({
+  items: z4.array(profileCompletionSchema),
   nextCursor: cursor.nullable()
 });
-var profileReferralSchema = z3.object({
+var profileReferralSchema = z4.object({
   program: identifier,
   key: identifier.optional(),
-  title: z3.string(),
+  title: z4.string(),
   /** Members this member invited. Invitations are shared by every program. */
   invited: count,
   /** Invited members who qualified in this program. */
   qualified: count,
-  milestones: z3.array(
-    z3.object({ id: identifier, count, reached: z3.boolean() })
+  milestones: z4.array(
+    z4.object({ id: identifier, count, reached: z4.boolean() })
   )
 });
-var profileSettingsSchema = z3.object({
+var profileSettingsSchema = z4.object({
   visibility: profileVisibilitySchema,
   defaults: profileDefaultsSchema,
   revision: count,
-  actor: z3.string().nullable(),
+  actor: z4.string().nullable(),
   updatedAt: count.nullable()
 });
 var profileSettingsInputSchema = profileSettingsSchema.omit({ revision: true, actor: true, updatedAt: true }).extend({
   actionId: identifier,
   /** The revision the change was made against; a newer one is a 409. */
   expectedRevision: count,
-  reason: z3.string().trim().min(1).max(500)
+  reason: z4.string().trim().min(1).max(500)
 }).strict();
-var profileModerationSchema = z3.object({
+var profileModerationSchema = z4.object({
   actionId: identifier,
-  resetName: z3.boolean().default(false),
-  removeAvatar: z3.boolean().default(false),
+  resetName: z4.boolean().default(false),
+  removeAvatar: z4.boolean().default(false),
   /** True locks the name and avatar, false unlocks them. */
-  lock: z3.boolean().optional(),
-  reason: z3.string().trim().min(1).max(1e3)
+  lock: z4.boolean().optional(),
+  reason: z4.string().trim().min(1).max(1e3)
 }).strict().refine(
   (value) => value.resetName || value.removeAvatar || value.lock !== void 0,
   "Choose an action"
@@ -360,55 +392,55 @@ var profileModerationSchema = z3.object({
 var managedProfileSchema = ownProfileSchema.omit({ options: true }).extend({
   member: identifier,
   lockedAt: count.nullable(),
-  lockedBy: z3.string().nullable(),
-  lockedReason: z3.string().nullable(),
+  lockedBy: z4.string().nullable(),
+  lockedReason: z4.string().nullable(),
   updatedAt: count
 });
 var AVATAR_UPLOAD_LIMIT = 5 * 1024 * 1024;
 var avatarUploadTypes = ["image/jpeg", "image/png", "image/webp"];
 
 // src/leaderboards.ts
-import { z as z4 } from "zod";
-var integer = z4.number().int().safe();
+import { z as z5 } from "zod";
+var integer = z5.number().int().safe();
 var timestamp = integer.nonnegative().max(864e13);
-var leaderboardWindowSchema = z4.discriminatedUnion("kind", [
-  z4.object({ kind: z4.literal("all-time") }).strict(),
-  z4.object({ kind: z4.literal("fixed"), start: timestamp, end: timestamp }).strict().refine((w) => w.end > w.start, "Window end must follow its start"),
-  z4.object({ kind: z4.literal("rolling"), days: integer.min(1).max(3660) }).strict(),
+var leaderboardWindowSchema = z5.discriminatedUnion("kind", [
+  z5.object({ kind: z5.literal("all-time") }).strict(),
+  z5.object({ kind: z5.literal("fixed"), start: timestamp, end: timestamp }).strict().refine((w) => w.end > w.start, "Window end must follow its start"),
+  z5.object({ kind: z5.literal("rolling"), days: integer.min(1).max(3660) }).strict(),
   // Not strict: boards published while a calendar window named its own `timeZone` keep reading,
   // and the field drops on parse. The authoring schema refuses it.
-  z4.object({
-    kind: z4.literal("calendar"),
+  z5.object({
+    kind: z5.literal("calendar"),
     /** The current day, week (ISO, starting on Monday) or month of the project calendar. */
     period: calendarPeriodSchema.exclude(["lifetime"])
   })
 ]);
 var periodScore = {
   window: leaderboardWindowSchema.default({ kind: "all-time" }),
-  quests: z4.array(identifier).min(1).max(100).optional()
+  quests: z5.array(identifier).min(1).max(100).optional()
 };
-var scoreSchema = z4.discriminatedUnion("kind", [
-  z4.object({ kind: z4.literal("balance") }).strict(),
-  z4.object({ kind: z4.literal("earned"), ...periodScore }).strict(),
-  z4.object({
-    kind: z4.literal("net"),
+var scoreSchema = z5.discriminatedUnion("kind", [
+  z5.object({ kind: z5.literal("balance") }).strict(),
+  z5.object({ kind: z5.literal("earned"), ...periodScore }).strict(),
+  z5.object({
+    kind: z5.literal("net"),
     window: leaderboardWindowSchema.default({ kind: "all-time" })
   }).strict()
 ]).default({ kind: "balance" });
-var leaderboardPrizeRewardSchema = z4.union([
+var leaderboardPrizeRewardSchema = z5.union([
   pointsRewardSchema,
   tierRewardSchema
 ]);
-var leaderboardPrizeSchema = z4.object({
-  ranks: z4.tuple([integer.positive(), integer.positive()]).refine(([first, last]) => last >= first, {
+var leaderboardPrizeSchema = z5.object({
+  ranks: z5.tuple([integer.positive(), integer.positive()]).refine(([first, last]) => last >= first, {
     message: "Prize rank range must end at or after it starts"
   }),
-  rewards: z4.array(leaderboardPrizeRewardSchema).min(1).max(20)
+  rewards: z5.array(leaderboardPrizeRewardSchema).min(1).max(20)
 }).strict();
-var leaderboardSettlementPolicySchema = z4.object({
-  at: z4.literal("window-end"),
-  ties: z4.enum(["shared", "earliest"]),
-  prizes: z4.array(leaderboardPrizeSchema).min(1).max(50)
+var leaderboardSettlementPolicySchema = z5.object({
+  at: z5.literal("window-end"),
+  ties: z5.enum(["shared", "earliest"]),
+  prizes: z5.array(leaderboardPrizeSchema).min(1).max(50)
 }).strict().superRefine((policy, context) => {
   for (const [index, prize] of policy.prizes.entries()) {
     const keys = prize.rewards.map(rewardKey);
@@ -432,13 +464,13 @@ var leaderboardSettlementPolicySchema = z4.object({
     }
   }
 });
-var leaderboardDefinitionObject = z4.object({
+var leaderboardDefinitionObject = z5.object({
   id: identifier,
   key: identifier.optional(),
-  title: z4.string().trim().min(1).max(120),
+  title: z5.string().trim().min(1).max(120),
   balance: identifier,
   score: scoreSchema,
-  access: z4.enum(["participants", "public"]).default("participants"),
+  access: z5.enum(["participants", "public"]).default("participants"),
   group: identifier.optional(),
   settle: leaderboardSettlementPolicySchema.optional()
 }).strict();
@@ -457,60 +489,60 @@ var leaderboardDefinitionResponseSchema = responseShape(
 );
 var leaderboardAuthoringSchema = leaderboardDefinitionObject.omit({ id: true }).extend({
   ...authoringIdentityShape,
-  score: z4.preprocess(refuseWindowTimeZone, scoreSchema),
+  score: z5.preprocess(refuseWindowTimeZone, scoreSchema),
   group: identifier.optional()
 }).strict().superRefine(validateSettlementWindow);
-var leaderboardArtifactSchema = z4.union([
+var leaderboardArtifactSchema = z5.union([
   leaderboardAuthoringSchema,
-  z4.object({ code: z4.string().min(1).max(2e6) }).strict()
+  z5.object({ code: z5.string().min(1).max(2e6) }).strict()
 ]);
-var publishedLeaderboardSchema = z4.object({
-  archivedAt: z4.number().int().nonnegative().nullable().optional(),
+var publishedLeaderboardSchema = z5.object({
+  archivedAt: z5.number().int().nonnegative().nullable().optional(),
   version: identifier,
   definition: leaderboardDefinitionResponseSchema,
   publishedAt: timestamp,
-  actor: z4.string().nullable()
+  actor: z5.string().nullable()
 });
-var leaderboardQuerySchema = z4.object({
-  limit: z4.coerce.number().int().min(1).max(100).default(25),
-  cursor: z4.string().max(4096).optional()
+var leaderboardQuerySchema = z5.object({
+  limit: z5.coerce.number().int().min(1).max(100).default(25),
+  cursor: z5.string().max(4096).optional()
 }).strict();
-var leaderboardRowSchema = z4.object({
+var leaderboardRowSchema = z5.object({
   /** The row's stable key: a pseudonym per board and member. */
   participant: identifier,
   member: identifier.optional(),
   /** The profile's name where the viewer can see it, otherwise the pseudonym's. */
-  name: z4.string(),
+  name: z5.string(),
   score: integer,
   rank: integer.positive(),
   /** The member's profile, where visible to this viewer and not hidden by the member. */
   profile: profileSummarySchema.nullable()
 });
-var leaderboardPageSchema = z4.object({
+var leaderboardPageSchema = z5.object({
   leaderboard: identifier,
-  title: z4.string(),
+  title: z5.string(),
   version: identifier,
-  calculation: z4.enum(["balance", "earned", "net"]),
-  period: z4.object({ start: timestamp.nullable(), end: timestamp.nullable() }),
+  calculation: z5.enum(["balance", "earned", "net"]),
+  period: z5.object({ start: timestamp.nullable(), end: timestamp.nullable() }),
   calculatedAt: timestamp,
   lastEntryAt: timestamp.nullable(),
   total: integer.nonnegative(),
-  items: z4.array(leaderboardRowSchema),
+  items: z5.array(leaderboardRowSchema),
   me: leaderboardRowSchema.nullable(),
-  nearby: z4.array(leaderboardRowSchema),
-  nextCursor: z4.string().nullable()
+  nearby: z5.array(leaderboardRowSchema),
+  nextCursor: z5.string().nullable()
 });
-var leaderboardPlacementSchema = z4.object({
+var leaderboardPlacementSchema = z5.object({
   leaderboard: identifier,
   key: identifier.optional(),
-  title: z4.string(),
+  title: z5.string(),
   profile: identifier,
   rank: integer.positive().nullable(),
   score: integer.nullable(),
   /** Ranked participants on the board. */
   total: integer.nonnegative()
 });
-var leaderboardPreviewSchema = z4.object({
+var leaderboardPreviewSchema = z5.object({
   published: publishedLeaderboardSchema,
   before: leaderboardPageSchema.nullable(),
   after: leaderboardPageSchema
@@ -519,152 +551,152 @@ var mutationBase = {
   actionId: identifier,
   member: identifier,
   balance: identifier,
-  reason: z4.string().trim().min(1).max(1e3)
+  reason: z5.string().trim().min(1).max(1e3)
 };
 var datedMutation = { ...mutationBase, effectiveAt: timestamp.optional() };
-var pointsMutationSchema = z4.discriminatedUnion("kind", [
-  z4.object({
+var pointsMutationSchema = z5.discriminatedUnion("kind", [
+  z5.object({
     ...datedMutation,
-    kind: z4.literal("award"),
-    referralEligible: z4.boolean().optional(),
+    kind: z5.literal("award"),
+    referralEligible: z5.boolean().optional(),
     amount: integer.positive()
   }).strict(),
-  z4.object({
+  z5.object({
     ...datedMutation,
-    kind: z4.literal("spend"),
+    kind: z5.literal("spend"),
     amount: integer.positive()
   }).strict(),
-  z4.object({
+  z5.object({
     ...datedMutation,
-    kind: z4.literal("adjust"),
+    kind: z5.literal("adjust"),
     amount: integer.refine((n) => n !== 0)
   }).strict(),
-  z4.object({
+  z5.object({
     ...datedMutation,
-    kind: z4.literal("set"),
+    kind: z5.literal("set"),
     total: integer.nonnegative(),
     expectedTotal: integer.nonnegative(),
-    classification: z4.enum(["earned", "spend"])
+    classification: z5.enum(["earned", "spend"])
   }).strict(),
-  z4.object({
+  z5.object({
     ...mutationBase,
-    kind: z4.literal("reverse"),
+    kind: z5.literal("reverse"),
     entry: identifier,
     amount: integer.positive()
   }).strict()
 ]);
-var pointsEntrySchema = z4.object({
+var pointsEntrySchema = z5.object({
   id: identifier,
-  completion: z4.string().nullable(),
+  completion: z5.string().nullable(),
   member: identifier,
   balance: identifier,
   amount: integer,
-  kind: z4.enum(["award", "spend", "adjust", "reverse"]),
+  kind: z5.enum(["award", "spend", "adjust", "reverse"]),
   effectiveAt: timestamp,
   receivedAt: timestamp,
   quest: identifier.nullable(),
   original: identifier.nullable(),
-  reason: z4.string(),
-  actor: z4.string().nullable()
+  reason: z5.string(),
+  actor: z5.string().nullable()
 });
-var managedPointHistoryPageSchema = z4.object({
-  items: z4.array(pointsEntrySchema),
+var managedPointHistoryPageSchema = z5.object({
+  items: z5.array(pointsEntrySchema),
   nextCursor: pageCursorSchema.nullable(),
   /** @deprecated Use `nextCursor`, passed back as `cursor`. Removed in 2.0.0. */
-  next: z4.number().nullable()
+  next: z5.number().nullable()
 });
-var pointsResultSchema = z4.object({
+var pointsResultSchema = z5.object({
   entry: pointsEntrySchema,
   total: integer.nonnegative()
 });
-var pointsAccountSchema = z4.object({
+var pointsAccountSchema = z5.object({
   member: identifier,
   balance: identifier,
   total: integer.nonnegative(),
   held: integer.nonnegative()
 });
-var leaderboardExclusionSchema = z4.object({
+var leaderboardExclusionSchema = z5.object({
   actionId: identifier,
   member: identifier,
-  excluded: z4.boolean(),
-  reason: z4.string().trim().min(1).max(1e3)
+  excluded: z5.boolean(),
+  reason: z5.string().trim().min(1).max(1e3)
 }).strict();
-var leaderboardGroupSchema = z4.object({
+var leaderboardGroupSchema = z5.object({
   actionId: identifier,
   member: identifier,
-  included: z4.boolean(),
-  reason: z4.string().trim().min(1).max(1e3)
+  included: z5.boolean(),
+  reason: z5.string().trim().min(1).max(1e3)
 }).strict();
-var leaderboardSettlementStatusSchema = z4.enum(["pending", "approved"]);
-var leaderboardSettlementSummarySchema = z4.object({
+var leaderboardSettlementStatusSchema = z5.enum(["pending", "approved"]);
+var leaderboardSettlementSummarySchema = z5.object({
   id: identifier,
   leaderboard: identifier,
   version: identifier,
-  title: z4.string(),
-  period: z4.object({ start: timestamp, end: timestamp }),
-  ties: z4.enum(["shared", "earliest"]),
+  title: z5.string(),
+  period: z5.object({ start: timestamp, end: timestamp }),
+  ties: z5.enum(["shared", "earliest"]),
   status: leaderboardSettlementStatusSchema,
   total: integer.nonnegative(),
   winners: integer.nonnegative(),
   createdAt: timestamp,
   approvedAt: timestamp.nullable(),
-  approvedBy: z4.string().nullable(),
-  approvalReason: z4.string().nullable()
+  approvedBy: z5.string().nullable(),
+  approvalReason: z5.string().nullable()
 });
-var leaderboardSettlementRowSchema = z4.object({
+var leaderboardSettlementRowSchema = z5.object({
   member: identifier,
   score: integer,
   rank: integer.positive(),
   position: integer.positive(),
   scoredAt: timestamp,
-  prizes: z4.array(integer.nonnegative()),
+  prizes: z5.array(integer.nonnegative()),
   completion: identifier.nullable(),
   revokedAt: timestamp.nullable()
 });
 var leaderboardSettlementSchema = leaderboardSettlementSummarySchema.extend({
-  prizes: z4.array(leaderboardPrizeSchema),
-  excluded: z4.array(identifier),
-  rows: z4.array(leaderboardSettlementRowSchema)
+  prizes: z5.array(leaderboardPrizeSchema),
+  excluded: z5.array(identifier),
+  rows: z5.array(leaderboardSettlementRowSchema)
 });
-var leaderboardSettlementApprovalSchema = z4.object({
+var leaderboardSettlementApprovalSchema = z5.object({
   actionId: identifier,
-  reason: z4.string().trim().min(1).max(500)
+  reason: z5.string().trim().min(1).max(500)
 }).strict();
 
 // src/referrals.ts
-import { z as z5 } from "zod";
-var rewardSchema = z5.union([pointsRewardSchema, tierRewardSchema]);
-var amount2 = z5.number().int().safe().nonnegative();
-var reason = z5.string().trim().min(1).max(1e3);
-var referralDefinitionSchema = z5.object({
+import { z as z6 } from "zod";
+var rewardSchema = z6.union([pointsRewardSchema, tierRewardSchema]);
+var amount2 = z6.number().int().safe().nonnegative();
+var reason = z6.string().trim().min(1).max(1e3);
+var referralDefinitionSchema = z6.object({
   id: identifier,
   key: identifier.optional(),
-  title: z5.string().trim().min(1).max(120),
-  enabled: z5.boolean().default(true),
-  qualification: z5.discriminatedUnion("kind", [
-    z5.object({ kind: z5.literal("signup") }).strict(),
-    z5.object({ kind: z5.literal("quest"), quest: identifier }).strict(),
-    z5.object({ kind: z5.literal("external") }).strict()
+  title: z6.string().trim().min(1).max(120),
+  enabled: z6.boolean().default(true),
+  qualification: z6.discriminatedUnion("kind", [
+    z6.object({ kind: z6.literal("signup") }).strict(),
+    z6.object({ kind: z6.literal("quest"), quest: identifier }).strict(),
+    z6.object({ kind: z6.literal("external") }).strict()
   ]),
   inviterGroup: identifier.optional(),
-  rewards: z5.object({
-    inviter: z5.array(rewardSchema).max(10).default([]),
-    invitee: z5.array(rewardSchema).max(10).default([])
+  rewards: z6.object({
+    inviter: z6.array(rewardSchema).max(10).default([]),
+    invitee: z6.array(rewardSchema).max(10).default([])
   }).strict().default({ inviter: [], invitee: [] }),
-  milestones: z5.array(
-    z5.object({
+  milestones: z6.array(
+    z6.object({
       id: identifier,
       count: amount2.min(1),
-      rewards: z5.array(rewardSchema).min(1).max(10)
+      rewards: z6.array(rewardSchema).min(1).max(10)
     }).strict()
   ).max(30).default([]),
-  bonuses: z5.array(
-    z5.object({
+  bonuses: z6.array(
+    z6.object({
       id: identifier,
       balance: identifier,
       basisPoints: amount2.min(1).max(1e4),
-      quests: z5.array(identifier).min(1).max(100).optional(),
-      external: z5.boolean().default(false),
+      quests: z6.array(identifier).min(1).max(100).optional(),
+      external: z6.boolean().default(false),
       durationDays: amount2.min(1).max(36500).optional(),
       maxPoints: amount2.min(1).optional()
     }).strict()
@@ -676,7 +708,7 @@ var referralDefinitionSchema = z5.object({
     }
   }
 });
-var referralAuthoringSchema = z5.object(referralDefinitionSchema.shape).omit({ id: true }).extend({
+var referralAuthoringSchema = z6.object(referralDefinitionSchema.shape).omit({ id: true }).extend({
   ...authoringIdentityShape,
   inviterGroup: identifier.optional()
 }).strict().superRefine((value, ctx) => {
@@ -686,105 +718,105 @@ var referralAuthoringSchema = z5.object(referralDefinitionSchema.shape).omit({ i
     }
   }
 });
-var referralArtifactSchema = z5.union([
+var referralArtifactSchema = z6.union([
   referralAuthoringSchema,
-  z5.object({ code: z5.string().min(1).max(2e6) }).strict()
+  z6.object({ code: z6.string().min(1).max(2e6) }).strict()
 ]);
-var publishedReferralSchema = z5.object({
-  archivedAt: z5.number().int().nonnegative().nullable().optional(),
+var publishedReferralSchema = z6.object({
+  archivedAt: z6.number().int().nonnegative().nullable().optional(),
   version: identifier,
   definition: referralDefinitionSchema,
   publishedAt: amount2,
-  actor: z5.string().nullable()
+  actor: z6.string().nullable()
 });
-var referralAcceptSchema = z5.object({ actionId: identifier, code: identifier }).strict();
-var referralSuspensionSchema = z5.object({ actionId: identifier, suspended: z5.boolean(), reason }).strict();
-var referralQualificationSchema = z5.object({ actionId: identifier, qualified: z5.boolean(), reason }).strict();
-var referralRewardResolutionSchema = z5.object({ actionId: identifier, reason }).strict();
-var referralControlSchema = z5.discriminatedUnion("kind", [
-  z5.object({
-    kind: z5.literal("suspend"),
+var referralAcceptSchema = z6.object({ actionId: identifier, code: identifier }).strict();
+var referralSuspensionSchema = z6.object({ actionId: identifier, suspended: z6.boolean(), reason }).strict();
+var referralQualificationSchema = z6.object({ actionId: identifier, qualified: z6.boolean(), reason }).strict();
+var referralRewardResolutionSchema = z6.object({ actionId: identifier, reason }).strict();
+var referralControlSchema = z6.discriminatedUnion("kind", [
+  z6.object({
+    kind: z6.literal("suspend"),
     actionId: identifier,
     member: identifier,
-    suspended: z5.boolean(),
+    suspended: z6.boolean(),
     reason
   }).strict(),
-  z5.object({
-    kind: z5.literal("qualify"),
+  z6.object({
+    kind: z6.literal("qualify"),
     actionId: identifier,
     member: identifier,
     program: identifier,
-    qualified: z5.boolean(),
+    qualified: z6.boolean(),
     reason
   }).strict(),
-  z5.object({
-    kind: z5.literal("resolve-reward"),
+  z6.object({
+    kind: z6.literal("resolve-reward"),
     actionId: identifier,
     entitlement: identifier,
     reason
   }).strict()
 ]);
-var referralRelationshipSchema = z5.object({
+var referralRelationshipSchema = z6.object({
   member: identifier,
   inviter: identifier,
   acceptedAt: amount2,
-  suspended: z5.boolean()
+  suspended: z6.boolean()
 });
-var referralAccountSchema = z5.object({
+var referralAccountSchema = z6.object({
   id: identifier,
   program: identifier,
-  kind: z5.enum(["bonus", "fixed", "milestone"]),
+  kind: z6.enum(["bonus", "fixed", "milestone"]),
   balance: identifier,
   earned: amount2,
   settled: amount2,
   outstanding: amount2
 });
-var referralSummarySchema = z5.object({
+var referralSummarySchema = z6.object({
   code: identifier,
   attributed: amount2,
-  programs: z5.array(
-    z5.object({
+  programs: z6.array(
+    z6.object({
       definition: referralDefinitionSchema,
       qualified: amount2,
-      milestones: z5.array(
-        z5.object({ id: identifier, count: amount2, reached: z5.boolean() })
+      milestones: z6.array(
+        z6.object({ id: identifier, count: amount2, reached: z6.boolean() })
       )
     })
   ),
-  accounts: z5.array(referralAccountSchema)
+  accounts: z6.array(referralAccountSchema)
 });
-var referralHistorySchema = z5.object({
-  items: z5.array(
-    z5.object({
+var referralHistorySchema = z6.object({
+  items: z6.array(
+    z6.object({
       id: amount2,
       program: identifier,
       balance: identifier,
-      amount: z5.number().int().safe(),
+      amount: z6.number().int().safe(),
       at: amount2,
-      reason: z5.string()
+      reason: z6.string()
     })
   ),
   nextCursor: pageCursorSchema.nullable()
 });
-var referralManagementSchema = z5.object({
-  relationships: z5.array(referralRelationshipSchema),
-  qualifications: z5.array(
-    z5.object({
+var referralManagementSchema = z6.object({
+  relationships: z6.array(referralRelationshipSchema),
+  qualifications: z6.array(
+    z6.object({
       member: identifier,
       program: identifier,
-      qualified: z5.boolean(),
+      qualified: z6.boolean(),
       qualifiedAt: amount2
     })
   ),
-  accounts: z5.array(
-    referralAccountSchema.extend({ member: identifier, invitee: z5.string() })
+  accounts: z6.array(
+    referralAccountSchema.extend({ member: identifier, invitee: z6.string() })
   ),
-  reviews: z5.array(
-    z5.object({
+  reviews: z6.array(
+    z6.object({
       entitlement: identifier,
       member: identifier,
       program: identifier,
-      reason: z5.string()
+      reason: z6.string()
     })
   ),
   nextCursor: pageCursorSchema.nullable().default(null),
@@ -793,51 +825,51 @@ var referralManagementSchema = z5.object({
 });
 
 // src/offers.ts
-import { z as z6 } from "zod";
-var quantity = z6.number().int().safe().nonnegative();
+import { z as z7 } from "zod";
+var quantity = z7.number().int().safe().nonnegative();
 var offerPriceSchema = pointsRewardSchema.extend({
-  amount: z6.number().int().positive().max(1e4)
+  amount: z7.number().int().positive().max(1e4)
 });
-var offerLimitSchema = z6.object({ perMember: z6.number().int().positive().max(1e4) }).strict();
-var offerDefinitionSchema = z6.object({
+var offerLimitSchema = z7.object({ perMember: z7.number().int().positive().max(1e4) }).strict();
+var offerDefinitionSchema = z7.object({
   id: identifier,
   key: identifier.optional(),
-  title: z6.string().trim().min(1).max(120),
+  title: z7.string().trim().min(1).max(120),
   price: offerPriceSchema,
   reward: tierRewardSchema,
   stock: quantity.max(1e6),
   limit: offerLimitSchema.default({ perMember: 1 }),
-  enabled: z6.boolean().default(true)
+  enabled: z7.boolean().default(true)
 }).strict();
 var offerAuthoringSchema = offerDefinitionSchema.omit({ id: true, title: true, enabled: true }).extend({
   ...authoringIdentityShape,
-  title: z6.string().trim().min(1).max(120).optional()
+  title: z7.string().trim().min(1).max(120).optional()
 }).strict().transform((offer) => ({
   ...offer,
   title: offer.title ?? offer.reward.reward.title,
   enabled: true
 }));
-var offerArtifactSchema = z6.union([
+var offerArtifactSchema = z7.union([
   offerAuthoringSchema,
-  z6.object({ code: z6.string().min(1).max(2e6) }).strict()
+  z7.object({ code: z7.string().min(1).max(2e6) }).strict()
 ]);
 var offerAvailabilitySchema = responseShape(
-  z6.discriminatedUnion("kind", [
-    z6.object({ kind: z6.literal("available"), remaining: quantity }).strict(),
-    z6.object({ kind: z6.literal("out-of-stock") }).strict(),
-    z6.object({ kind: z6.literal("limit-reached") }).strict(),
-    z6.object({ kind: z6.literal("paused") }).strict()
+  z7.discriminatedUnion("kind", [
+    z7.object({ kind: z7.literal("available"), remaining: quantity }).strict(),
+    z7.object({ kind: z7.literal("out-of-stock") }).strict(),
+    z7.object({ kind: z7.literal("limit-reached") }).strict(),
+    z7.object({ kind: z7.literal("paused") }).strict()
   ])
 );
 var offerSchema = responseShape(
   offerDefinitionSchema.extend({
-    revision: z6.number().int().positive(),
+    revision: z7.number().int().positive(),
     available: quantity,
     redeemed: quantity,
     availability: offerAvailabilitySchema
   })
 );
-var redeemOfferSchema = z6.object({ actionId: identifier }).strict();
+var redeemOfferSchema = z7.object({ actionId: identifier }).strict();
 var redemptionBase = {
   id: identifier,
   offer: identifier,
@@ -851,36 +883,46 @@ var redemptionBase = {
   price: offerPriceSchema,
   reward: tierRewardSchema,
   entitlement: identifier,
-  revision: z6.number().int().positive(),
-  redeemedAt: z6.number().int().safe().nonnegative()
+  revision: z7.number().int().positive(),
+  redeemedAt: z7.number().int().safe().nonnegative()
 };
 var redemptionSchema = responseShape(
-  z6.discriminatedUnion("status", [
-    z6.object({ ...redemptionBase, status: z6.literal("fulfilled") }).strict(),
-    z6.object({
+  z7.discriminatedUnion("status", [
+    z7.object({ ...redemptionBase, status: z7.literal("fulfilled") }).strict(),
+    z7.object({
       ...redemptionBase,
-      status: z6.literal("canceled"),
-      canceledAt: z6.number().int().safe().nonnegative(),
-      reason: z6.string().min(1).max(500)
+      status: z7.literal("canceled"),
+      canceledAt: z7.number().int().safe().nonnegative(),
+      reason: z7.string().min(1).max(500)
     }).strict()
   ])
 );
-var offerControlSchema = z6.object({
+var offerControlSchema = z7.object({
   actionId: identifier,
-  revision: z6.number().int().positive(),
-  enabled: z6.boolean(),
-  reason: z6.string().trim().min(1).max(500)
+  revision: z7.number().int().positive(),
+  enabled: z7.boolean(),
+  reason: z7.string().trim().min(1).max(500)
 }).strict();
-var redemptionCancellationSchema = z6.object({
+var redemptionCancellationSchema = z7.object({
   actionId: identifier,
-  revision: z6.number().int().positive(),
-  reason: z6.string().trim().min(1).max(500)
+  revision: z7.number().int().positive(),
+  reason: z7.string().trim().min(1).max(500)
 }).strict();
 function defineOffer(input) {
   return resourceHandle("offer", offerAuthoringSchema.parse(input));
 }
 
 export {
+  badgePropertiesSchema,
+  badgeDeclarationSchema,
+  badgeSchema,
+  managedBadgeSchema,
+  createBadgeSchema,
+  badgeArtifactSchema,
+  memberBadgeSchema,
+  memberBadgesSchema,
+  badgeMutationSchema,
+  badgeMutationResultSchema,
   pointLedgerPropertiesSchema,
   createPointLedgerSchema,
   pointLedgerSchema,