@domino-sdk/relay 0.5.0 → 0.7.0

package/dist/{chunk-LUCL63DS.js → chunk-LXLNC4CN.js}

@@ -10,12 +10,12 @@ import {
   referralDefinitionSchema,
   referralHistorySchema,
   referralSummarySchema
-} from "./chunk-TXL43HL3.js";
+} from "./chunk-TYVT5BPZ.js";
 import {
   authScopeSchema,
   exchangeResultSchema,
   sessionSchema
-} from "./chunk-QWRSUSNB.js";
+} from "./chunk-36LZ3IOO.js";
 import {
   accountConnectionSchema,
   attemptSchema,
@@ -39,7 +39,36 @@ import {
   settingsValuesSchema,
   snapshotSchema,
   templateSchema
-} from "./chunk-3IQ4KUKF.js";
+} from "./chunk-6QUCADMF.js";
+
+// src/point-ledgers.ts
+import { z } from "zod";
+var pointLedgerSchema = z.object({
+  id: identifier,
+  name: z.string().trim().min(1).max(120),
+  description: z.string().trim().max(1e3).default("")
+}).strict();
+
+// src/reward-deliveries.ts
+import { z as z2 } from "zod";
+var rewardDeliverySchema = z2.object({
+  id: z2.string(),
+  quest: z2.string(),
+  completion: z2.string(),
+  member: z2.string(),
+  provider: z2.literal("discord"),
+  action: z2.literal("grant-role"),
+  roleId: z2.string(),
+  status: z2.enum(["pending", "delivered"]),
+  attempts: z2.number().int(),
+  nextAt: z2.number(),
+  lastError: z2.string().nullable(),
+  createdAt: z2.number(),
+  deliveredAt: z2.number().nullable()
+});
+var rewardDeliveriesSchema = z2.object({
+  deliveries: z2.array(rewardDeliverySchema)
+});
 
 // src/resource-id.ts
 var alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -55,8 +84,8 @@ function resourceId(prefix) {
 }
 
 // src/catalog.ts
-import { z } from "zod";
-var interactionSchema = z.enum([
+import { z as z3 } from "zod";
+var interactionSchema = z3.enum([
   "photo",
   "quiz",
   "claim",
@@ -66,103 +95,103 @@ var interactionSchema = z.enum([
 function questInteraction(trigger) {
   return trigger.kind === "automatic" ? "automatic" : trigger.actor === "staff" ? "staff" : trigger.input === "none" ? "claim" : trigger.input;
 }
-var questTypeVersionSchema = z.object({
+var questTypeVersionSchema = z3.object({
   id: identifier,
   version: identifier,
-  code: z.string(),
+  code: z3.string(),
   definition: questDescriptionSchema,
   provider: reviewModeSchema,
-  createdAt: z.number()
+  createdAt: z3.number()
 });
-var collectionSlotSchema = z.object({ id: identifier, title: z.string().trim().min(1).max(120) }).strict();
+var collectionSlotSchema = z3.object({ id: identifier, title: z3.string().trim().min(1).max(120) }).strict();
 var questCollectionSchema = collectionSlotSchema.extend({
-  quests: z.array(identifier).max(100).refine(
+  quests: z3.array(identifier).max(100).refine(
     (v) => new Set(v).size === v.length,
     "A collection can contain a quest only once"
   )
 });
-var questInstanceSchema = z.object({
+var questInstanceSchema = z3.object({
   id: identifier,
-  title: z.string().trim().min(1).max(120),
+  title: z3.string().trim().min(1).max(120),
   typeVersion: identifier,
   settings: settingsValuesSchema,
-  requires: z.array(identifier).max(30),
-  status: z.enum(["active", "paused", "archived"])
+  requires: z3.array(identifier).max(30),
+  status: z3.enum(["active", "paused", "archived"])
 }).strict();
-var questDraftChangesSchema = z.object({
-  quests: z.array(
+var questDraftChangesSchema = z3.object({
+  quests: z3.array(
     questInstanceSchema.extend({ expectedRelease: identifier.nullable() })
   ).max(50),
-  collections: z.array(questCollectionSchema).max(50)
+  collections: z3.array(questCollectionSchema).max(50)
 }).strict();
-var draftBase = z.object({
+var draftBase = z3.object({
   id: identifier,
-  revision: z.number().int().positive(),
-  baseRevision: z.number().int().nonnegative(),
+  revision: z3.number().int().positive(),
+  baseRevision: z3.number().int().nonnegative(),
   changes: questDraftChangesSchema
 });
-var questDraftSchema = z.discriminatedUnion("status", [
-  draftBase.extend({ status: z.literal("draft") }),
+var questDraftSchema = z3.discriminatedUnion("status", [
+  draftBase.extend({ status: z3.literal("draft") }),
   draftBase.extend({
-    status: z.literal("published"),
-    releaseIds: z.array(identifier)
+    status: z3.literal("published"),
+    releaseIds: z3.array(identifier)
   })
 ]);
-var questCatalogSchema = z.object({
-  revision: z.number().int().nonnegative(),
-  types: z.array(questTypeVersionSchema),
-  collections: z.array(questCollectionSchema),
-  quests: z.array(questInstanceSchema),
-  drafts: z.array(questDraftSchema),
-  releases: z.array(publishedReleaseSchema).default([]),
-  supportedInteractions: z.array(interactionSchema)
+var questCatalogSchema = z3.object({
+  revision: z3.number().int().nonnegative(),
+  types: z3.array(questTypeVersionSchema),
+  collections: z3.array(questCollectionSchema),
+  quests: z3.array(questInstanceSchema),
+  drafts: z3.array(questDraftSchema),
+  releases: z3.array(publishedReleaseSchema).default([]),
+  supportedInteractions: z3.array(interactionSchema)
 });
-var catalogDeploymentSchema = z.object({
-  expectedRevision: z.number().int().nonnegative(),
-  types: z.array(
-    z.object({
-      code: z.string().min(1).max(1e6),
+var catalogDeploymentSchema = z3.object({
+  expectedRevision: z3.number().int().nonnegative(),
+  types: z3.array(
+    z3.object({
+      code: z3.string().min(1).max(1e6),
       provider: reviewModeSchema
     })
   ).max(50).default([]),
-  collections: z.array(collectionSlotSchema).max(50).default([]),
-  supportedInteractions: z.array(interactionSchema).min(1).optional()
+  collections: z3.array(collectionSlotSchema).max(50).default([]),
+  supportedInteractions: z3.array(interactionSchema).min(1).optional()
 }).strict();
-var catalogDeploymentPreviewSchema = z.object({
-  revision: z.number().int().nonnegative(),
-  types: z.array(questTypeVersionSchema),
-  collections: z.array(collectionSlotSchema),
-  supportedInteractions: z.array(interactionSchema)
+var catalogDeploymentPreviewSchema = z3.object({
+  revision: z3.number().int().nonnegative(),
+  types: z3.array(questTypeVersionSchema),
+  collections: z3.array(collectionSlotSchema),
+  supportedInteractions: z3.array(interactionSchema)
 });
-var saveQuestDraftSchema = z.object({
+var saveQuestDraftSchema = z3.object({
   id: identifier,
-  expectedRevision: z.number().int().nonnegative(),
-  baseRevision: z.number().int().nonnegative(),
+  expectedRevision: z3.number().int().nonnegative(),
+  baseRevision: z3.number().int().nonnegative(),
   changes: questDraftChangesSchema
 }).strict();
-var publishQuestDraftSchema = z.object({ id: identifier, expectedRevision: z.number().int().positive() }).strict();
+var publishQuestDraftSchema = z3.object({ id: identifier, expectedRevision: z3.number().int().positive() }).strict();
 var questViewSchema = memberProgressSchema.shape.quests.element.extend(
   {
     release: identifier,
     interaction: interactionSchema,
-    lifecycle: z.enum(["active", "paused", "archived"]),
-    rewards: z.array(z.object({ label: z.string() }))
+    lifecycle: z3.enum(["active", "paused", "archived"]),
+    rewards: z3.array(z3.object({ label: z3.string() }))
   }
 );
-var collectionViewSchema = z.object({
+var collectionViewSchema = z3.object({
   id: identifier,
-  title: z.string(),
-  quests: z.array(questViewSchema)
+  title: z3.string(),
+  quests: z3.array(questViewSchema)
 });
-var questExperienceSchema = z.object({
+var questExperienceSchema = z3.object({
   member: identifier,
-  quests: z.array(questViewSchema),
-  collections: z.array(collectionViewSchema)
+  quests: z3.array(questViewSchema),
+  collections: z3.array(collectionViewSchema)
 });
-var questPublicationPreviewSchema = z.object({
+var questPublicationPreviewSchema = z3.object({
   draft: questDraftSchema,
-  releases: z.array(publishedReleaseSchema),
-  affectedCollections: z.array(questCollectionSchema)
+  releases: z3.array(publishedReleaseSchema),
+  affectedCollections: z3.array(questCollectionSchema)
 });
 
 // src/errors.ts
@@ -179,43 +208,43 @@ var RelayError = class extends Error {
 };
 
 // src/submissions.ts
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 var common = {
   id: identifier,
   quest: identifier,
   release: identifier.optional()
 };
-var claimInputSchema = z2.union([
+var claimInputSchema = z4.union([
   quizEvidenceSchema,
-  z2.object({ kind: z2.literal("none") }).strict()
+  z4.object({ kind: z4.literal("none") }).strict()
 ]);
-var draftSchema = z2.union([
+var draftSchema = z4.union([
   claimInputSchema,
-  z2.object({ kind: z2.literal("photo"), file: z2.instanceof(Blob) })
+  z4.object({ kind: z4.literal("photo"), file: z4.instanceof(Blob) })
 ]);
-var recordSchema = z2.union([
-  z2.object({
+var recordSchema = z4.union([
+  z4.object({
     ...common,
-    stage: z2.literal("review"),
+    stage: z4.literal("review"),
     draft: draftSchema.nullable()
   }),
-  z2.object({ ...common, stage: z2.literal("upload"), file: z2.instanceof(Blob) }),
-  z2.object({
+  z4.object({ ...common, stage: z4.literal("upload"), file: z4.instanceof(Blob) }),
+  z4.object({
     ...common,
-    stage: z2.literal("claim"),
+    stage: z4.literal("claim"),
     evidence: identifier,
-    file: z2.instanceof(Blob).optional()
+    file: z4.instanceof(Blob).optional()
   }),
-  z2.object({
+  z4.object({
     ...common,
-    stage: z2.literal("submitted"),
+    stage: z4.literal("submitted"),
     evidence: identifier,
     attempt: identifier
   }),
-  z2.object({ ...common, stage: z2.literal("claim"), input: claimInputSchema }),
-  z2.object({
+  z4.object({ ...common, stage: z4.literal("claim"), input: claimInputSchema }),
+  z4.object({
     ...common,
-    stage: z2.literal("submitted"),
+    stage: z4.literal("submitted"),
     input: claimInputSchema,
     attempt: identifier
   })
@@ -348,7 +377,8 @@ function submissions(transport, configuredStore, namespace) {
           const previous = await claim(existing);
           if (previous.status === "failed")
             return transport.retry(previous.id, sessionId);
-          if (previous.status !== "rejected") return previous;
+          if (previous.status !== "rejected" && !(options.repeatable && previous.status === "accepted"))
+            return previous;
         }
         await store.write(key, record);
         return resumeRecord(record);
@@ -365,7 +395,7 @@ function submissions(transport, configuredStore, namespace) {
               "Resume the unfinished submission before starting over."
             );
           const attempt = await claim(record);
-          if (attempt.status !== "failed" && attempt.status !== "rejected")
+          if (attempt.status !== "failed" && attempt.status !== "rejected" && !(options.repeatable && attempt.status === "accepted"))
             throw new Error(
               "Only a failed or rejected submission can be discarded."
             );
@@ -486,7 +516,8 @@ function questActions(submission, latest) {
       const handle = await submission(view.quest, {
         input: "none",
         release: view.release,
-        recoverPrevious: true
+        recoverPrevious: true,
+        repeatable: view.completion.kind === "keyed"
       });
       return {
         kind: "status",
@@ -501,7 +532,8 @@ function questActions(submission, latest) {
         const handle = await submission(view.quest, {
           input: "photo",
           release: view.release,
-          recoverPrevious: true
+          recoverPrevious: true,
+          repeatable: view.completion.kind === "keyed"
         });
         return {
           kind: "photo",
@@ -516,7 +548,8 @@ function questActions(submission, latest) {
         const handle = await submission(view.quest, {
           input: "quiz",
           release: view.release,
-          recoverPrevious: true
+          recoverPrevious: true,
+          repeatable: view.completion.kind === "keyed"
         });
         return {
           kind: "quiz",
@@ -531,7 +564,8 @@ function questActions(submission, latest) {
         const handle = await submission(view.quest, {
           input: "none",
           release: view.release,
-          recoverPrevious: true
+          recoverPrevious: true,
+          repeatable: view.completion.kind === "keyed"
         });
         return {
           kind: "claim",
@@ -624,56 +658,56 @@ function observeProgress(transport, listener, options = {}, onDispose = () => {
 }
 
 // src/index.ts
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 
 // src/wallet.ts
-import { z as z3 } from "zod";
-var solanaAddressSchema = z3.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
-var walletConnectionSchema = z3.object({
-  chain: z3.literal("solana"),
+import { z as z5 } from "zod";
+var solanaAddressSchema = z5.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
+var walletConnectionSchema = z5.object({
+  chain: z5.literal("solana"),
   address: solanaAddressSchema,
-  verifiedAt: z3.number().int().nonnegative(),
-  revision: z3.number().int().positive()
+  verifiedAt: z5.number().int().nonnegative(),
+  revision: z5.number().int().positive()
 }).strict();
-var walletChallengeInputSchema = z3.object({
-  chain: z3.literal("solana"),
+var walletChallengeInputSchema = z5.object({
+  chain: z5.literal("solana"),
   address: solanaAddressSchema
 }).strict();
 var walletChallengeSchema = walletChallengeInputSchema.extend({
-  id: z3.string().uuid(),
-  message: z3.string(),
-  expiresAt: z3.number()
+  id: z5.string().uuid(),
+  message: z5.string(),
+  expiresAt: z5.number()
 });
-var walletProofSchema = z3.object({
-  challenge: z3.string().uuid(),
-  signature: z3.string().min(64).max(88).regex(/^[1-9A-HJ-NP-Za-km-z]+$/)
+var walletProofSchema = z5.object({
+  challenge: z5.string().uuid(),
+  signature: z5.string().min(64).max(88).regex(/^[1-9A-HJ-NP-Za-km-z]+$/)
 }).strict();
-var solanaBalanceSchema = z3.object({
+var solanaBalanceSchema = z5.object({
   address: solanaAddressSchema,
-  network: z3.literal("mainnet-beta"),
-  lamports: z3.string().regex(/^(0|[1-9][0-9]*)$/),
-  slot: z3.number().int().nonnegative().safe(),
-  observedAt: z3.number().int().nonnegative()
+  network: z5.literal("mainnet-beta"),
+  lamports: z5.string().regex(/^(0|[1-9][0-9]*)$/),
+  slot: z5.number().int().nonnegative().safe(),
+  observedAt: z5.number().int().nonnegative()
 }).strict();
 
 // src/collection.ts
-import { z as z4 } from "zod";
-var collectionCodeSchema = z4.string().regex(/^relay:collect:[a-f0-9]{64}$/);
-var collectionPassSchema = z4.object({
+import { z as z6 } from "zod";
+var collectionCodeSchema = z6.string().regex(/^relay:collect:[a-f0-9]{64}$/);
+var collectionPassSchema = z6.object({
   code: collectionCodeSchema,
-  expiresAt: z4.number(),
+  expiresAt: z6.number(),
   entitlement: identifier
 });
-var collectionResolveSchema = z4.object({ code: collectionCodeSchema }).strict();
+var collectionResolveSchema = z6.object({ code: collectionCodeSchema }).strict();
 var collectionBeginSchema = collectionResolveSchema.extend({
   actionId: identifier,
-  revision: z4.number().int().positive(),
+  revision: z6.number().int().positive(),
   selection: pickupSelectionSchema.optional()
 });
-var collectionPreviewSchema = z4.object({
+var collectionPreviewSchema = z6.object({
   entitlement: entitlementSchema,
   inventory: pickupAvailabilitySchema,
-  expiresAt: z4.number()
+  expiresAt: z6.number()
 });
 
 // src/configuration.ts
@@ -691,53 +725,53 @@ function questConfiguration(release) {
 }
 
 // src/deployments.ts
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 var projectCatalogArtifactSchema = catalogDeploymentSchema.omit({ expectedRevision: true }).extend({
-  referrals: z5.array(referralArtifactSchema).max(50).default([]),
-  leaderboards: z5.array(leaderboardArtifactSchema).max(50).default([])
+  referrals: z7.array(referralArtifactSchema).max(50).default([]),
+  leaderboards: z7.array(leaderboardArtifactSchema).max(50).default([])
 });
-var projectDeploymentSchema = projectCatalogArtifactSchema.extend({ releases: z5.array(releaseSchema).max(50).default([]) }).refine(
+var projectDeploymentSchema = projectCatalogArtifactSchema.extend({ releases: z7.array(releaseSchema).max(50).default([]) }).refine(
   (value) => value.releases.length > 0 || value.leaderboards.length > 0 || value.referrals.length > 0 || value.types.length > 0 || value.collections.length > 0 || value.supportedInteractions !== void 0,
   "No resources configured. Add quests, questTypes, leaderboards, collections, or supportedInteractions to relay.json."
 );
-var deploymentPreviewSchema = z5.object({
+var deploymentPreviewSchema = z7.object({
   id: identifier,
-  baseRevision: z5.number().int().nonnegative(),
-  releases: z5.array(publishedReleaseSchema),
-  types: z5.array(questTypeVersionSchema),
-  collections: z5.array(questCollectionSchema),
-  supportedInteractions: z5.array(interactionSchema),
-  referrals: z5.array(publishedReferralSchema).default([]),
-  leaderboards: z5.array(leaderboardPreviewSchema).default([])
+  baseRevision: z7.number().int().nonnegative(),
+  releases: z7.array(publishedReleaseSchema),
+  types: z7.array(questTypeVersionSchema),
+  collections: z7.array(questCollectionSchema),
+  supportedInteractions: z7.array(interactionSchema),
+  referrals: z7.array(publishedReferralSchema).default([]),
+  leaderboards: z7.array(leaderboardPreviewSchema).default([])
 });
-var publishDeploymentSchema = z5.object({ id: identifier }).strict();
+var publishDeploymentSchema = z7.object({ id: identifier }).strict();
 var deploymentResultSchema = deploymentPreviewSchema.extend({
-  revision: z5.number().int().positive()
+  revision: z7.number().int().positive()
 });
 
 // src/identity-integration.ts
-import { z as z6 } from "zod";
-var identityIntegrationInputSchema = z6.object({
-  name: z6.string().trim().min(1).max(80),
-  origin: z6.string().url().refine((value) => {
+import { z as z8 } from "zod";
+var identityIntegrationInputSchema = z8.object({
+  name: z8.string().trim().min(1).max(80),
+  origin: z8.string().url().refine((value) => {
     const url = new URL(value);
     return url.protocol === "https:" && url.origin === value;
   }, "Use an exact HTTPS application origin")
 }).strict();
 var identityIntegrationSchema = authScopeSchema.extend({
-  id: z6.string().uuid(),
-  name: z6.string(),
-  origin: z6.string(),
-  expiresAt: z6.number()
+  id: z8.string().uuid(),
+  name: z8.string(),
+  origin: z8.string(),
+  expiresAt: z8.number()
 });
 var identityIntegrationSecretSchema = identityIntegrationSchema.extend(
   {
-    token: z6.string()
+    token: z8.string()
   }
 );
-var participantExchangeSchema = z6.object({
-  subject: z6.string().min(1).max(200),
-  previousToken: z6.string().max(200).optional()
+var participantExchangeSchema = z8.object({
+  subject: z8.string().min(1).max(200),
+  previousToken: z8.string().max(200).optional()
 }).strict();
 
 // src/index.ts
@@ -850,19 +884,19 @@ function createRelayClient(options) {
   }
   return {
     referrals: {
-      list: () => request("/v1/referrals", z7.array(referralDefinitionSchema)),
+      list: () => request("/v1/referrals", z9.array(referralDefinitionSchema)),
       summary: () => request("/v1/referrals/me", referralSummarySchema),
       history: (before) => request(
         query("/v1/referrals/history", { before }),
         referralHistorySchema
       ),
-      accept: (input) => request("/v1/referrals/accept", z7.object({ ok: z7.literal(true) }), {
+      accept: (input) => request("/v1/referrals/accept", z9.object({ ok: z9.literal(true) }), {
         method: "POST",
         body: JSON.stringify(referralAcceptSchema.parse(input))
       })
     },
     leaderboards: {
-      list: () => request("/v1/leaderboards", z7.array(leaderboardDefinitionSchema)),
+      list: () => request("/v1/leaderboards", z9.array(leaderboardDefinitionSchema)),
       standings: (board, options2 = {}) => {
         const parsed = leaderboardQuerySchema.parse(options2);
         return request(
@@ -874,6 +908,10 @@ function createRelayClient(options) {
     quests: {
       get: getQuest,
       retry: async (view) => {
+        if (view.trigger.kind === "automatic")
+          throw new Error(
+            "Automatic quests recover without participant retries."
+          );
         if (!view.attempt || view.attempt.status !== "failed")
           throw new Error("There is no failed attempt to retry.");
         const session = await request(
@@ -938,25 +976,25 @@ function createRelayClient(options) {
     auth: {
       providers: () => request(
         "/v1/auth/providers",
-        z7.object({
-          providers: z7.array(
-            z7.object({
+        z9.object({
+          providers: z9.array(
+            z9.object({
               provider: authProviderSchema,
-              configured: z7.boolean()
+              configured: z9.boolean()
             })
           ),
-          email: z7.boolean(),
-          demo: z7.boolean()
+          email: z9.boolean(),
+          demo: z9.boolean()
         })
       ),
       start: (provider, mode) => request(
         "/v1/auth/start",
-        z7.object({ url: z7.string() }),
+        z9.object({ url: z9.string() }),
         json({ provider, mode })
       ),
       emailStart: (email) => request(
         "/v1/auth/email/start",
-        z7.object({ challenge: z7.string() }),
+        z9.object({ challenge: z9.string() }),
         json({ email })
       ),
       emailVerify: (challenge, code) => changeSession(
@@ -966,25 +1004,25 @@ function createRelayClient(options) {
           json({ challenge, code })
         )
       ),
-      accounts: () => request("/v1/auth/accounts", z7.array(accountConnectionSchema)),
+      accounts: () => request("/v1/auth/accounts", z9.array(accountConnectionSchema)),
       disconnect: (provider) => request(
         "/v1/auth/accounts/disconnect",
-        z7.object({ ok: z7.boolean() }),
+        z9.object({ ok: z9.boolean() }),
         json({ provider })
       ),
       connections: () => request(
         "/v1/auth/connections",
-        z7.array(
-          z7.object({
-            provider: z7.string(),
-            subject: z7.string(),
-            signInEnabled: z7.boolean()
+        z9.array(
+          z9.object({
+            provider: z9.string(),
+            subject: z9.string(),
+            signInEnabled: z9.boolean()
           })
         )
       ),
       session: () => request("/v1/auth/session", sessionSchema.nullable()),
       signOut: () => changeSession(
-        () => request("/v1/auth/logout", z7.object({ ok: z7.boolean() }), json({}))
+        () => request("/v1/auth/logout", z9.object({ ok: z9.boolean() }), json({}))
       ),
       /** Local development only. Existing hosted apps use createParticipantBackend from /portal-proxy. */
       exchange: (input) => request("/v1/auth/exchange", exchangeResultSchema, json(input))
@@ -1018,6 +1056,7 @@ function createRelayClient(options) {
       }),
       linkPass: (code) => request("/v1/me/pass", attemptSchema, json({ code })),
       progress: () => request("/v1/me/progress", memberProgressSchema),
+      rewardDeliveries: () => request("/v1/reward-deliveries", rewardDeliveriesSchema),
       claim: (input, options2) => request("/v1/me/attempts", attemptSchema, {
         ...json(input),
         headers: {
@@ -1059,16 +1098,16 @@ function createRelayClient(options) {
     },
     lookupMember: (issuer, subject) => request(
       "/v1/members/lookup",
-      z7.object({ member: z7.string() }),
+      z9.object({ member: z9.string() }),
       json({ issuer, subject })
     ),
-    journeyTemplate: () => request("/v1/journey-template", z7.array(templateSchema)),
+    journeyTemplate: () => request("/v1/journey-template", z9.array(templateSchema)),
     template: () => request("/v1/template", templateSchema),
     snapshot: () => request("/v1/snapshot", snapshotSchema),
     publish: (release) => request("/v1/releases", publishedReleaseSchema, json(release)),
     publishBatch: (releases) => request(
       "/v1/releases/batch",
-      z7.array(publishedReleaseSchema),
+      z9.array(publishedReleaseSchema),
       json({ releases })
     ),
     progress: (member) => request(
@@ -1093,6 +1132,9 @@ function createRelayClient(options) {
 }
 
 export {
+  pointLedgerSchema,
+  rewardDeliverySchema,
+  rewardDeliveriesSchema,
   resourceId,
   interactionSchema,
   questInteraction,

package/dist/{chunk-TXL43HL3.js → chunk-TYVT5BPZ.js}

@@ -1,10 +1,12 @@
 import {
   identifier,
-  rewardSchema
-} from "./chunk-3IQ4KUKF.js";
+  pointsRewardSchema,
+  tierRewardSchema
+} from "./chunk-6QUCADMF.js";
 
 // src/referrals.ts
 import { z } from "zod";
+var rewardSchema = z.union([pointsRewardSchema, tierRewardSchema]);
 var amount = z.number().int().safe().nonnegative();
 var reason = z.string().trim().min(1).max(1e3);
 var referralDefinitionSchema = z.object({