@domino-sdk/relay 1.53.1 → 1.55.0

package/dist/chunk-CCE2JWES.js

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