@domino-sdk/relay 0.6.0 → 0.8.0

package/dist/{chunk-CCLIDCUU.js → chunk-APMYDKEX.js}

@@ -1,21 +1,24 @@
 import {
+  authoringIdentityShape,
   leaderboardArtifactSchema,
   leaderboardDefinitionSchema,
   leaderboardPageSchema,
   leaderboardPreviewSchema,
   leaderboardQuerySchema,
+  normalizeAuthoringIdentity,
   publishedReferralSchema,
   referralAcceptSchema,
   referralArtifactSchema,
   referralDefinitionSchema,
   referralHistorySchema,
-  referralSummarySchema
-} from "./chunk-UIC6OF3C.js";
+  referralSummarySchema,
+  validateAuthoringIdentity
+} from "./chunk-XVHWBZRG.js";
 import {
   authScopeSchema,
   exchangeResultSchema,
   sessionSchema
-} from "./chunk-PLO5PPLU.js";
+} from "./chunk-2BN7XZH3.js";
 import {
   accountConnectionSchema,
   attemptSchema,
@@ -39,45 +42,44 @@ import {
   settingsValuesSchema,
   snapshotSchema,
   templateSchema
-} from "./chunk-MXK7KEDA.js";
+} from "./chunk-Z43O273V.js";
 
-// src/reward-deliveries.ts
+// src/point-ledgers.ts
 import { z } from "zod";
-var rewardDeliverySchema = z.object({
-  id: z.string(),
-  quest: z.string(),
-  completion: z.string(),
-  member: z.string(),
-  provider: z.literal("discord"),
-  action: z.literal("grant-role"),
-  roleId: z.string(),
-  status: z.enum(["pending", "delivered"]),
-  attempts: z.number().int(),
-  nextAt: z.number(),
-  lastError: z.string().nullable(),
-  createdAt: z.number(),
-  deliveredAt: z.number().nullable()
-});
-var rewardDeliveriesSchema = z.object({
-  deliveries: z.array(rewardDeliverySchema)
+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/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/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/catalog.ts
-import { z as z2 } from "zod";
-var interactionSchema = z2.enum([
+import { z as z3 } from "zod";
+var interactionSchema = z3.enum([
   "photo",
   "quiz",
   "claim",
@@ -87,104 +89,114 @@ var interactionSchema = z2.enum([
 function questInteraction(trigger) {
   return trigger.kind === "automatic" ? "automatic" : trigger.actor === "staff" ? "staff" : trigger.input === "none" ? "claim" : trigger.input;
 }
-var questTypeVersionSchema = z2.object({
+var questTypeVersionSchema = z3.object({
+  key: identifier.optional(),
   id: identifier,
   version: identifier,
-  code: z2.string(),
+  code: z3.string(),
   definition: questDescriptionSchema,
   provider: reviewModeSchema,
-  createdAt: z2.number()
+  createdAt: z3.number()
 });
-var collectionSlotSchema = z2.object({ id: identifier, title: z2.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: z2.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 = z2.object({
+var questInstanceSchema = z3.object({
   id: identifier,
-  title: z2.string().trim().min(1).max(120),
+  title: z3.string().trim().min(1).max(120),
   typeVersion: identifier,
   settings: settingsValuesSchema,
-  requires: z2.array(identifier).max(30),
-  status: z2.enum(["active", "paused", "archived"])
+  requires: z3.array(identifier).max(30),
+  status: z3.enum(["active", "paused", "archived"])
 }).strict();
-var questDraftChangesSchema = z2.object({
-  quests: z2.array(
+var questDraftChangesSchema = z3.object({
+  quests: z3.array(
     questInstanceSchema.extend({ expectedRelease: identifier.nullable() })
   ).max(50),
-  collections: z2.array(questCollectionSchema).max(50)
+  collections: z3.array(questCollectionSchema).max(50)
 }).strict();
-var draftBase = z2.object({
+var draftBase = z3.object({
   id: identifier,
-  revision: z2.number().int().positive(),
-  baseRevision: z2.number().int().nonnegative(),
+  revision: z3.number().int().positive(),
+  baseRevision: z3.number().int().nonnegative(),
   changes: questDraftChangesSchema
 });
-var questDraftSchema = z2.discriminatedUnion("status", [
-  draftBase.extend({ status: z2.literal("draft") }),
+var questDraftSchema = z3.discriminatedUnion("status", [
+  draftBase.extend({ status: z3.literal("draft") }),
   draftBase.extend({
-    status: z2.literal("published"),
-    releaseIds: z2.array(identifier)
+    status: z3.literal("published"),
+    releaseIds: z3.array(identifier)
   })
 ]);
-var questCatalogSchema = z2.object({
-  revision: z2.number().int().nonnegative(),
-  types: z2.array(questTypeVersionSchema),
-  collections: z2.array(questCollectionSchema),
-  quests: z2.array(questInstanceSchema),
-  drafts: z2.array(questDraftSchema),
-  releases: z2.array(publishedReleaseSchema).default([]),
-  supportedInteractions: z2.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 = z2.object({
-  expectedRevision: z2.number().int().nonnegative(),
-  types: z2.array(
-    z2.object({
-      code: z2.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: z2.array(collectionSlotSchema).max(50).default([]),
-  supportedInteractions: z2.array(interactionSchema).min(1).optional()
+  collections: z3.array(collectionSlotDeclarationSchema).max(50).default([]),
+  supportedInteractions: z3.array(interactionSchema).min(1).optional()
 }).strict();
-var catalogDeploymentPreviewSchema = z2.object({
-  revision: z2.number().int().nonnegative(),
-  types: z2.array(questTypeVersionSchema),
-  collections: z2.array(collectionSlotSchema),
-  supportedInteractions: z2.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 = z2.object({
-  id: identifier,
-  expectedRevision: z2.number().int().nonnegative(),
-  baseRevision: z2.number().int().nonnegative(),
+var saveQuestDraftSchema = z3.object({
+  id: identifier.optional(),
+  actionId: identifier,
+  expectedRevision: z3.number().int().nonnegative(),
+  baseRevision: z3.number().int().nonnegative(),
   changes: questDraftChangesSchema
 }).strict();
-var publishQuestDraftSchema = z2.object({ id: identifier, expectedRevision: z2.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: z2.enum(["active", "paused", "archived"]),
-    rewards: z2.array(z2.object({ label: z2.string() }))
+    lifecycle: z3.enum(["active", "paused", "archived"]),
+    rewards: z3.array(z3.object({ label: z3.string() }))
   }
 );
-var collectionViewSchema = z2.object({
+var collectionViewSchema = z3.object({
+  key: identifier.optional(),
   id: identifier,
-  title: z2.string(),
-  quests: z2.array(questViewSchema)
+  title: z3.string(),
+  quests: z3.array(questViewSchema)
 });
-var questExperienceSchema = z2.object({
+var questExperienceSchema = z3.object({
   member: identifier,
-  quests: z2.array(questViewSchema),
-  collections: z2.array(collectionViewSchema)
+  quests: z3.array(questViewSchema),
+  collections: z3.array(collectionViewSchema)
 });
-var questPublicationPreviewSchema = z2.object({
+var questPublicationPreviewSchema = z3.object({
   draft: questDraftSchema,
-  releases: z2.array(publishedReleaseSchema),
-  affectedCollections: z2.array(questCollectionSchema)
+  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 {
@@ -200,43 +212,43 @@ var RelayError = class extends Error {
 };
 
 // src/submissions.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var common = {
   id: identifier,
   quest: identifier,
   release: identifier.optional()
 };
-var claimInputSchema = z3.union([
+var claimInputSchema = z4.union([
   quizEvidenceSchema,
-  z3.object({ kind: z3.literal("none") }).strict()
+  z4.object({ kind: z4.literal("none") }).strict()
 ]);
-var draftSchema = z3.union([
+var draftSchema = z4.union([
   claimInputSchema,
-  z3.object({ kind: z3.literal("photo"), file: z3.instanceof(Blob) })
+  z4.object({ kind: z4.literal("photo"), file: z4.instanceof(Blob) })
 ]);
-var recordSchema = z3.union([
-  z3.object({
+var recordSchema = z4.union([
+  z4.object({
     ...common,
-    stage: z3.literal("review"),
+    stage: z4.literal("review"),
     draft: draftSchema.nullable()
   }),
-  z3.object({ ...common, stage: z3.literal("upload"), file: z3.instanceof(Blob) }),
-  z3.object({
+  z4.object({ ...common, stage: z4.literal("upload"), file: z4.instanceof(Blob) }),
+  z4.object({
     ...common,
-    stage: z3.literal("claim"),
+    stage: z4.literal("claim"),
     evidence: identifier,
-    file: z3.instanceof(Blob).optional()
+    file: z4.instanceof(Blob).optional()
   }),
-  z3.object({
+  z4.object({
     ...common,
-    stage: z3.literal("submitted"),
+    stage: z4.literal("submitted"),
     evidence: identifier,
     attempt: identifier
   }),
-  z3.object({ ...common, stage: z3.literal("claim"), input: claimInputSchema }),
-  z3.object({
+  z4.object({ ...common, stage: z4.literal("claim"), input: claimInputSchema }),
+  z4.object({
     ...common,
-    stage: z3.literal("submitted"),
+    stage: z4.literal("submitted"),
     input: claimInputSchema,
     attempt: identifier
   })
@@ -650,56 +662,56 @@ function observeProgress(transport, listener, options = {}, onDispose = () => {
 }
 
 // src/index.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/wallet.ts
-import { z as z4 } from "zod";
-var solanaAddressSchema = z4.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
-var walletConnectionSchema = z4.object({
-  chain: z4.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: z4.number().int().nonnegative(),
-  revision: z4.number().int().positive()
+  verifiedAt: z5.number().int().nonnegative(),
+  revision: z5.number().int().positive()
 }).strict();
-var walletChallengeInputSchema = z4.object({
-  chain: z4.literal("solana"),
+var walletChallengeInputSchema = z5.object({
+  chain: z5.literal("solana"),
   address: solanaAddressSchema
 }).strict();
 var walletChallengeSchema = walletChallengeInputSchema.extend({
-  id: z4.string().uuid(),
-  message: z4.string(),
-  expiresAt: z4.number()
+  id: z5.string().uuid(),
+  message: z5.string(),
+  expiresAt: z5.number()
 });
-var walletProofSchema = z4.object({
-  challenge: z4.string().uuid(),
-  signature: z4.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 = z4.object({
+var solanaBalanceSchema = z5.object({
   address: solanaAddressSchema,
-  network: z4.literal("mainnet-beta"),
-  lamports: z4.string().regex(/^(0|[1-9][0-9]*)$/),
-  slot: z4.number().int().nonnegative().safe(),
-  observedAt: z4.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 z5 } from "zod";
-var collectionCodeSchema = z5.string().regex(/^relay:collect:[a-f0-9]{64}$/);
-var collectionPassSchema = z5.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: z5.number(),
+  expiresAt: z6.number(),
   entitlement: identifier
 });
-var collectionResolveSchema = z5.object({ code: collectionCodeSchema }).strict();
+var collectionResolveSchema = z6.object({ code: collectionCodeSchema }).strict();
 var collectionBeginSchema = collectionResolveSchema.extend({
   actionId: identifier,
-  revision: z5.number().int().positive(),
+  revision: z6.number().int().positive(),
   selection: pickupSelectionSchema.optional()
 });
-var collectionPreviewSchema = z5.object({
+var collectionPreviewSchema = z6.object({
   entitlement: entitlementSchema,
   inventory: pickupAvailabilitySchema,
-  expiresAt: z5.number()
+  expiresAt: z6.number()
 });
 
 // src/configuration.ts
@@ -717,53 +729,55 @@ function questConfiguration(release) {
 }
 
 // src/deployments.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var projectCatalogArtifactSchema = catalogDeploymentSchema.omit({ expectedRevision: true }).extend({
-  referrals: z6.array(referralArtifactSchema).max(50).default([]),
-  leaderboards: z6.array(leaderboardArtifactSchema).max(50).default([])
+  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: z6.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 projectDeploymentSchema = projectCatalogArtifactSchema.extend({ releases: z7.array(releaseSchema).max(50).default([]) }).refine(
+  (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 = z6.object({
+var deploymentPreviewSchema = z7.object({
   id: identifier,
-  baseRevision: z6.number().int().nonnegative(),
-  releases: z6.array(publishedReleaseSchema),
-  types: z6.array(questTypeVersionSchema),
-  collections: z6.array(questCollectionSchema),
-  supportedInteractions: z6.array(interactionSchema),
-  referrals: z6.array(publishedReferralSchema).default([]),
-  leaderboards: z6.array(leaderboardPreviewSchema).default([])
+  baseRevision: z7.number().int().nonnegative(),
+  pointLedgers: z7.array(pointLedgerSchema).default([]),
+  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 = z6.object({ id: identifier }).strict();
+var publishDeploymentSchema = z7.object({ id: identifier }).strict();
 var deploymentResultSchema = deploymentPreviewSchema.extend({
-  revision: z6.number().int().positive()
+  revision: z7.number().int().positive()
 });
 
 // src/identity-integration.ts
-import { z as z7 } from "zod";
-var identityIntegrationInputSchema = z7.object({
-  name: z7.string().trim().min(1).max(80),
-  origin: z7.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: z7.string().uuid(),
-  name: z7.string(),
-  origin: z7.string(),
-  expiresAt: z7.number()
+  id: z8.string().uuid(),
+  name: z8.string(),
+  origin: z8.string(),
+  expiresAt: z8.number()
 });
 var identityIntegrationSecretSchema = identityIntegrationSchema.extend(
   {
-    token: z7.string()
+    token: z8.string()
   }
 );
-var participantExchangeSchema = z7.object({
-  subject: z7.string().min(1).max(200),
-  previousToken: z7.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
@@ -870,25 +884,27 @@ 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;
   }
   return {
     referrals: {
-      list: () => request("/v1/referrals", z8.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", z8.object({ ok: z8.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", z8.array(leaderboardDefinitionSchema)),
+      list: () => request("/v1/leaderboards", z9.array(leaderboardDefinitionSchema)),
       standings: (board, options2 = {}) => {
         const parsed = leaderboardQuerySchema.parse(options2);
         return request(
@@ -923,7 +939,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;
@@ -968,25 +984,25 @@ function createRelayClient(options) {
     auth: {
       providers: () => request(
         "/v1/auth/providers",
-        z8.object({
-          providers: z8.array(
-            z8.object({
+        z9.object({
+          providers: z9.array(
+            z9.object({
               provider: authProviderSchema,
-              configured: z8.boolean()
+              configured: z9.boolean()
             })
           ),
-          email: z8.boolean(),
-          demo: z8.boolean()
+          email: z9.boolean(),
+          demo: z9.boolean()
         })
       ),
       start: (provider, mode) => request(
         "/v1/auth/start",
-        z8.object({ url: z8.string() }),
+        z9.object({ url: z9.string() }),
         json({ provider, mode })
       ),
       emailStart: (email) => request(
         "/v1/auth/email/start",
-        z8.object({ challenge: z8.string() }),
+        z9.object({ challenge: z9.string() }),
         json({ email })
       ),
       emailVerify: (challenge, code) => changeSession(
@@ -996,25 +1012,25 @@ function createRelayClient(options) {
           json({ challenge, code })
         )
       ),
-      accounts: () => request("/v1/auth/accounts", z8.array(accountConnectionSchema)),
+      accounts: () => request("/v1/auth/accounts", z9.array(accountConnectionSchema)),
       disconnect: (provider) => request(
         "/v1/auth/accounts/disconnect",
-        z8.object({ ok: z8.boolean() }),
+        z9.object({ ok: z9.boolean() }),
         json({ provider })
       ),
       connections: () => request(
         "/v1/auth/connections",
-        z8.array(
-          z8.object({
-            provider: z8.string(),
-            subject: z8.string(),
-            signInEnabled: z8.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", z8.object({ ok: z8.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))
@@ -1090,16 +1106,16 @@ function createRelayClient(options) {
     },
     lookupMember: (issuer, subject) => request(
       "/v1/members/lookup",
-      z8.object({ member: z8.string() }),
+      z9.object({ member: z9.string() }),
       json({ issuer, subject })
     ),
-    journeyTemplate: () => request("/v1/journey-template", z8.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",
-      z8.array(publishedReleaseSchema),
+      z9.array(publishedReleaseSchema),
       json({ releases })
     ),
     progress: (member) => request(
@@ -1124,13 +1140,17 @@ function createRelayClient(options) {
 }
 
 export {
+  pointLedgerPropertiesSchema,
+  createPointLedgerSchema,
+  pointLedgerSchema,
+  pointLedgerDeclarationSchema,
   rewardDeliverySchema,
   rewardDeliveriesSchema,
-  resourceId,
   interactionSchema,
   questInteraction,
   questTypeVersionSchema,
   collectionSlotSchema,
+  collectionSlotDeclarationSchema,
   questCollectionSchema,
   questInstanceSchema,
   questDraftChangesSchema,
@@ -1144,6 +1164,8 @@ export {
   collectionViewSchema,
   questExperienceSchema,
   questPublicationPreviewSchema,
+  allocateQuestSchema,
+  allocatedQuestSchema,
   RelayError,
   QuestUpdatedError,
   reconcileQuestDraft,