@domino-sdk/relay 1.61.0 → 1.63.0

package/dist/chunk-3Y3L2F54.js

@@ -1,982 +0,0 @@
-import {
-  pointEntrySchema,
-  profileSummarySchema
-} from "./chunk-SE4PFJPT.js";
-import {
-  authoringIdentityShape,
-  calendarPeriodSchema,
-  contentMetricSchema,
-  contentMetricsSchema,
-  identifier,
-  maxPointsAmount,
-  missingPrerequisiteSchema,
-  pageCursorSchema,
-  pointsRewardSchema,
-  prerequisiteSchema,
-  refuseWindowTimeZone,
-  resourceHandle,
-  responseShape,
-  rewardKey,
-  tierRewardSchema
-} from "./chunk-ZDJLPN4L.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(),
-  /** The member import that recorded this referral, or null when the friend accepted an invitation. */
-  import: identifier.nullable().optional()
-});
-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,
-      /** The member import that recorded this qualification, which paid no reward, or null. */
-      import: identifier.nullable().optional()
-    })
-  ),
-  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/definition-error.ts
-function issueText(issues) {
-  return issues.map(
-    (issue) => issue.path.length ? issue.path.map(String).join(".") + ": " + issue.message : issue.message
-  ).join("; ");
-}
-function parseDefinition(kind, schema, input) {
-  const parsed = schema.safeParse(input);
-  if (parsed.success) {
-    return parsed.data;
-  }
-  const key = typeof input === "object" && input !== null && "key" in input && typeof input.key === "string" ? ` "${input.key}"` : "";
-  parsed.error.message = `${kind}${key} is invalid: ${issueText(parsed.error.issues)}`;
-  throw parsed.error;
-}
-
-// 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 }),
-  /**
-   * What a member must meet to redeem, the same prerequisites quests take: `completed`,
-   * `balanceAtLeast` and `inGroup`. Checked when the member redeems; absent, anyone can.
-   */
-  requires: z5.array(prerequisiteSchema).max(30).optional(),
-  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(),
-  // `defineOffer` returns `enabled: true`, and a deployment describes the module's default
-  // export and parses it again, so the output has to read back. Pause an offer in Console.
-  enabled: z5.literal(true).optional()
-}).strict().transform(({ enabled: _, ...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,
-    /**
-     * When an operator archived the offer, or `null`. Only management reads carry it and list an
-     * archived offer; it refuses new redemptions with `offer-paused` until it is restored.
-     */
-    archivedAt: z5.number().int().nonnegative().nullable().optional(),
-    /**
-     * The prerequisites the signed-in member has not met yet, so an app can show the offer locked
-     * and why. Empty when nothing is missing or the read has no member; redeeming while it is not
-     * empty fails with `prerequisites-incomplete`.
-     */
-    missing: z5.array(missingPrerequisiteSchema).default([])
-  })
-);
-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",
-    parseDefinition("Offer", offerAuthoringSchema, 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,
-  parseDefinition,
-  offerPriceSchema,
-  offerLimitSchema,
-  offerDefinitionSchema,
-  offerAuthoringSchema,
-  offerArtifactSchema,
-  offerAvailabilitySchema,
-  offerSchema,
-  redeemOfferSchema,
-  redemptionSchema,
-  redemptionQuerySchema,
-  redemptionPageSchema,
-  offerControlSchema,
-  redemptionCancellationSchema,
-  defineOffer
-};