@domino-sdk/relay 1.53.1 → 1.55.0

package/dist/chunk-C7QZ4UBB.js

@@ -0,0 +1,937 @@
+import {
+  pointEntrySchema,
+  profileSummarySchema
+} from "./chunk-WHMXXHPX.js";
+import {
+  authoringIdentityShape,
+  calendarPeriodSchema,
+  contentMetricSchema,
+  contentMetricsSchema,
+  identifier,
+  maxPointsAmount,
+  pageCursorSchema,
+  pointsRewardSchema,
+  refuseWindowTimeZone,
+  resourceHandle,
+  responseShape,
+  rewardKey,
+  tierRewardSchema
+} from "./chunk-YCOKTQ4E.js";
+
+// src/badges.ts
+import * as z from "zod";
+var badgePropertiesSchema = z.object({
+  name: z.string().trim().min(1).max(120),
+  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/engagement.ts
+import * as z2 from "zod";
+var amount = z2.number().int().safe().nonnegative();
+var engagementBudgetSchema = z2.strictObject({
+  scope: z2.enum(["member", "project"]),
+  period: calendarPeriodSchema,
+  limit: amount
+});
+var engagementDefinitionSchema = z2.strictObject({
+  key: identifier,
+  qualifiedBy: identifier,
+  balance: identifier,
+  metrics: z2.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(
+    (budgets) => new Set(budgets.map((b) => b.scope + ":" + b.period)).size === budgets.length,
+    "Give each scope and period one budget"
+  )
+});
+var engagementScoreInputSchema = z2.strictObject({
+  metrics: contentMetricsSchema,
+  baseline: contentMetricsSchema
+});
+var engagementScoreSchema = z2.strictObject({
+  target: amount,
+  baseline: amount
+});
+var engagementPublishSchema = z2.strictObject({
+  actionId: identifier,
+  code: z2.string().min(1).max(1e6)
+});
+var engagementRuleSchema = z2.strictObject({
+  version: identifier,
+  definition: engagementDefinitionSchema,
+  publishedAt: amount
+});
+var engagementPageQuerySchema = z2.strictObject({
+  rule: identifier,
+  content: z2.string().min(1).max(256),
+  member: identifier.optional(),
+  cursor: pageCursorSchema.optional()
+});
+var engagementSettlementSchema = z2.strictObject({
+  id: identifier,
+  day: z2.string(),
+  observation: identifier,
+  qualification: identifier,
+  earned: amount,
+  growth: amount,
+  paid: amount,
+  excluded: amount,
+  entry: identifier.nullable(),
+  createdAt: amount
+});
+var engagementPageSchema = z2.strictObject({
+  rule: engagementRuleSchema,
+  account: z2.strictObject({
+    member: identifier,
+    earned: amount,
+    accounted: amount,
+    paid: amount,
+    excluded: amount,
+    pending: amount,
+    counters: contentMetricsSchema,
+    baseline: contentMetricsSchema,
+    observation: identifier.nullable(),
+    nextSettlementAt: amount.nullable(),
+    reason: z2.string().nullable()
+  }).nullable(),
+  items: z2.array(engagementSettlementSchema),
+  nextCursor: pageCursorSchema.nullable()
+});
+var engagementChangePreviewInputSchema = z2.strictObject({
+  code: z2.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({
+  rule: identifier,
+  fromVersion: identifier,
+  toVersion: identifier,
+  previewHash: identifier,
+  definition: engagementDefinitionSchema,
+  boundary: z2.literal("available-eligible-observation"),
+  settlement: z2.literal("deferred"),
+  summary: z2.strictObject({
+    knownAdmissions: amount,
+    accounts: amount,
+    uninitialized: amount,
+    pendingTransitions: amount,
+    earned: total,
+    paid: total,
+    excluded: total,
+    pending: total
+  })
+});
+var engagementVersionSchema = engagementRuleSchema.extend({
+  previousVersion: identifier.nullable()
+});
+var engagementRuleVersionPageSchema = z2.object({
+  items: z2.array(
+    z2.object({
+      version: identifier,
+      definition: z2.object({
+        ...engagementDefinitionSchema.shape,
+        budgets: z2.array(z2.object(engagementBudgetSchema.shape)).max(8).default([])
+      }),
+      publishedAt: amount,
+      previousVersion: identifier.nullable()
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable()
+});
+var engagementVersionPageSchema = z2.strictObject({
+  items: z2.array(engagementVersionSchema),
+  next: amount.nullable()
+});
+var engagementVersionQuerySchema = z2.strictObject({
+  rule: identifier,
+  before: z2.coerce.number().int().positive().safe().optional()
+});
+var engagementBoundaryPageSchema = z2.strictObject({
+  current: engagementRuleSchema.nullable(),
+  requested: engagementRuleSchema,
+  items: z2.array(
+    z2.strictObject({
+      from: identifier,
+      to: identifier,
+      baseline: contentMetricsSchema,
+      observedAt: amount,
+      settlement: engagementSettlementSchema
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable()
+});
+var engagementArtifactSchema = engagementPublishSchema.omit({
+  actionId: true
+});
+var deploymentEntry = engagementArtifactSchema.extend({
+  rule: engagementRuleSchema
+});
+var engagementDeploymentEntrySchema = z2.discriminatedUnion("kind", [
+  deploymentEntry.extend({ kind: z2.literal("create") }),
+  deploymentEntry.extend({ kind: z2.literal("unchanged") }),
+  deploymentEntry.extend({
+    kind: z2.literal("change"),
+    change: engagementChangePreviewSchema
+  })
+]);
+
+// src/leaderboards.ts
+import * as z3 from "zod";
+var integer = z3.number().int().safe();
+var timestamp = integer.nonnegative().max(864e13);
+var leaderboardWindowSchema = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("all-time") }).strict(),
+  z3.object({ kind: z3.literal("fixed"), start: timestamp, end: timestamp }).strict().refine((w) => w.end > w.start, "Window end must follow its start"),
+  z3.object({ kind: z3.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.
+  z3.object({
+    kind: z3.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: z3.array(identifier).min(1).max(100).optional()
+};
+var scoreSchema = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("balance") }).strict(),
+  z3.object({ kind: z3.literal("earned"), ...periodScore }).strict(),
+  z3.object({
+    kind: z3.literal("net"),
+    window: leaderboardWindowSchema.default({ kind: "all-time" })
+  }).strict()
+]).default({ kind: "balance" });
+var leaderboardPrizeRewardSchema = z3.union([
+  pointsRewardSchema,
+  tierRewardSchema
+]);
+var leaderboardPrizeSchema = z3.object({
+  ranks: z3.tuple([integer.positive(), integer.positive()]).refine(([first, last]) => last >= first, {
+    message: "Prize rank range must end at or after it starts"
+  }),
+  rewards: z3.array(leaderboardPrizeRewardSchema).min(1).max(20)
+}).strict();
+var baseUnitsSchema = z3.string().regex(
+  /^(0|[1-9]\d{0,77})$/,
+  'Use a whole number of base units, such as "1000000"'
+);
+var leaderboardPoolUnitSchema = z3.union([
+  z3.literal("points"),
+  z3.object({
+    code: z3.string().trim().min(1).max(32),
+    decimals: integer.min(0).max(36)
+  }).strict()
+]);
+var poolShape = {
+  /** The whole pool in base units. */
+  amount: baseUnitsSchema.refine((amount3) => amount3 !== "0", {
+    message: "A pool must hold a positive amount"
+  }),
+  unit: leaderboardPoolUnitSchema,
+  /** The point ledger a points pool pays into. Only points pools take one, and they require it. */
+  ledger: identifier.optional(),
+  /** Members scoring at or below this get no share. Members scoring 0 or less never do. */
+  minScore: integer.optional()
+};
+var refinePool = (pool, context) => {
+  if (pool.unit === "points") {
+    if (!pool.ledger) {
+      context.addIssue({
+        code: "custom",
+        message: "A points pool names the point ledger it pays into",
+        path: ["ledger"]
+      });
+    }
+    if (/^\d+$/.test(pool.amount) && BigInt(pool.amount) > maxPointsAmount) {
+      context.addIssue({
+        code: "custom",
+        message: `A points pool holds at most ${maxPointsAmount} points`,
+        path: ["amount"]
+      });
+    }
+  } else if (pool.ledger !== void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Only a points pool pays into a point ledger",
+      path: ["ledger"]
+    });
+  }
+};
+var leaderboardPoolSchema = z3.object(poolShape).strict().superRefine(refinePool);
+var leaderboardSettlementPolicySchema = z3.object({
+  at: z3.literal("window-end"),
+  ties: z3.enum(["shared", "earliest"]),
+  /** Rank prizes. A board with a pool may list none. */
+  prizes: z3.array(leaderboardPrizeSchema).max(50),
+  pool: leaderboardPoolSchema.optional()
+}).strict().superRefine((policy, context) => {
+  if (!policy.prizes.length && !policy.pool) {
+    context.addIssue({
+      code: "custom",
+      message: "A settlement awards rank prizes, a pool, or both",
+      path: ["prizes"]
+    });
+  }
+  for (const [index, prize] of policy.prizes.entries()) {
+    const keys = prize.rewards.map(rewardKey);
+    if (new Set(keys).size !== keys.length) {
+      context.addIssue({
+        code: "custom",
+        message: "A prize may grant each point ledger or tiered reward only once",
+        path: ["prizes", index, "rewards"]
+      });
+    }
+  }
+  for (let index = 1; index < policy.prizes.length; index++) {
+    const previous = policy.prizes[index - 1];
+    const current = policy.prizes[index];
+    if (current.ranks[0] <= previous.ranks[1]) {
+      context.addIssue({
+        code: "custom",
+        message: "Prize rank ranges must be ordered and must not overlap",
+        path: ["prizes", index, "ranks"]
+      });
+    }
+  }
+});
+var leaderboardDefinitionObject = z3.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z3.string().trim().min(1).max(120),
+  balance: identifier,
+  score: scoreSchema,
+  access: z3.enum(["participants", "public"]).default("participants"),
+  group: identifier.optional(),
+  /**
+   * List the project's eligible members who have no qualifying points, with a score of 0, ranked
+   * after every member who scored and ordered by member ID. Omitted or false lists only members
+   * with a qualifying entry. Settlements never include them.
+   */
+  includeUnscored: z3.boolean().optional(),
+  settle: leaderboardSettlementPolicySchema.optional()
+}).strict();
+var validateSettlementWindow = (definition, context) => {
+  if (definition.settle && (definition.score.kind === "balance" || !["fixed", "calendar"].includes(definition.score.window.kind))) {
+    context.addIssue({
+      code: "custom",
+      message: "Leaderboard prizes require an earned or net score with a fixed or calendar window",
+      path: ["settle"]
+    });
+  }
+};
+var leaderboardDefinitionSchema = leaderboardDefinitionObject.superRefine(validateSettlementWindow);
+var leaderboardDefinitionResponseSchema = responseShape(
+  leaderboardDefinitionSchema
+);
+var leaderboardAuthoringSchema = leaderboardDefinitionObject.omit({ id: true }).extend({
+  ...authoringIdentityShape,
+  score: z3.preprocess(refuseWindowTimeZone, scoreSchema),
+  group: identifier.optional()
+}).strict().superRefine(validateSettlementWindow);
+var leaderboardArtifactSchema = z3.union([
+  leaderboardAuthoringSchema,
+  z3.object({ code: z3.string().min(1).max(2e6) }).strict()
+]);
+var publishedLeaderboardSchema = z3.object({
+  archivedAt: z3.number().int().nonnegative().nullable().optional(),
+  version: identifier,
+  definition: leaderboardDefinitionResponseSchema,
+  publishedAt: timestamp,
+  actor: z3.string().nullable()
+});
+var leaderboardQuerySchema = z3.object({
+  limit: z3.coerce.number().int().min(1).max(100).default(25),
+  cursor: z3.string().max(4096).optional()
+}).strict();
+var leaderboardRowSchema = z3.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: z3.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 = z3.object({
+  leaderboard: identifier,
+  title: z3.string(),
+  version: identifier,
+  calculation: z3.enum(["balance", "earned", "net"]),
+  period: z3.object({ start: timestamp.nullable(), end: timestamp.nullable() }),
+  calculatedAt: timestamp,
+  lastEntryAt: timestamp.nullable(),
+  total: integer.nonnegative(),
+  items: z3.array(leaderboardRowSchema),
+  me: leaderboardRowSchema.nullable(),
+  nearby: z3.array(leaderboardRowSchema),
+  nextCursor: z3.string().nullable()
+});
+var leaderboardPlacementSchema = z3.object({
+  leaderboard: identifier,
+  key: identifier.optional(),
+  title: z3.string(),
+  profile: identifier,
+  rank: integer.positive().nullable(),
+  score: integer.nullable(),
+  /** Ranked participants on the board. */
+  total: integer.nonnegative()
+});
+var leaderboardHistoryQuerySchema = z3.strictObject({
+  board: identifier,
+  cursor: pageCursorSchema.optional()
+});
+var leaderboardHistoryPageSchema = z3.object({
+  leaderboard: identifier,
+  period: z3.object({ start: timestamp.nullable(), end: timestamp.nullable() }),
+  items: z3.array(pointEntrySchema),
+  nextCursor: pageCursorSchema.nullable()
+});
+var leaderboardPreviewSchema = z3.object({
+  published: publishedLeaderboardSchema,
+  before: leaderboardPageSchema.nullable(),
+  after: leaderboardPageSchema
+});
+var mutationBase = {
+  actionId: identifier,
+  member: identifier,
+  balance: identifier,
+  reason: z3.string().trim().min(1).max(1e3)
+};
+var datedMutation = { ...mutationBase, effectiveAt: timestamp.optional() };
+var pointsMutationSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    ...datedMutation,
+    kind: z3.literal("award"),
+    referralEligible: z3.boolean().optional(),
+    amount: integer.positive()
+  }).strict(),
+  z3.object({
+    ...datedMutation,
+    kind: z3.literal("spend"),
+    amount: integer.positive()
+  }).strict(),
+  z3.object({
+    ...datedMutation,
+    kind: z3.literal("adjust"),
+    amount: integer.refine((n) => n !== 0)
+  }).strict(),
+  z3.object({
+    ...datedMutation,
+    kind: z3.literal("set"),
+    total: integer.nonnegative(),
+    expectedTotal: integer.nonnegative(),
+    classification: z3.enum(["earned", "spend"])
+  }).strict(),
+  z3.object({
+    ...mutationBase,
+    kind: z3.literal("reverse"),
+    entry: identifier,
+    amount: integer.positive()
+  }).strict()
+]);
+var pointsEntrySchema = z3.object({
+  id: identifier,
+  completion: z3.string().nullable(),
+  member: identifier,
+  balance: identifier,
+  amount: integer,
+  kind: z3.enum(["award", "spend", "adjust", "reverse"]),
+  effectiveAt: timestamp,
+  receivedAt: timestamp,
+  quest: identifier.nullable(),
+  original: identifier.nullable(),
+  reason: z3.string(),
+  actor: z3.string().nullable(),
+  /**
+   * The member import whose opening balance this `adjust` is, or null. Imported entries emit no
+   * `points.awarded` and count on balance leaderboards only. Absent from Relay versions without
+   * imports.
+   */
+  import: identifier.nullable().optional()
+});
+var managedPointHistoryPageSchema = z3.object({
+  items: z3.array(pointsEntrySchema),
+  nextCursor: pageCursorSchema.nullable(),
+  /** @deprecated Use `nextCursor`, passed back as `cursor`. Removed in 2.0.0. */
+  next: z3.number().nullable()
+});
+var pointsResultSchema = z3.object({
+  entry: pointsEntrySchema,
+  total: integer.nonnegative()
+});
+var pointsAccountSchema = z3.object({
+  member: identifier,
+  balance: identifier,
+  total: integer.nonnegative(),
+  held: integer.nonnegative()
+});
+var leaderboardExclusionSchema = z3.object({
+  actionId: identifier,
+  member: identifier,
+  excluded: z3.boolean(),
+  reason: z3.string().trim().min(1).max(1e3)
+}).strict();
+var leaderboardExclusionGroupSchema = z3.object({
+  leaderboard: identifier,
+  group: identifier,
+  generated: z3.boolean(),
+  boundAt: timestamp.nullable()
+});
+var leaderboardExclusionGroupBindingSchema = z3.object({
+  actionId: identifier,
+  group: identifier,
+  reason: z3.string().trim().min(1).max(1e3)
+}).strict();
+var leaderboardGroupSchema = z3.object({
+  actionId: identifier,
+  member: identifier,
+  included: z3.boolean(),
+  reason: z3.string().trim().min(1).max(1e3)
+}).strict();
+var leaderboardSettlementStatusSchema = z3.enum(["pending", "approved"]);
+var leaderboardSettlementSummarySchema = z3.object({
+  id: identifier,
+  leaderboard: identifier,
+  version: identifier,
+  title: z3.string(),
+  period: z3.object({ start: timestamp, end: timestamp }),
+  ties: z3.enum(["shared", "earliest"]),
+  status: leaderboardSettlementStatusSchema,
+  total: integer.nonnegative(),
+  winners: integer.nonnegative(),
+  createdAt: timestamp,
+  approvedAt: timestamp.nullable(),
+  approvedBy: z3.string().nullable(),
+  approvalReason: z3.string().nullable()
+});
+var leaderboardSettlementRowSchema = z3.object({
+  member: identifier,
+  score: integer,
+  rank: integer.positive(),
+  position: integer.positive(),
+  scoredAt: timestamp,
+  prizes: z3.array(integer.nonnegative()),
+  completion: identifier.nullable(),
+  revokedAt: timestamp.nullable(),
+  /**
+   * The member's pool share in the pool's base units, frozen with the row: `"0"` for a member the
+   * pool leaves out. Absent when the settlement has no pool.
+   */
+  share: baseUnitsSchema.optional()
+});
+var leaderboardSettlementPoolSchema = z3.object({
+  ...poolShape,
+  allocated: baseUnitsSchema,
+  unallocated: baseUnitsSchema
+});
+var leaderboardSettlementUnmeasuredSchema = z3.object({
+  content: z3.string(),
+  member: identifier,
+  /** When the last good measurement was observed, if Relay has one. */
+  observedAt: timestamp.nullable()
+});
+var leaderboardSettlementSchema = leaderboardSettlementSummarySchema.extend({
+  prizes: z3.array(leaderboardPrizeSchema),
+  excluded: z3.array(identifier),
+  /**
+   * Content frozen at its last good measurement because its closing measurement never came; a
+   * reviewer can retry measurement. Relay sends it for every settlement, empty when nothing is
+   * missing.
+   */
+  unmeasured: z3.array(leaderboardSettlementUnmeasuredSchema).optional(),
+  /** The settlement's pool prize, or null without one. Absent from Relay versions without pools. */
+  pool: leaderboardSettlementPoolSchema.nullable().optional(),
+  rows: z3.array(leaderboardSettlementRowSchema)
+});
+var leaderboardSettlementApprovalSchema = z3.object({
+  actionId: identifier,
+  reason: z3.string().trim().min(1).max(500)
+}).strict();
+
+// src/referrals.ts
+import * as z4 from "zod";
+var rewardSchema = z4.union([pointsRewardSchema, tierRewardSchema]);
+var amount2 = z4.number().int().safe().nonnegative();
+var reason = z4.string().trim().min(1).max(1e3);
+var referralDefinitionSchema = z4.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z4.string().trim().min(1).max(120),
+  enabled: z4.boolean().default(true),
+  qualification: z4.discriminatedUnion("kind", [
+    z4.object({ kind: z4.literal("signup") }).strict(),
+    z4.object({ kind: z4.literal("quest"), quest: identifier }).strict(),
+    z4.object({ kind: z4.literal("external") }).strict()
+  ]),
+  inviterGroup: identifier.optional(),
+  rewards: z4.object({
+    inviter: z4.array(rewardSchema).max(10).default([]),
+    invitee: z4.array(rewardSchema).max(10).default([])
+  }).strict().default({ inviter: [], invitee: [] }),
+  milestones: z4.array(
+    z4.object({
+      id: identifier,
+      count: amount2.min(1),
+      rewards: z4.array(rewardSchema).min(1).max(10)
+    }).strict()
+  ).max(30).default([]),
+  bonuses: z4.array(
+    z4.object({
+      id: identifier,
+      balance: identifier,
+      basisPoints: amount2.min(1).max(1e4),
+      quests: z4.array(identifier).min(1).max(100).optional(),
+      external: z4.boolean().default(false),
+      durationDays: amount2.min(1).max(36500).optional(),
+      maxPoints: amount2.min(1).optional()
+    }).strict()
+  ).max(20).default([])
+}).strict().superRefine((value, ctx) => {
+  for (const entries of [value.milestones, value.bonuses]) {
+    if (new Set(entries.map((e) => e.id)).size !== entries.length) {
+      ctx.addIssue({ code: "custom", message: "Rule IDs must be unique" });
+    }
+  }
+});
+var referralAuthoringSchema = z4.object(referralDefinitionSchema.shape).omit({ id: true }).extend({
+  ...authoringIdentityShape,
+  inviterGroup: identifier.optional()
+}).strict().superRefine((value, ctx) => {
+  for (const entries of [value.milestones, value.bonuses]) {
+    if (new Set(entries.map((entry) => entry.id)).size !== entries.length) {
+      ctx.addIssue({ code: "custom", message: "Rule keys must be unique" });
+    }
+  }
+});
+var referralArtifactSchema = z4.union([
+  referralAuthoringSchema,
+  z4.object({ code: z4.string().min(1).max(2e6) }).strict()
+]);
+var publishedReferralSchema = z4.object({
+  archivedAt: z4.number().int().nonnegative().nullable().optional(),
+  version: identifier,
+  definition: referralDefinitionSchema,
+  publishedAt: amount2,
+  actor: z4.string().nullable()
+});
+var referralAcceptSchema = z4.object({ actionId: identifier, code: identifier }).strict();
+var referralSuspensionSchema = z4.object({ actionId: identifier, suspended: z4.boolean(), reason }).strict();
+var referralQualificationSchema = z4.object({ actionId: identifier, qualified: z4.boolean(), reason }).strict();
+var referralRewardResolutionSchema = z4.object({ actionId: identifier, reason }).strict();
+var referralControlSchema = z4.discriminatedUnion("kind", [
+  z4.object({
+    kind: z4.literal("suspend"),
+    actionId: identifier,
+    member: identifier,
+    suspended: z4.boolean(),
+    reason
+  }).strict(),
+  z4.object({
+    kind: z4.literal("qualify"),
+    actionId: identifier,
+    member: identifier,
+    program: identifier,
+    qualified: z4.boolean(),
+    reason
+  }).strict(),
+  z4.object({
+    kind: z4.literal("resolve-reward"),
+    actionId: identifier,
+    entitlement: identifier,
+    reason
+  }).strict()
+]);
+var referralRelationshipSchema = z4.object({
+  member: identifier,
+  inviter: identifier,
+  acceptedAt: amount2,
+  suspended: z4.boolean()
+});
+var referralAccountSchema = z4.object({
+  id: identifier,
+  program: identifier,
+  kind: z4.enum(["bonus", "fixed", "milestone"]),
+  balance: identifier,
+  earned: amount2,
+  settled: amount2,
+  outstanding: amount2
+});
+var referralSummarySchema = z4.object({
+  code: identifier,
+  attributed: amount2,
+  programs: z4.array(
+    z4.object({
+      definition: referralDefinitionSchema,
+      qualified: amount2,
+      milestones: z4.array(
+        z4.object({ id: identifier, count: amount2, reached: z4.boolean() })
+      )
+    })
+  ),
+  accounts: z4.array(referralAccountSchema)
+});
+var referralHistorySchema = z4.object({
+  items: z4.array(
+    z4.object({
+      id: amount2,
+      program: identifier,
+      balance: identifier,
+      amount: z4.number().int().safe(),
+      at: amount2,
+      reason: z4.string()
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable()
+});
+var referralManagementSchema = z4.object({
+  relationships: z4.array(referralRelationshipSchema),
+  qualifications: z4.array(
+    z4.object({
+      member: identifier,
+      program: identifier,
+      qualified: z4.boolean(),
+      qualifiedAt: amount2
+    })
+  ),
+  accounts: z4.array(
+    referralAccountSchema.extend({ member: identifier, invitee: z4.string() })
+  ),
+  reviews: z4.array(
+    z4.object({
+      entitlement: identifier,
+      member: identifier,
+      program: identifier,
+      reason: z4.string()
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable().default(null),
+  /** @deprecated Use `nextCursor`, passed back as `cursor`. Removed in 2.0.0. */
+  next: amount2.nullable()
+});
+
+// src/offers.ts
+import * as z5 from "zod";
+var quantity = z5.number().int().safe().nonnegative();
+var offerPriceSchema = pointsRewardSchema.extend({
+  amount: z5.number().int().positive().max(maxPointsAmount)
+});
+var offerLimitSchema = z5.object({ perMember: z5.number().int().positive().max(1e4) }).strict();
+var offerDefinitionSchema = z5.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z5.string().trim().min(1).max(120),
+  price: offerPriceSchema,
+  reward: tierRewardSchema,
+  stock: quantity.max(1e6),
+  limit: offerLimitSchema.default({ perMember: 1 }),
+  enabled: z5.boolean().default(true)
+}).strict();
+var offerAuthoringSchema = offerDefinitionSchema.omit({ id: true, title: true, enabled: true }).extend({
+  ...authoringIdentityShape,
+  title: z5.string().trim().min(1).max(120).optional()
+}).strict().transform((offer) => ({
+  ...offer,
+  title: offer.title ?? offer.reward.reward.title,
+  enabled: true
+}));
+var offerArtifactSchema = z5.union([
+  offerAuthoringSchema,
+  z5.object({ code: z5.string().min(1).max(2e6) }).strict()
+]);
+var offerAvailabilitySchema = responseShape(
+  z5.discriminatedUnion("kind", [
+    z5.object({ kind: z5.literal("available"), remaining: quantity }).strict(),
+    z5.object({ kind: z5.literal("out-of-stock") }).strict(),
+    z5.object({ kind: z5.literal("limit-reached") }).strict(),
+    z5.object({ kind: z5.literal("paused") }).strict()
+  ])
+);
+var offerSchema = responseShape(
+  offerDefinitionSchema.extend({
+    revision: z5.number().int().positive(),
+    available: quantity,
+    redeemed: quantity,
+    availability: offerAvailabilitySchema
+  })
+);
+var redeemOfferSchema = z5.object({ actionId: identifier }).strict();
+var redemptionBase = {
+  id: identifier,
+  offer: identifier,
+  member: identifier,
+  /**
+   * @deprecated Use `id` to refer to a redemption. A redemption is fulfilled in the request that
+   * makes it, so nothing is reserved beforehand; the ID refers to no other record. Removed in
+   * 2.0.0.
+   */
+  reservation: identifier,
+  price: offerPriceSchema,
+  reward: tierRewardSchema,
+  entitlement: identifier,
+  revision: z5.number().int().positive(),
+  redeemedAt: z5.number().int().safe().nonnegative()
+};
+var redemptionSchema = responseShape(
+  z5.discriminatedUnion("status", [
+    z5.object({ ...redemptionBase, status: z5.literal("fulfilled") }).strict(),
+    z5.object({
+      ...redemptionBase,
+      status: z5.literal("canceled"),
+      canceledAt: z5.number().int().safe().nonnegative(),
+      reason: z5.string().min(1).max(500)
+    }).strict()
+  ])
+);
+var redemptionQuerySchema = z5.strictObject({
+  member: identifier.optional(),
+  cursor: pageCursorSchema.optional(),
+  limit: z5.coerce.number().int().min(1).max(100).optional()
+});
+var redemptionPageSchema = z5.object({
+  items: z5.array(redemptionSchema),
+  nextCursor: pageCursorSchema.nullable()
+});
+var offerControlSchema = z5.object({
+  actionId: identifier,
+  revision: z5.number().int().positive(),
+  enabled: z5.boolean(),
+  reason: z5.string().trim().min(1).max(500)
+}).strict();
+var redemptionCancellationSchema = z5.object({
+  actionId: identifier,
+  revision: z5.number().int().positive(),
+  reason: z5.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,
+  engagementBudgetSchema,
+  engagementDefinitionSchema,
+  engagementScoreInputSchema,
+  engagementScoreSchema,
+  engagementPublishSchema,
+  engagementRuleSchema,
+  engagementPageQuerySchema,
+  engagementSettlementSchema,
+  engagementPageSchema,
+  engagementChangePreviewInputSchema,
+  engagementChangeSchema,
+  engagementChangePreviewSchema,
+  engagementRuleVersionPageSchema,
+  engagementVersionPageSchema,
+  engagementVersionQuerySchema,
+  engagementBoundaryPageSchema,
+  engagementArtifactSchema,
+  engagementDeploymentEntrySchema,
+  leaderboardWindowSchema,
+  leaderboardPrizeRewardSchema,
+  leaderboardPrizeSchema,
+  baseUnitsSchema,
+  leaderboardPoolUnitSchema,
+  leaderboardPoolSchema,
+  leaderboardSettlementPolicySchema,
+  leaderboardDefinitionSchema,
+  leaderboardDefinitionResponseSchema,
+  leaderboardAuthoringSchema,
+  leaderboardArtifactSchema,
+  publishedLeaderboardSchema,
+  leaderboardQuerySchema,
+  leaderboardRowSchema,
+  leaderboardPageSchema,
+  leaderboardPlacementSchema,
+  leaderboardHistoryQuerySchema,
+  leaderboardHistoryPageSchema,
+  leaderboardPreviewSchema,
+  pointsMutationSchema,
+  pointsEntrySchema,
+  managedPointHistoryPageSchema,
+  pointsResultSchema,
+  pointsAccountSchema,
+  leaderboardExclusionSchema,
+  leaderboardExclusionGroupSchema,
+  leaderboardExclusionGroupBindingSchema,
+  leaderboardGroupSchema,
+  leaderboardSettlementStatusSchema,
+  leaderboardSettlementSummarySchema,
+  leaderboardSettlementRowSchema,
+  leaderboardSettlementPoolSchema,
+  leaderboardSettlementUnmeasuredSchema,
+  leaderboardSettlementSchema,
+  leaderboardSettlementApprovalSchema,
+  referralDefinitionSchema,
+  referralAuthoringSchema,
+  referralArtifactSchema,
+  publishedReferralSchema,
+  referralAcceptSchema,
+  referralSuspensionSchema,
+  referralQualificationSchema,
+  referralRewardResolutionSchema,
+  referralControlSchema,
+  referralRelationshipSchema,
+  referralAccountSchema,
+  referralSummarySchema,
+  referralHistorySchema,
+  referralManagementSchema,
+  offerPriceSchema,
+  offerLimitSchema,
+  offerDefinitionSchema,
+  offerAuthoringSchema,
+  offerArtifactSchema,
+  offerAvailabilitySchema,
+  offerSchema,
+  redeemOfferSchema,
+  redemptionSchema,
+  redemptionQuerySchema,
+  redemptionPageSchema,
+  offerControlSchema,
+  redemptionCancellationSchema,
+  defineOffer
+};