@domino-sdk/relay 1.11.1 → 1.14.0

package/dist/chunk-ZFABFKIY.js

@@ -1,1295 +0,0 @@
-import {
-  RequestError,
-  isRequestError
-} from "./chunk-NPGENI7K.js";
-import {
-  authoringIdentityShape,
-  calendarPeriodSchema,
-  contentMetricSchema,
-  contentMetricsSchema,
-  identifier,
-  pageCursorSchema,
-  pointsRewardSchema,
-  refuseWindowTimeZone,
-  resourceHandle,
-  responseShape,
-  rewardKey,
-  tierRewardSchema
-} from "./chunk-46C33ASD.js";
-
-// src/errors.ts
-import { z } from "zod";
-var RelayErrorCode = {
-  /** The call needs a signed-in member. */
-  NotSignedIn: "not-signed-in",
-  /** The session changed since the app read it (the `session` option). Reload before retrying. */
-  StaleSession: "stale-session",
-  /** The input failed validation before it was sent. */
-  InvalidInput: "invalid-input",
-  /** Relay's answer was not JSON or not the expected shape (kind `invalid-response`). */
-  InvalidResponse: "invalid-response",
-  /** The transport failed, before a response or while reading its body (kind `network`). */
-  Network: "network",
-  /** The client's deadline elapsed (kind `timeout`). */
-  Timeout: "timeout",
-  /** The caller cancelled the request (kind `aborted`). */
-  Aborted: "aborted",
-  /** A quest or collection the call named is not in the member's experience. */
-  NotFound: "not-found",
-  /** The quest has no failed attempt the member can retry. */
-  RetryUnavailable: "retry-unavailable",
-  /**
-   * Durable submission storage is missing, blocked or unreadable. Nothing was lost: call the
-   * handle's `status()` or `resume()` again once storage is available.
-   */
-  SubmissionStorage: "submission-storage",
-  /** Browser storage is full, so submission progress was not saved. Free space, then resume. */
-  SubmissionStorageQuota: "submission-storage-quota",
-  /** The saved submission is in a state that does not allow this action. */
-  SubmissionConflict: "submission-conflict",
-  /** The quest changed since the member saw it; review it before submitting again. */
-  QuestUpdated: "quest-updated",
-  /** Wait for the deferred attempt before submitting another action. */
-  AttemptPending: "attempt-pending",
-  /** The quiz changed since the member answered it. */
-  StaleQuiz: "stale-quiz",
-  /** Relay refused the submitted evidence. */
-  InvalidSubmission: "invalid-submission",
-  /** A page cursor Relay cannot read; start again from the first page. */
-  InvalidCursor: "invalid-cursor",
-  /** No point ledger in the project has the key or ID the call named. */
-  PointLedgerNotFound: "point-ledger-not-found",
-  /** The member has not joined this project, so it holds no points here. */
-  NotJoined: "not-joined",
-  /** The quest or campaign is not open at this time. */
-  OutsideWindow: "outside-window",
-  /** The signed-in member must enroll in the campaign first. */
-  EnrollmentRequired: "enrollment-required",
-  /** The quest's current reward budget has no remaining capacity. */
-  BudgetExhausted: "budget-exhausted",
-  /** No published offer has the key or ID the call named. */
-  OfferNotFound: "offer-not-found",
-  /** The operator paused this offer. */
-  OfferPaused: "offer-paused",
-  /** This member has already used the offer's allowed number of redemptions. */
-  OfferLimitReached: "offer-limit-reached",
-  /** No declared units remain. */
-  OfferOutOfStock: "offer-out-of-stock",
-  /** The participant's available point balance is below the offer price. */
-  InsufficientPoints: "insufficient-points",
-  /** A wallet signer failed or the member refused to sign; `cause` is the wallet's own error. */
-  WalletSigner: "wallet-signer",
-  /** The member has not met the quest's prerequisites; `missing` lists them. */
-  PrerequisitesIncomplete: "prerequisites-incomplete",
-  /** The quest is archived or retired: it takes no new participation. */
-  QuestClosed: "quest-closed",
-  /** An operator paused the quest. */
-  QuestPaused: "quest-paused",
-  /** An operator locked the member's profile; hiding it is still allowed. */
-  ProfileLocked: "profile-locked",
-  /** No member in the project has the invitation code the member accepted. */
-  InvitationNotFound: "invitation-not-found",
-  /** The email sign-in code is wrong; the member can type it again. */
-  InvalidCode: "invalid-code",
-  /** The email sign-in code expired, was used or had too many attempts; request another. */
-  CodeExpired: "code-expired",
-  /** The wallet sign-in challenge expired, was used or changed; start sign-in again. */
-  ChallengeExpired: "challenge-expired",
-  /** Too many requests; `retryAfter` says how long to wait when Relay knows. */
-  RateLimited: "rate-limited"
-};
-var relayErrorBrand = /* @__PURE__ */ Symbol.for("@domino-sdk/relay.RelayError");
-function isRelayError(value) {
-  return isRequestError(value) && value[relayErrorBrand] === true;
-}
-var RelayError = class extends RequestError {
-  name = "RelayError";
-  [relayErrorBrand] = true;
-  /** Which window refused admission when `code` is `outside-window`. */
-  window;
-  /** Prerequisites the member does not currently meet, when Relay refused for that reason. */
-  missing;
-  constructor(message, details) {
-    super(message, details);
-    this.window = details.window;
-    this.missing = details.missing ?? [];
-  }
-};
-function asRelayError(cause, fallback = "Request failed") {
-  if (isRelayError(cause)) {
-    return cause;
-  }
-  return new RelayError(
-    cause instanceof Error && cause.message ? cause.message : fallback,
-    { kind: "client", cause }
-  );
-}
-function clientError(message, code, details = {}) {
-  return new RelayError(message, { ...details, kind: "client", code });
-}
-function parseInput(schema, value) {
-  const parsed = schema.safeParse(value);
-  if (!parsed.success) {
-    throw clientError(
-      z.prettifyError(parsed.error),
-      RelayErrorCode.InvalidInput,
-      { cause: parsed.error }
-    );
-  }
-  return parsed.data;
-}
-
-// src/point-ledgers.ts
-import { z as z2 } from "zod";
-var pointLedgerPropertiesSchema = z2.object({
-  name: z2.string().trim().min(1).max(120),
-  description: z2.string().trim().max(1e3).default("")
-}).strict();
-var createPointLedgerSchema = pointLedgerPropertiesSchema.extend({ actionId: identifier, key: identifier.optional() }).strict();
-var pointLedgerSchema = pointLedgerPropertiesSchema.extend({
-  id: identifier
-});
-var managedPointLedgerSchema = pointLedgerSchema.extend({
-  archivedAt: 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()
-});
-var pointHistoryQuerySchema = z2.strictObject({
-  ledger: identifier,
-  cursor: pageCursorSchema.optional()
-});
-var pointHistoryPageSchema = z2.object({
-  items: z2.array(pointEntrySchema),
-  nextCursor: pageCursorSchema.nullable()
-});
-
-// src/engagement.ts
-import { z as z3 } from "zod";
-var amount = z3.number().int().safe().nonnegative();
-var engagementBudgetSchema = z3.strictObject({
-  scope: z3.enum(["member", "project"]),
-  period: calendarPeriodSchema,
-  limit: amount
-});
-var engagementDefinitionSchema = 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 { z 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 { z 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(),
-  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 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()
-});
-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 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 { z as z6 } from "zod";
-var rewardSchema = z6.union([pointsRewardSchema, tierRewardSchema]);
-var amount2 = z6.number().int().safe().nonnegative();
-var reason = z6.string().trim().min(1).max(1e3);
-var referralDefinitionSchema = z6.object({
-  id: identifier,
-  key: identifier.optional(),
-  title: 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 { z as z7 } from "zod";
-var quantity = z7.number().int().safe().nonnegative();
-var offerPriceSchema = pointsRewardSchema.extend({
-  amount: z7.number().int().positive().max(1e4)
-});
-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 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));
-}
-
-// src/wallet.ts
-import { z as z8 } from "zod";
-var solanaAddressSchema = z8.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
-var walletChainSchema = z8.enum(["solana", "eip155", "cosmos"]);
-var cosmosNetworkPattern = /^cosmos:[-_a-zA-Z0-9]{1,32}$/;
-var cosmosNetworkSchema = z8.custom(
-  (value) => typeof value === "string" && cosmosNetworkPattern.test(value),
-  "Use a Cosmos network: cosmos:<chain ID>"
-);
-var cosmosDenomSchema = z8.string().regex(
-  /^[a-zA-Z][a-zA-Z0-9/:._-]{2,127}$/,
-  "Use a Cosmos bank denomination such as uatom or uosmo"
-);
-function cosmosChain(chain) {
-  if (typeof chain === "string" && !chain.startsWith("cosmos:")) {
-    throw new Error('Use a Cosmos network such as "cosmos:cosmoshub-4"');
-  }
-  const value = typeof chain === "string" ? { chainId: chain.slice("cosmos:".length) } : chain;
-  if (typeof value?.chainId !== "string") {
-    throw new Error(
-      'Pass a Cosmos chain as { chainId } or a network such as "cosmos:cosmoshub-4"'
-    );
-  }
-  const network = `cosmos:${value.chainId}`;
-  if (!cosmosNetworkPattern.test(network)) {
-    throw new Error(
-      "A Cosmos chain ID has 1 to 32 letters, digits, hyphens or underscores"
-    );
-  }
-  if (value.chainInfo && value.chainInfo.chainId !== value.chainId) {
-    throw new Error("The chain info describes another chain ID");
-  }
-  return { ...value, network };
-}
-var solanaMainnet = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
-var evmAddressSchema = z8.string().regex(/^0x[0-9a-fA-F]{40}$/);
-var cosmosAddressSchema = z8.string().min(8).max(90).regex(
-  /^(?:[a-z][a-z0-9]{0,82}1[02-9ac-hj-np-z]{38,}|[A-Z][A-Z0-9]{0,82}1[02-9AC-HJ-NP-Z]{38,})$/
-);
-var walletAddressInputSchema = z8.discriminatedUnion("chain", [
-  z8.object({ chain: z8.literal("solana"), address: solanaAddressSchema }).strict(),
-  z8.object({
-    chain: z8.literal("eip155"),
-    address: evmAddressSchema,
-    /** Shown in the sign-in message's Chain ID line only: links are chain-agnostic. Defaults to 1. */
-    chainId: z8.number().int().positive().safe().optional()
-  }).strict(),
-  z8.object({
-    chain: z8.literal("cosmos"),
-    network: cosmosNetworkSchema,
-    address: cosmosAddressSchema
-  }).strict()
-]);
-var walletMessageChallengeSchema = z8.object({
-  id: z8.string().min(1).max(200),
-  purpose: z8.enum(["link", "sign-in"]),
-  chain: walletChainSchema,
-  network: cosmosNetworkSchema.nullable(),
-  /** Canonical (base58, EIP-55 or lowercase bech32). The signer must sign with this address. */
-  address: z8.string(),
-  message: z8.string().max(4096),
-  expiresAt: z8.number().int()
-});
-var walletSignatureSchema = z8.object({
-  challenge: z8.string().min(1).max(200),
-  /** solana: base58, 64 bytes · eip155: 0x and 130 hex digits (65 bytes) · cosmos: base64, 64 bytes (r‖s) */
-  signature: z8.string().min(1).max(256),
-  /** cosmos only: the base64 33-byte compressed secp256k1 key from signArbitrary's pub_key.value */
-  publicKey: z8.string().max(128).optional()
-}).strict();
-var linkedWalletSchema = z8.object({
-  chain: walletChainSchema,
-  network: cosmosNetworkSchema.nullable(),
-  address: z8.string(),
-  verifiedAt: z8.number().int().nonnegative(),
-  revision: z8.number().int().positive(),
-  /** True when this wallet can sign in: it was first used through wallet sign-in. Linking never enables sign-in. */
-  signIn: z8.boolean()
-});
-var walletUnlinkInputSchema = z8.object({ chain: walletChainSchema, address: z8.string().min(1).max(100) }).strict();
-async function walletAddressInput(signer) {
-  const address = await signer.address();
-  switch (signer.chain) {
-    case "solana":
-      return { chain: "solana", address };
-    case "eip155":
-      return {
-        chain: "eip155",
-        address,
-        ...signer.chainId ? { chainId: await signer.chainId() } : {}
-      };
-    case "cosmos":
-      if (!signer.network) {
-        throw clientError(
-          "Choose the Cosmos chain for this wallet",
-          RelayErrorCode.InvalidInput
-        );
-      }
-      return { chain: "cosmos", network: signer.network, address };
-  }
-}
-var WALLETS_PER_CHAIN = 5;
-var walletSignInFamilies = ["solana", "eip155", "cosmos"];
-var walletSignInNetworkSchema = z8.enum(walletSignInFamilies);
-var walletSignInNetworksSchema = z8.array(walletSignInNetworkSchema).max(walletSignInFamilies.length).refine((values) => new Set(values).size === values.length, {
-  message: "Duplicate wallet family"
-}).transform(
-  (values) => walletSignInFamilies.filter((family) => values.includes(family))
-);
-function walletSignInNetwork(wallet) {
-  return wallet.chain;
-}
-function caip10(wallet, network) {
-  if (wallet.chain === "cosmos") {
-    if (!wallet.network || network && network !== wallet.network) {
-      throw new Error("A Cosmos wallet belongs to its own network");
-    }
-    return `${wallet.network}:${wallet.address}`;
-  }
-  const selected = network ?? (wallet.chain === "solana" ? solanaMainnet : "eip155:1");
-  const valid = wallet.chain === "solana" ? /^solana:[1-9A-HJ-NP-Za-km-z]{32}$/.test(selected) : isEvmChainId(selected);
-  if (!valid) {
-    throw new Error(`Use a ${wallet.chain} network for this wallet`);
-  }
-  return `${selected}:${wallet.address}`;
-}
-function isEvmChainId(value) {
-  return /^eip155:[1-9][0-9]{0,15}$/.test(value);
-}
-var evmChainIdSchema = z8.custom(
-  (value) => typeof value === "string" && isEvmChainId(value),
-  'Use an EVM chain ID such as "eip155:8453"'
-);
-var units = z8.string().regex(/^(0|[1-9][0-9]*)$/);
-var walletBalanceSchema = responseShape(
-  z8.object({
-    /** Canonical CAIP-2 ID for Solana, EVM or a supported Cosmos SDK chain. */
-    chain: z8.string(),
-    /** The canonical mint, EIP-55 contract or Cosmos bank denom; null for a native coin. */
-    token: z8.string().nullable(),
-    /** Null when token metadata does not report decimals. */
-    decimals: z8.number().int().min(0).max(255).nullable(),
-    /** The sum over `wallets`. */
-    total: units,
-    wallets: z8.array(
-      z8.object({ address: z8.string(), amount: units }).strict()
-    ),
-    /** Solana: lowest slot. EVM: approximate latest block. Cosmos: the fixed queried block. */
-    at: z8.object({ kind: z8.enum(["slot", "block"]), number: units }).strict(),
-    observedAt: z8.number().int().nonnegative()
-  }).strict()
-);
-
-export {
-  RelayErrorCode,
-  isRelayError,
-  RelayError,
-  asRelayError,
-  clientError,
-  parseInput,
-  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,
-  solanaAddressSchema,
-  walletChainSchema,
-  cosmosNetworkSchema,
-  cosmosDenomSchema,
-  cosmosChain,
-  solanaMainnet,
-  evmAddressSchema,
-  cosmosAddressSchema,
-  walletAddressInputSchema,
-  walletMessageChallengeSchema,
-  walletSignatureSchema,
-  linkedWalletSchema,
-  walletUnlinkInputSchema,
-  walletAddressInput,
-  WALLETS_PER_CHAIN,
-  walletSignInFamilies,
-  walletSignInNetworkSchema,
-  walletSignInNetworksSchema,
-  walletSignInNetwork,
-  caip10,
-  isEvmChainId,
-  evmChainIdSchema,
-  walletBalanceSchema
-};