@domino-sdk/relay 0.7.0 → 0.9.0

package/dist/chunk-Q5VDZVVO.js

@@ -0,0 +1,388 @@
+import {
+  identifier,
+  pointsRewardSchema,
+  tierRewardSchema
+} from "./chunk-XTFCKK2Y.js";
+
+// src/authoring-identity.ts
+import { z } from "zod";
+var authoringIdentityShape = {
+  key: identifier.optional(),
+  id: identifier.optional()
+};
+function validateAuthoringIdentity(value, ctx) {
+  if (!value.key && !value.id)
+    ctx.addIssue({
+      code: "custom",
+      path: ["key"],
+      message: "Provide an authoring key. Legacy id is also accepted."
+    });
+  if (value.key && value.id && value.key !== value.id)
+    ctx.addIssue({
+      code: "custom",
+      path: ["key"],
+      message: "id and key must match. Keep the existing authoring name to preserve identity."
+    });
+}
+function normalizeAuthoringIdentity(value) {
+  const { id, key, ...properties } = value;
+  return { ...properties, key: identifier.parse(key ?? id) };
+}
+var identitySchema = z.object(authoringIdentityShape).superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
+var authoringKey = (input) => identitySchema.parse(input).key;
+
+// src/referrals.ts
+import { z as z2 } from "zod";
+var rewardSchema = z2.union([pointsRewardSchema, tierRewardSchema]);
+var amount = z2.number().int().safe().nonnegative();
+var reason = z2.string().trim().min(1).max(1e3);
+var referralDefinitionSchema = z2.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z2.string().trim().min(1).max(120),
+  enabled: z2.boolean().default(true),
+  qualification: z2.discriminatedUnion("kind", [
+    z2.object({ kind: z2.literal("signup") }).strict(),
+    z2.object({ kind: z2.literal("quest"), quest: identifier }).strict(),
+    z2.object({ kind: z2.literal("external") }).strict()
+  ]),
+  inviterGroup: identifier.optional(),
+  rewards: z2.object({
+    inviter: z2.array(rewardSchema).max(10).default([]),
+    invitee: z2.array(rewardSchema).max(10).default([])
+  }).strict().default({ inviter: [], invitee: [] }),
+  milestones: z2.array(
+    z2.object({
+      id: identifier,
+      count: amount.min(1),
+      rewards: z2.array(rewardSchema).min(1).max(10)
+    }).strict()
+  ).max(30).default([]),
+  bonuses: z2.array(
+    z2.object({
+      id: identifier,
+      balance: identifier,
+      basisPoints: amount.min(1).max(1e4),
+      quests: z2.array(identifier).min(1).max(100).optional(),
+      external: z2.boolean().default(false),
+      durationDays: amount.min(1).max(36500).optional(),
+      maxPoints: amount.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 = z2.object(referralDefinitionSchema.shape).omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).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" });
+}).transform(normalizeAuthoringIdentity);
+function defineReferral(input) {
+  const definition = referralAuthoringSchema.parse(input);
+  return {
+    ...definition,
+    /** @deprecated Use key. */
+    id: definition.key
+  };
+}
+var referralArtifactSchema = z2.union([
+  referralAuthoringSchema,
+  z2.object({ code: z2.string().min(1).max(2e6) }).strict()
+]);
+var publishedReferralSchema = z2.object({
+  version: identifier,
+  definition: referralDefinitionSchema,
+  publishedAt: amount,
+  actor: z2.string().nullable()
+});
+var referralAcceptSchema = z2.object({ actionId: identifier, code: identifier }).strict();
+var referralControlSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("suspend"),
+    actionId: identifier,
+    member: identifier,
+    suspended: z2.boolean(),
+    reason
+  }).strict(),
+  z2.object({
+    kind: z2.literal("qualify"),
+    actionId: identifier,
+    member: identifier,
+    program: identifier,
+    qualified: z2.boolean(),
+    reason
+  }).strict(),
+  z2.object({
+    kind: z2.literal("resolve-reward"),
+    actionId: identifier,
+    entitlement: identifier,
+    reason
+  }).strict()
+]);
+var referralRelationshipSchema = z2.object({
+  member: identifier,
+  inviter: identifier,
+  acceptedAt: amount,
+  suspended: z2.boolean()
+});
+var referralAccountSchema = z2.object({
+  id: identifier,
+  program: identifier,
+  kind: z2.enum(["bonus", "fixed", "milestone"]),
+  balance: identifier,
+  earned: amount,
+  settled: amount,
+  outstanding: amount
+});
+var referralSummarySchema = z2.object({
+  code: identifier,
+  attributed: amount,
+  programs: z2.array(
+    z2.object({
+      definition: referralDefinitionSchema,
+      qualified: amount,
+      milestones: z2.array(
+        z2.object({ id: identifier, count: amount, reached: z2.boolean() })
+      )
+    })
+  ),
+  accounts: z2.array(referralAccountSchema)
+});
+var referralHistorySchema = z2.object({
+  items: z2.array(
+    z2.object({
+      id: amount,
+      program: identifier,
+      balance: identifier,
+      amount: z2.number().int().safe(),
+      at: amount,
+      reason: z2.string()
+    })
+  ),
+  next: amount.nullable()
+});
+var referralManagementSchema = z2.object({
+  relationships: z2.array(referralRelationshipSchema),
+  qualifications: z2.array(
+    z2.object({
+      member: identifier,
+      program: identifier,
+      qualified: z2.boolean(),
+      qualifiedAt: amount
+    })
+  ),
+  accounts: z2.array(
+    referralAccountSchema.extend({ member: identifier, invitee: z2.string() })
+  ),
+  reviews: z2.array(
+    z2.object({
+      entitlement: identifier,
+      member: identifier,
+      program: identifier,
+      reason: z2.string()
+    })
+  ),
+  next: amount.nullable()
+});
+
+// src/leaderboards.ts
+import { z as z3 } from "zod";
+var integer = z3.number().int().safe();
+var timestamp = integer.nonnegative().max(864e13);
+var leaderboardWindowSchema = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("all-time") }).strict(),
+  z3.object({ kind: z3.literal("fixed"), start: timestamp, end: timestamp }).strict().refine((w) => w.end > w.start, "Window end must follow its start"),
+  z3.object({ kind: z3.literal("rolling"), days: integer.min(1).max(3660) }).strict(),
+  z3.object({
+    kind: z3.literal("calendar"),
+    period: z3.enum(["day", "week", "month"]),
+    timeZone: z3.string().min(1).max(100).refine((zone) => {
+      try {
+        new Intl.DateTimeFormat("en", { timeZone: zone });
+        return true;
+      } catch {
+        return false;
+      }
+    }, "Use an IANA timezone")
+  }).strict()
+]);
+var periodScore = {
+  window: leaderboardWindowSchema.default({ kind: "all-time" }),
+  quests: z3.array(identifier).min(1).max(100).optional()
+};
+var leaderboardDefinitionSchema = z3.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z3.string().trim().min(1).max(120),
+  balance: identifier,
+  score: z3.discriminatedUnion("kind", [
+    z3.object({ kind: z3.literal("balance") }).strict(),
+    z3.object({ kind: z3.literal("earned"), ...periodScore }).strict(),
+    z3.object({
+      kind: z3.literal("net"),
+      window: leaderboardWindowSchema.default({ kind: "all-time" })
+    }).strict()
+  ]).default({ kind: "balance" }),
+  access: z3.enum(["participants", "public"]).default("participants"),
+  group: identifier.optional()
+}).strict();
+var leaderboardAuthoringSchema = leaderboardDefinitionSchema.omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
+function defineLeaderboard(input) {
+  const definition = leaderboardAuthoringSchema.parse(input);
+  return {
+    ...definition,
+    /** @deprecated Use key. */
+    id: definition.key
+  };
+}
+var leaderboardArtifactSchema = z3.union([
+  leaderboardAuthoringSchema,
+  z3.object({ code: z3.string().min(1).max(2e6) }).strict()
+]);
+var publishedLeaderboardSchema = z3.object({
+  version: identifier,
+  definition: leaderboardDefinitionSchema,
+  publishedAt: timestamp,
+  actor: z3.string().nullable()
+});
+var leaderboardQuerySchema = z3.object({
+  limit: z3.coerce.number().int().min(1).max(100).default(25),
+  cursor: z3.string().max(4096).optional()
+}).strict();
+var leaderboardRowSchema = z3.object({
+  participant: identifier,
+  member: identifier.optional(),
+  name: z3.string(),
+  score: integer,
+  rank: integer.positive()
+});
+var leaderboardPageSchema = z3.object({
+  leaderboard: identifier,
+  title: z3.string(),
+  version: identifier,
+  calculation: z3.enum(["balance", "earned", "net"]),
+  period: z3.object({ start: timestamp.nullable(), end: timestamp.nullable() }),
+  calculatedAt: timestamp,
+  lastEntryAt: timestamp.nullable(),
+  total: integer.nonnegative(),
+  items: z3.array(leaderboardRowSchema),
+  me: leaderboardRowSchema.nullable(),
+  nearby: z3.array(leaderboardRowSchema),
+  nextCursor: z3.string().nullable()
+});
+var leaderboardPreviewSchema = z3.object({
+  published: publishedLeaderboardSchema,
+  before: leaderboardPageSchema.nullable(),
+  after: leaderboardPageSchema
+});
+var mutationBase = {
+  actionId: identifier,
+  member: identifier,
+  balance: identifier,
+  reason: z3.string().trim().min(1).max(1e3)
+};
+var datedMutation = { ...mutationBase, effectiveAt: timestamp.optional() };
+var pointsMutationSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    ...datedMutation,
+    kind: z3.literal("award"),
+    referralEligible: z3.boolean().optional(),
+    amount: integer.positive()
+  }).strict(),
+  z3.object({
+    ...datedMutation,
+    kind: z3.literal("spend"),
+    amount: integer.positive()
+  }).strict(),
+  z3.object({
+    ...datedMutation,
+    kind: z3.literal("adjust"),
+    amount: integer.refine((n) => n !== 0)
+  }).strict(),
+  z3.object({
+    ...datedMutation,
+    kind: z3.literal("set"),
+    total: integer.nonnegative(),
+    expectedTotal: integer.nonnegative(),
+    classification: z3.enum(["earned", "spend"])
+  }).strict(),
+  z3.object({
+    ...mutationBase,
+    kind: z3.literal("reverse"),
+    entry: identifier,
+    amount: integer.positive()
+  }).strict()
+]);
+var pointsEntrySchema = z3.object({
+  id: identifier,
+  completion: z3.string().nullable(),
+  member: identifier,
+  balance: identifier,
+  amount: integer,
+  kind: z3.enum(["award", "spend", "adjust", "reverse"]),
+  effectiveAt: timestamp,
+  receivedAt: timestamp,
+  quest: identifier.nullable(),
+  original: identifier.nullable(),
+  reason: z3.string(),
+  actor: z3.string().nullable()
+});
+var pointsResultSchema = z3.object({
+  entry: pointsEntrySchema,
+  total: integer.nonnegative()
+});
+var pointsAccountSchema = z3.object({
+  member: identifier,
+  balance: identifier,
+  total: integer.nonnegative(),
+  held: integer.nonnegative()
+});
+var leaderboardExclusionSchema = z3.object({
+  actionId: identifier,
+  member: identifier,
+  excluded: z3.boolean(),
+  reason: z3.string().trim().min(1).max(1e3)
+}).strict();
+var leaderboardGroupSchema = z3.object({
+  actionId: identifier,
+  member: identifier,
+  included: z3.boolean(),
+  reason: z3.string().trim().min(1).max(1e3)
+}).strict();
+
+export {
+  authoringIdentityShape,
+  validateAuthoringIdentity,
+  normalizeAuthoringIdentity,
+  authoringKey,
+  referralDefinitionSchema,
+  referralAuthoringSchema,
+  defineReferral,
+  referralArtifactSchema,
+  publishedReferralSchema,
+  referralAcceptSchema,
+  referralControlSchema,
+  referralRelationshipSchema,
+  referralAccountSchema,
+  referralSummarySchema,
+  referralHistorySchema,
+  referralManagementSchema,
+  leaderboardWindowSchema,
+  leaderboardDefinitionSchema,
+  leaderboardAuthoringSchema,
+  defineLeaderboard,
+  leaderboardArtifactSchema,
+  publishedLeaderboardSchema,
+  leaderboardQuerySchema,
+  leaderboardRowSchema,
+  leaderboardPageSchema,
+  leaderboardPreviewSchema,
+  pointsMutationSchema,
+  pointsEntrySchema,
+  pointsResultSchema,
+  pointsAccountSchema,
+  leaderboardExclusionSchema,
+  leaderboardGroupSchema
+};

package/dist/{chunk-6QUCADMF.js → chunk-XTFCKK2Y.js}

@@ -145,6 +145,10 @@ var channelSourceSchema = z6.object({
   types: z6.array(z6.enum(["text", "announcement"])).min(1)
 }).strict();
 var resourceSourceSchema = z6.union([
+  z6.object({
+    provider: z6.literal("domino"),
+    resource: z6.literal("point-ledger")
+  }).strict(),
   channelSourceSchema,
   z6.object({
     provider: z6.literal("discord"),
@@ -187,6 +191,10 @@ var discord = {
     });
   }
 };
+var pointLedgers = () => ({
+  provider: "domino",
+  resource: "point-ledger"
+});
 
 // src/settings.ts
 var instant = z7.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
@@ -397,7 +405,8 @@ var decisionSchema = z8.discriminatedUnion("kind", [
     completionKey: completionKeySchema.optional()
   }).strict()
 ]);
-var reviewModeSchema = z8.enum([
+var reviewModeSchema = z8.enum(["workers-ai"]);
+var storedReviewModeSchema = z8.enum([
   "fixture-pass",
   "fixture-fail",
   "fixture-unclear",
@@ -460,8 +469,9 @@ var questSettingsInputSchema = z8.object({
   reset: z8.array(z8.string())
 }).strict();
 var storedReleaseSchema = questDescriptionSchema.extend({
+  key: identifier.optional(),
   code: z8.string(),
-  provider: reviewModeSchema,
+  provider: storedReviewModeSchema,
   id: identifier,
   createdAt: z8.number(),
   legacy: z8.boolean().default(false),
@@ -480,7 +490,7 @@ var legacyReleaseSchema = z8.object({
   humanReview: z8.boolean(),
   rewards: rewardBundleSchema,
   code: z8.string(),
-  provider: reviewModeSchema,
+  provider: storedReviewModeSchema,
   id: identifier,
   createdAt: z8.number()
 }).transform((r) => {
@@ -595,7 +605,22 @@ var configurePickupSchema = z8.object({
   reward: identifier,
   revision: z8.number().int().nonnegative(),
   actionId: identifier,
-  policy: pickupPolicySchema
+  policy: z8.discriminatedUnion("kind", [
+    z8.object({ kind: z8.literal("untracked") }).strict(),
+    z8.object({
+      kind: z8.literal("at-pickup"),
+      tiers: z8.array(
+        z8.object({
+          tier: identifier,
+          variants: z8.array(
+            pickupAllocationSchema.extend({
+              item: identifier.optional()
+            })
+          ).min(1).max(100)
+        }).strict()
+      ).min(1).max(100)
+    }).strict()
+  ])
 }).strict();
 var entitlementBase = {
   id: identifier,
@@ -659,6 +684,7 @@ var memberProgressSchema = z8.object({
   quests: z8.array(
     z8.object({
       quest: identifier,
+      key: identifier.optional(),
       release: identifier.optional(),
       title: z8.string(),
       presentation: questPresentationSchema.default({}),
@@ -744,6 +770,8 @@ var memberPageSchema = z8.object({
   items: z8.array(z8.object({ member: identifier })).max(100),
   nextCursor: z8.string().nullable()
 });
+var createStockItemSchema = z8.object({ actionId: identifier, name: z8.string().trim().min(1).max(80) }).strict();
+var stockItemSchema = z8.object({ id: identifier, name: z8.string() });
 
 export {
   identifier,
@@ -772,6 +800,7 @@ export {
   resourceRequestSchema,
   resourceOptionsSchema,
   discord,
+  pointLedgers,
   settingFieldSchema,
   settingsFieldsSchema,
   settingsValuesSchema,
@@ -790,6 +819,7 @@ export {
   photoResultSchema,
   decisionSchema,
   reviewModeSchema,
+  storedReviewModeSchema,
   rewardBundleSchema,
   mediaUrlSchema,
   questPresentationSchema,
@@ -827,5 +857,7 @@ export {
   memberListSchema,
   reviewItemSchema,
   reviewPageSchema,
-  memberPageSchema
+  memberPageSchema,
+  createStockItemSchema,
+  stockItemSchema
 };

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

@@ -1,21 +1,24 @@
 import {
+  authoringIdentityShape,
   leaderboardArtifactSchema,
   leaderboardDefinitionSchema,
   leaderboardPageSchema,
   leaderboardPreviewSchema,
   leaderboardQuerySchema,
+  normalizeAuthoringIdentity,
   publishedReferralSchema,
   referralAcceptSchema,
   referralArtifactSchema,
   referralDefinitionSchema,
   referralHistorySchema,
-  referralSummarySchema
-} from "./chunk-TYVT5BPZ.js";
+  referralSummarySchema,
+  validateAuthoringIdentity
+} from "./chunk-Q5VDZVVO.js";
 import {
   authScopeSchema,
   exchangeResultSchema,
   sessionSchema
-} from "./chunk-36LZ3IOO.js";
+} from "./chunk-MVDE7WKB.js";
 import {
   accountConnectionSchema,
   attemptSchema,
@@ -38,16 +41,21 @@ import {
   reviewPageSchema,
   settingsValuesSchema,
   snapshotSchema,
+  storedReviewModeSchema,
   templateSchema
-} from "./chunk-6QUCADMF.js";
+} from "./chunk-XTFCKK2Y.js";
 
 // src/point-ledgers.ts
 import { z } from "zod";
-var pointLedgerSchema = z.object({
-  id: identifier,
+var pointLedgerPropertiesSchema = z.object({
   name: z.string().trim().min(1).max(120),
   description: z.string().trim().max(1e3).default("")
 }).strict();
+var createPointLedgerSchema = pointLedgerPropertiesSchema.extend({ actionId: identifier, key: identifier.optional() }).strict();
+var pointLedgerSchema = pointLedgerPropertiesSchema.extend({
+  id: identifier
+});
+var pointLedgerDeclarationSchema = pointLedgerPropertiesSchema.extend({ key: identifier }).strict();
 
 // src/reward-deliveries.ts
 import { z as z2 } from "zod";
@@ -70,19 +78,6 @@ var rewardDeliveriesSchema = z2.object({
   deliveries: z2.array(rewardDeliverySchema)
 });
 
-// src/resource-id.ts
-var alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-function resourceId(prefix) {
-  let suffix = "";
-  while (suffix.length < 22) {
-    for (const byte of crypto.getRandomValues(new Uint8Array(32))) {
-      if (byte < 248) suffix += alphabet[byte % 62];
-      if (suffix.length === 22) break;
-    }
-  }
-  return `${prefix}_${suffix}`;
-}
-
 // src/catalog.ts
 import { z as z3 } from "zod";
 var interactionSchema = z3.enum([
@@ -96,14 +91,20 @@ function questInteraction(trigger) {
   return trigger.kind === "automatic" ? "automatic" : trigger.actor === "staff" ? "staff" : trigger.input === "none" ? "claim" : trigger.input;
 }
 var questTypeVersionSchema = z3.object({
+  key: identifier.optional(),
   id: identifier,
   version: identifier,
   code: z3.string(),
   definition: questDescriptionSchema,
-  provider: reviewModeSchema,
+  provider: storedReviewModeSchema,
   createdAt: z3.number()
 });
-var collectionSlotSchema = z3.object({ id: identifier, title: z3.string().trim().min(1).max(120) }).strict();
+var collectionSlotSchema = z3.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z3.string().trim().min(1).max(120)
+}).strict();
+var collectionSlotDeclarationSchema = collectionSlotSchema.omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
 var questCollectionSchema = collectionSlotSchema.extend({
   quests: z3.array(identifier).max(100).refine(
     (v) => new Set(v).size === v.length,
@@ -154,7 +155,7 @@ var catalogDeploymentSchema = z3.object({
       provider: reviewModeSchema
     })
   ).max(50).default([]),
-  collections: z3.array(collectionSlotSchema).max(50).default([]),
+  collections: z3.array(collectionSlotDeclarationSchema).max(50).default([]),
   supportedInteractions: z3.array(interactionSchema).min(1).optional()
 }).strict();
 var catalogDeploymentPreviewSchema = z3.object({
@@ -164,7 +165,8 @@ var catalogDeploymentPreviewSchema = z3.object({
   supportedInteractions: z3.array(interactionSchema)
 });
 var saveQuestDraftSchema = z3.object({
-  id: identifier,
+  id: identifier.optional(),
+  actionId: identifier,
   expectedRevision: z3.number().int().nonnegative(),
   baseRevision: z3.number().int().nonnegative(),
   changes: questDraftChangesSchema
@@ -179,6 +181,7 @@ var questViewSchema = memberProgressSchema.shape.quests.element.extend(
   }
 );
 var collectionViewSchema = z3.object({
+  key: identifier.optional(),
   id: identifier,
   title: z3.string(),
   quests: z3.array(questViewSchema)
@@ -193,6 +196,8 @@ var questPublicationPreviewSchema = z3.object({
   releases: z3.array(publishedReleaseSchema),
   affectedCollections: z3.array(questCollectionSchema)
 });
+var allocateQuestSchema = z3.object({ actionId: identifier }).strict();
+var allocatedQuestSchema = z3.object({ id: identifier });
 
 // src/errors.ts
 var RelayError = class extends Error {
@@ -727,16 +732,18 @@ function questConfiguration(release) {
 // src/deployments.ts
 import { z as z7 } from "zod";
 var projectCatalogArtifactSchema = catalogDeploymentSchema.omit({ expectedRevision: true }).extend({
+  pointLedgers: z7.array(pointLedgerDeclarationSchema).max(50).default([]),
   referrals: z7.array(referralArtifactSchema).max(50).default([]),
   leaderboards: z7.array(leaderboardArtifactSchema).max(50).default([])
 });
 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."
+  (value) => value.pointLedgers.length > 0 || 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, pointLedgers, leaderboards, referrals, collections, or supportedInteractions to relay.json."
 );
 var deploymentPreviewSchema = z7.object({
   id: identifier,
   baseRevision: z7.number().int().nonnegative(),
+  pointLedgers: z7.array(pointLedgerSchema).default([]),
   releases: z7.array(publishedReleaseSchema),
   types: z7.array(questTypeVersionSchema),
   collections: z7.array(questCollectionSchema),
@@ -878,7 +885,9 @@ function createRelayClient(options) {
   }
   const experience = () => request("/v1/me/experience", questExperienceSchema);
   async function getQuest(id) {
-    const quest = (await experience()).quests.find((q) => q.quest === id);
+    const quest = (await experience()).quests.find(
+      (q) => q.quest === id || q.key === id
+    );
     if (!quest) throw new RelayError("Quest not found", 404);
     return quest;
   }
@@ -931,7 +940,7 @@ function createRelayClient(options) {
       experience,
       collection: async (id) => {
         const collection = (await experience()).collections.find(
-          (c) => c.id === id
+          (c) => c.id === id || c.key === id
         );
         if (!collection) throw new RelayError("Collection not found", 404);
         return collection;
@@ -1132,14 +1141,17 @@ function createRelayClient(options) {
 }
 
 export {
+  pointLedgerPropertiesSchema,
+  createPointLedgerSchema,
   pointLedgerSchema,
+  pointLedgerDeclarationSchema,
   rewardDeliverySchema,
   rewardDeliveriesSchema,
-  resourceId,
   interactionSchema,
   questInteraction,
   questTypeVersionSchema,
   collectionSlotSchema,
+  collectionSlotDeclarationSchema,
   questCollectionSchema,
   questInstanceSchema,
   questDraftChangesSchema,
@@ -1153,6 +1165,8 @@ export {
   collectionViewSchema,
   questExperienceSchema,
   questPublicationPreviewSchema,
+  allocateQuestSchema,
+  allocatedQuestSchema,
   RelayError,
   QuestUpdatedError,
   reconcileQuestDraft,