@domino-sdk/relay 1.11.1 → 1.14.0

package/dist/chunk-UJACD6K2.js

@@ -0,0 +1,987 @@
+import {
+  authoringIdentityShape,
+  calendarPeriodSchema,
+  contentMetricSchema,
+  contentMetricsSchema,
+  identifier,
+  pageCursorSchema,
+  pointsRewardSchema,
+  refuseWindowTimeZone,
+  resourceHandle,
+  responseShape,
+  rewardKey,
+  tierRewardSchema
+} from "./chunk-46C33ASD.js";
+
+// src/point-ledgers.ts
+import { z } from "zod";
+var pointLedgerPropertiesSchema = z.object({
+  name: z.string().trim().min(1).max(120),
+  description: z.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()
+});
+var pointLedgerDeclarationSchema = pointLedgerPropertiesSchema.extend({ key: identifier }).strict();
+var pointLedgerArtifactSchema = z.union([
+  pointLedgerDeclarationSchema,
+  z.object({ code: z.string().min(1).max(2e6) }).strict()
+]);
+var pointLedgerReferenceSchema = z.object({
+  id: identifier,
+  key: identifier.nullable(),
+  name: z.string()
+});
+var points = z.number().int().safe();
+var pointBalanceSchema = z.object({
+  ledger: pointLedgerReferenceSchema,
+  balance: points,
+  available: points
+});
+var pointBalancesSchema = z.object({
+  items: z.array(pointBalanceSchema)
+});
+var PointEntryKind = {
+  /** Points a quest completion, an engagement settlement or an operator awarded. */
+  Award: "award",
+  /** Points the member spent. */
+  Spend: "spend",
+  /** A correction in either direction, by an operator or a referral payout. */
+  Adjust: "adjust",
+  /** 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({
+  id: identifier,
+  amount: points,
+  kind: pointEntryKindSchema,
+  /** When the entry took effect, in epoch milliseconds. A reversal keeps its source's. */
+  at: points.nonnegative(),
+  quest: identifier.nullable(),
+  reverses: identifier.nullable()
+});
+var pointHistoryQuerySchema = z.strictObject({
+  ledger: identifier,
+  cursor: pageCursorSchema.optional()
+});
+var pointHistoryPageSchema = z.object({
+  items: z.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"]),
+  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/profiles.ts
+import { z as z3 } from "zod";
+var count = z3.number().int().nonnegative().safe();
+var profileVisibilitySchema = z3.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(
+  (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(),
+    seed: avatarSeedSchema
+  }),
+  z3.object({
+    source: z3.literal("account"),
+    provider: avatarProviderSchema,
+    url: z3.string().url(),
+    seed: avatarSeedSchema
+  }),
+  z3.object({ source: z3.literal("generated"), seed: avatarSeedSchema })
+]);
+var profileSummarySchema = z3.object({
+  id: identifier,
+  name: z3.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 profileUpdateSchema = z3.object({
+  displayName: displayNameSchema.nullable().optional(),
+  avatar: z3.discriminatedUnion("source", [
+    z3.object({
+      source: z3.literal("account"),
+      provider: avatarProviderSchema
+    }).strict(),
+    z3.object({ source: z3.literal("generated") }).strict()
+  ]).nullable().optional(),
+  hidden: z3.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(),
+  /** The avatar the member chose: `default` follows the project's defaults. */
+  avatarChoice: z3.enum(["default", "upload", "account", "generated"]),
+  /** The account of an `account` choice. */
+  avatarProvider: avatarProviderSchema.nullable(),
+  hidden: z3.boolean(),
+  /** An operator locked the name and avatar; the member can still hide the profile. */
+  locked: z3.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({
+      provider: avatarProviderSchema,
+      name: z3.string().nullable(),
+      imageUrl: z3.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),
+  cursor: cursor.optional()
+}).strict();
+var profileCompletionSchema = z3.object({
+  quest: identifier,
+  key: identifier.optional(),
+  title: z3.string(),
+  completions: count.positive(),
+  /** Null for completions recorded before completion times were. */
+  lastCompletedAt: count.nullable()
+});
+var profileCompletionPageSchema = z3.object({
+  items: z3.array(profileCompletionSchema),
+  nextCursor: cursor.nullable()
+});
+var profileReferralSchema = z3.object({
+  program: identifier,
+  key: identifier.optional(),
+  title: z3.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() })
+  )
+});
+var profileSettingsSchema = z3.object({
+  visibility: profileVisibilitySchema,
+  defaults: profileDefaultsSchema,
+  revision: count,
+  actor: z3.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)
+}).strict();
+var profileModerationSchema = z3.object({
+  actionId: identifier,
+  resetName: z3.boolean().default(false),
+  removeAvatar: z3.boolean().default(false),
+  /** True locks the name and avatar, false unlocks them. */
+  lock: z3.boolean().optional(),
+  reason: z3.string().trim().min(1).max(1e3)
+}).strict().refine(
+  (value) => value.resetName || value.removeAvatar || value.lock !== void 0,
+  "Choose an action"
+);
+var managedProfileSchema = ownProfileSchema.omit({ options: true }).extend({
+  member: identifier,
+  lockedAt: count.nullable(),
+  lockedBy: z3.string().nullable(),
+  lockedReason: z3.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();
+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(),
+  // 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"),
+    /** 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()
+};
+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"),
+    window: leaderboardWindowSchema.default({ kind: "all-time" })
+  }).strict()
+]).default({ kind: "balance" });
+var leaderboardPrizeRewardSchema = z4.union([
+  pointsRewardSchema,
+  tierRewardSchema
+]);
+var leaderboardPrizeSchema = z4.object({
+  ranks: z4.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)
+}).strict();
+var leaderboardSettlementPolicySchema = z4.object({
+  at: z4.literal("window-end"),
+  ties: z4.enum(["shared", "earliest"]),
+  prizes: z4.array(leaderboardPrizeSchema).min(1).max(50)
+}).strict().superRefine((policy, context) => {
+  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 = z4.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z4.string().trim().min(1).max(120),
+  balance: identifier,
+  score: scoreSchema,
+  access: z4.enum(["participants", "public"]).default("participants"),
+  group: identifier.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: z4.preprocess(refuseWindowTimeZone, scoreSchema),
+  group: identifier.optional()
+}).strict().superRefine(validateSettlementWindow);
+var leaderboardArtifactSchema = z4.union([
+  leaderboardAuthoringSchema,
+  z4.object({ code: z4.string().min(1).max(2e6) }).strict()
+]);
+var publishedLeaderboardSchema = z4.object({
+  archivedAt: z4.number().int().nonnegative().nullable().optional(),
+  version: identifier,
+  definition: leaderboardDefinitionResponseSchema,
+  publishedAt: timestamp,
+  actor: z4.string().nullable()
+});
+var leaderboardQuerySchema = z4.object({
+  limit: z4.coerce.number().int().min(1).max(100).default(25),
+  cursor: z4.string().max(4096).optional()
+}).strict();
+var leaderboardRowSchema = z4.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(),
+  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({
+  leaderboard: identifier,
+  title: z4.string(),
+  version: identifier,
+  calculation: z4.enum(["balance", "earned", "net"]),
+  period: z4.object({ start: timestamp.nullable(), end: timestamp.nullable() }),
+  calculatedAt: timestamp,
+  lastEntryAt: timestamp.nullable(),
+  total: integer.nonnegative(),
+  items: z4.array(leaderboardRowSchema),
+  me: leaderboardRowSchema.nullable(),
+  nearby: z4.array(leaderboardRowSchema),
+  nextCursor: z4.string().nullable()
+});
+var leaderboardPlacementSchema = z4.object({
+  leaderboard: identifier,
+  key: identifier.optional(),
+  title: z4.string(),
+  profile: identifier,
+  rank: integer.positive().nullable(),
+  score: integer.nullable(),
+  /** Ranked participants on the board. */
+  total: integer.nonnegative()
+});
+var leaderboardPreviewSchema = z4.object({
+  published: publishedLeaderboardSchema,
+  before: leaderboardPageSchema.nullable(),
+  after: leaderboardPageSchema
+});
+var mutationBase = {
+  actionId: identifier,
+  member: identifier,
+  balance: identifier,
+  reason: z4.string().trim().min(1).max(1e3)
+};
+var datedMutation = { ...mutationBase, effectiveAt: timestamp.optional() };
+var pointsMutationSchema = z4.discriminatedUnion("kind", [
+  z4.object({
+    ...datedMutation,
+    kind: z4.literal("award"),
+    referralEligible: z4.boolean().optional(),
+    amount: integer.positive()
+  }).strict(),
+  z4.object({
+    ...datedMutation,
+    kind: z4.literal("spend"),
+    amount: integer.positive()
+  }).strict(),
+  z4.object({
+    ...datedMutation,
+    kind: z4.literal("adjust"),
+    amount: integer.refine((n) => n !== 0)
+  }).strict(),
+  z4.object({
+    ...datedMutation,
+    kind: z4.literal("set"),
+    total: integer.nonnegative(),
+    expectedTotal: integer.nonnegative(),
+    classification: z4.enum(["earned", "spend"])
+  }).strict(),
+  z4.object({
+    ...mutationBase,
+    kind: z4.literal("reverse"),
+    entry: identifier,
+    amount: integer.positive()
+  }).strict()
+]);
+var pointsEntrySchema = z4.object({
+  id: identifier,
+  completion: z4.string().nullable(),
+  member: identifier,
+  balance: identifier,
+  amount: integer,
+  kind: z4.enum(["award", "spend", "adjust", "reverse"]),
+  effectiveAt: timestamp,
+  receivedAt: timestamp,
+  quest: identifier.nullable(),
+  original: identifier.nullable(),
+  reason: z4.string(),
+  actor: z4.string().nullable()
+});
+var managedPointHistoryPageSchema = z4.object({
+  items: z4.array(pointsEntrySchema),
+  nextCursor: pageCursorSchema.nullable(),
+  /** @deprecated Use `nextCursor`, passed back as `cursor`. Removed in 2.0.0. */
+  next: z4.number().nullable()
+});
+var pointsResultSchema = z4.object({
+  entry: pointsEntrySchema,
+  total: integer.nonnegative()
+});
+var pointsAccountSchema = z4.object({
+  member: identifier,
+  balance: identifier,
+  total: integer.nonnegative(),
+  held: integer.nonnegative()
+});
+var leaderboardExclusionSchema = z4.object({
+  actionId: identifier,
+  member: identifier,
+  excluded: z4.boolean(),
+  reason: z4.string().trim().min(1).max(1e3)
+}).strict();
+var leaderboardGroupSchema = z4.object({
+  actionId: identifier,
+  member: identifier,
+  included: z4.boolean(),
+  reason: z4.string().trim().min(1).max(1e3)
+}).strict();
+var leaderboardSettlementStatusSchema = z4.enum(["pending", "approved"]);
+var leaderboardSettlementSummarySchema = z4.object({
+  id: identifier,
+  leaderboard: identifier,
+  version: identifier,
+  title: z4.string(),
+  period: z4.object({ start: timestamp, end: timestamp }),
+  ties: z4.enum(["shared", "earliest"]),
+  status: leaderboardSettlementStatusSchema,
+  total: integer.nonnegative(),
+  winners: integer.nonnegative(),
+  createdAt: timestamp,
+  approvedAt: timestamp.nullable(),
+  approvedBy: z4.string().nullable(),
+  approvalReason: z4.string().nullable()
+});
+var leaderboardSettlementRowSchema = z4.object({
+  member: identifier,
+  score: integer,
+  rank: integer.positive(),
+  position: integer.positive(),
+  scoredAt: timestamp,
+  prizes: z4.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)
+});
+var leaderboardSettlementApprovalSchema = z4.object({
+  actionId: identifier,
+  reason: z4.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({
+  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()
+  ]),
+  inviterGroup: identifier.optional(),
+  rewards: z5.object({
+    inviter: z5.array(rewardSchema).max(10).default([]),
+    invitee: z5.array(rewardSchema).max(10).default([])
+  }).strict().default({ inviter: [], invitee: [] }),
+  milestones: z5.array(
+    z5.object({
+      id: identifier,
+      count: amount2.min(1),
+      rewards: z5.array(rewardSchema).min(1).max(10)
+    }).strict()
+  ).max(30).default([]),
+  bonuses: z5.array(
+    z5.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),
+      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 = z5.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 = z5.union([
+  referralAuthoringSchema,
+  z5.object({ code: z5.string().min(1).max(2e6) }).strict()
+]);
+var publishedReferralSchema = z5.object({
+  archivedAt: z5.number().int().nonnegative().nullable().optional(),
+  version: identifier,
+  definition: referralDefinitionSchema,
+  publishedAt: amount2,
+  actor: z5.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"),
+    actionId: identifier,
+    member: identifier,
+    suspended: z5.boolean(),
+    reason
+  }).strict(),
+  z5.object({
+    kind: z5.literal("qualify"),
+    actionId: identifier,
+    member: identifier,
+    program: identifier,
+    qualified: z5.boolean(),
+    reason
+  }).strict(),
+  z5.object({
+    kind: z5.literal("resolve-reward"),
+    actionId: identifier,
+    entitlement: identifier,
+    reason
+  }).strict()
+]);
+var referralRelationshipSchema = z5.object({
+  member: identifier,
+  inviter: identifier,
+  acceptedAt: amount2,
+  suspended: z5.boolean()
+});
+var referralAccountSchema = z5.object({
+  id: identifier,
+  program: identifier,
+  kind: z5.enum(["bonus", "fixed", "milestone"]),
+  balance: identifier,
+  earned: amount2,
+  settled: amount2,
+  outstanding: amount2
+});
+var referralSummarySchema = z5.object({
+  code: identifier,
+  attributed: amount2,
+  programs: z5.array(
+    z5.object({
+      definition: referralDefinitionSchema,
+      qualified: amount2,
+      milestones: z5.array(
+        z5.object({ id: identifier, count: amount2, reached: z5.boolean() })
+      )
+    })
+  ),
+  accounts: z5.array(referralAccountSchema)
+});
+var referralHistorySchema = z5.object({
+  items: z5.array(
+    z5.object({
+      id: amount2,
+      program: identifier,
+      balance: identifier,
+      amount: z5.number().int().safe(),
+      at: amount2,
+      reason: z5.string()
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable()
+});
+var referralManagementSchema = z5.object({
+  relationships: z5.array(referralRelationshipSchema),
+  qualifications: z5.array(
+    z5.object({
+      member: identifier,
+      program: identifier,
+      qualified: z5.boolean(),
+      qualifiedAt: amount2
+    })
+  ),
+  accounts: z5.array(
+    referralAccountSchema.extend({ member: identifier, invitee: z5.string() })
+  ),
+  reviews: z5.array(
+    z5.object({
+      entitlement: identifier,
+      member: identifier,
+      program: identifier,
+      reason: z5.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 { z as z6 } from "zod";
+var quantity = z6.number().int().safe().nonnegative();
+var offerPriceSchema = pointsRewardSchema.extend({
+  amount: z6.number().int().positive().max(1e4)
+});
+var offerLimitSchema = z6.object({ perMember: z6.number().int().positive().max(1e4) }).strict();
+var offerDefinitionSchema = z6.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z6.string().trim().min(1).max(120),
+  price: offerPriceSchema,
+  reward: tierRewardSchema,
+  stock: quantity.max(1e6),
+  limit: offerLimitSchema.default({ perMember: 1 }),
+  enabled: z6.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()
+}).strict().transform((offer) => ({
+  ...offer,
+  title: offer.title ?? offer.reward.reward.title,
+  enabled: true
+}));
+var offerArtifactSchema = z6.union([
+  offerAuthoringSchema,
+  z6.object({ code: z6.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()
+  ])
+);
+var offerSchema = responseShape(
+  offerDefinitionSchema.extend({
+    revision: z6.number().int().positive(),
+    available: quantity,
+    redeemed: quantity,
+    availability: offerAvailabilitySchema
+  })
+);
+var redeemOfferSchema = z6.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: z6.number().int().positive(),
+  redeemedAt: z6.number().int().safe().nonnegative()
+};
+var redemptionSchema = responseShape(
+  z6.discriminatedUnion("status", [
+    z6.object({ ...redemptionBase, status: z6.literal("fulfilled") }).strict(),
+    z6.object({
+      ...redemptionBase,
+      status: z6.literal("canceled"),
+      canceledAt: z6.number().int().safe().nonnegative(),
+      reason: z6.string().min(1).max(500)
+    }).strict()
+  ])
+);
+var offerControlSchema = z6.object({
+  actionId: identifier,
+  revision: z6.number().int().positive(),
+  enabled: z6.boolean(),
+  reason: z6.string().trim().min(1).max(500)
+}).strict();
+var redemptionCancellationSchema = z6.object({
+  actionId: identifier,
+  revision: z6.number().int().positive(),
+  reason: z6.string().trim().min(1).max(500)
+}).strict();
+function defineOffer(input) {
+  return resourceHandle("offer", offerAuthoringSchema.parse(input));
+}
+
+export {
+  pointLedgerPropertiesSchema,
+  createPointLedgerSchema,
+  pointLedgerSchema,
+  managedPointLedgerSchema,
+  pointLedgerDeclarationSchema,
+  pointLedgerArtifactSchema,
+  pointLedgerReferenceSchema,
+  pointBalanceSchema,
+  pointBalancesSchema,
+  PointEntryKind,
+  pointEntrySchema,
+  pointHistoryQuerySchema,
+  pointHistoryPageSchema,
+  engagementBudgetSchema,
+  engagementDefinitionSchema,
+  engagementScoreInputSchema,
+  engagementScoreSchema,
+  engagementPublishSchema,
+  engagementRuleSchema,
+  engagementPageQuerySchema,
+  engagementSettlementSchema,
+  engagementPageSchema,
+  engagementChangePreviewInputSchema,
+  engagementChangeSchema,
+  engagementChangePreviewSchema,
+  engagementRuleVersionPageSchema,
+  engagementVersionPageSchema,
+  engagementVersionQuerySchema,
+  engagementBoundaryPageSchema,
+  engagementArtifactSchema,
+  engagementDeploymentEntrySchema,
+  profileVisibilitySchema,
+  avatarProviderSchema,
+  profileDefaultProviderSchema,
+  profileDefaultsSchema,
+  avatarSeedSchema,
+  profileAvatarSchema,
+  profileSummarySchema,
+  displayNameSchema,
+  profileUpdateSchema,
+  ownProfileSchema,
+  profileCompletionQuerySchema,
+  profileCompletionSchema,
+  profileCompletionPageSchema,
+  profileReferralSchema,
+  profileSettingsSchema,
+  profileSettingsInputSchema,
+  profileModerationSchema,
+  managedProfileSchema,
+  AVATAR_UPLOAD_LIMIT,
+  avatarUploadTypes,
+  leaderboardWindowSchema,
+  leaderboardPrizeRewardSchema,
+  leaderboardPrizeSchema,
+  leaderboardSettlementPolicySchema,
+  leaderboardDefinitionSchema,
+  leaderboardDefinitionResponseSchema,
+  leaderboardAuthoringSchema,
+  leaderboardArtifactSchema,
+  publishedLeaderboardSchema,
+  leaderboardQuerySchema,
+  leaderboardRowSchema,
+  leaderboardPageSchema,
+  leaderboardPlacementSchema,
+  leaderboardPreviewSchema,
+  pointsMutationSchema,
+  pointsEntrySchema,
+  managedPointHistoryPageSchema,
+  pointsResultSchema,
+  pointsAccountSchema,
+  leaderboardExclusionSchema,
+  leaderboardGroupSchema,
+  leaderboardSettlementStatusSchema,
+  leaderboardSettlementSummarySchema,
+  leaderboardSettlementRowSchema,
+  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,
+  offerControlSchema,
+  redemptionCancellationSchema,
+  defineOffer
+};