@domino-sdk/relay 1.5.2 → 1.7.0

package/dist/server/index.js

@@ -11,28 +11,45 @@ import {
   automaticSchedulingQuerySchema,
   automaticSchedulingRetrySchema,
   automaticSchedulingSchema,
+  deploymentActionSchema,
   deploymentPreviewSchema,
   deploymentRecordSchema,
+  deploymentRejectionSchema,
   deploymentResultSchema,
   projectDeploymentSchema,
   promoteDeploymentSchema,
   publishDeploymentSchema,
   rejectDeploymentSchema,
-  rollbackDeploymentSchema,
   submitDeploymentSchema
-} from "../chunk-VFHHLN6A.js";
+} from "../chunk-6RBF3UDA.js";
 import "../chunk-MC6V6VMG.js";
 import {
+  REFERRAL_INTEGRATION_REWARD_ERROR,
+  containsReferralIntegrationReward,
   identityIntegrationInputSchema,
   identityIntegrationSchema,
   identityIntegrationSecretSchema,
-  identityKindClaimSchema
-} from "../chunk-WJSSJ7AF.js";
+  identityKindClaimSchema,
+  parseImageExtraction,
+  parseImageResult,
+  participantExchangeSchema,
+  questConfiguration,
+  sequenceCursorSchema
+} from "../chunk-5ECM6AWV.js";
 import {
   imageAssetArtifactSchema
-} from "../chunk-BGGKNIRP.js";
-import "../chunk-GQKYAQM6.js";
-import "../chunk-GUP7YRR4.js";
+} from "../chunk-JW4G3SY5.js";
+import {
+  sourceDataSchema,
+  sourceRoles,
+  validateQuestShape
+} from "../chunk-23QJ7WH4.js";
+import {
+  isIntegrationParticipantPath,
+  isParticipantRoute,
+  participantRoutePattern,
+  participantRoutes
+} from "../chunk-AXRMT33W.js";
 import {
   allocateQuestSchema,
   allocatedQuestSchema,
@@ -50,7 +67,7 @@ import {
   rewardDeliveriesSchema,
   rewardDeliverySchema,
   saveQuestDraftSchema
-} from "../chunk-EYH5RDIE.js";
+} from "../chunk-C25TDFHN.js";
 import {
   cosmosNetworkSchema,
   createPointLedgerSchema,
@@ -62,6 +79,7 @@ import {
   engagementPageSchema,
   engagementPublishSchema,
   engagementRuleSchema,
+  engagementRuleVersionPageSchema,
   engagementVersionPageSchema,
   engagementVersionQuerySchema,
   evmChainIdSchema,
@@ -73,13 +91,14 @@ import {
   leaderboardSettlementSchema,
   leaderboardSettlementSummarySchema,
   linkedWalletSchema,
+  managedPointHistoryPageSchema,
   managedPointLedgerSchema,
   managedProfileSchema,
   offerControlSchema,
   offerSchema,
+  pointLedgerPropertiesSchema,
   pointLedgerSchema,
   pointsAccountSchema,
-  pointsEntrySchema,
   pointsMutationSchema,
   pointsResultSchema,
   profileModerationSchema,
@@ -92,11 +111,14 @@ import {
   referralControlSchema,
   referralHistorySchema,
   referralManagementSchema,
+  referralQualificationSchema,
+  referralRewardResolutionSchema,
+  referralSuspensionSchema,
   solanaMainnet,
   walletBalanceSchema,
   walletSignInNetworksSchema,
   walletUnlinkInputSchema
-} from "../chunk-36HTX2BM.js";
+} from "../chunk-GMPPLZKH.js";
 import {
   MANAGEMENT_TIMEOUT,
   lifetime,
@@ -108,13 +130,16 @@ import {
   RequestError,
   isRequestError
 } from "../chunk-NPGENI7K.js";
-import "../chunk-XFMSUPNS.js";
+import "../chunk-6ON4RMEN.js";
 import {
+  CompletionSourceKind,
+  addGroupMemberSchema,
   appIdentityKindSchema,
   attemptSchema,
   authProviderSchema,
   beginHandoverSchema,
   campaignEnrollmentSchema,
+  completionSourceSchema,
   configurePickupSchema,
   confirmHandoverSchema,
   contentPerformancePageSchema,
@@ -125,14 +150,23 @@ import {
   counterHistorySchema,
   counterModerationResultSchema,
   counterModerationSchema,
+  createGroupSchema,
   createStockItemSchema,
   entitlementCorrectionSchema,
   entitlementSchema,
+  eventSchema,
+  groupMemberPageSchema,
+  groupMemberSchema,
+  groupPageQuerySchema,
+  groupPageSchema,
   identifier,
+  managedGroupSchema,
   memberCampaignEnrollmentInputSchema,
   memberCampaignWithdrawalInputSchema,
   memberIdentitySchema,
   memberProgressSchema,
+  pageCursorSchema,
+  pageQuerySchema,
   pickupAvailabilitySchema,
   pickupCatalogSchema,
   projectCalendarInputSchema,
@@ -140,6 +174,7 @@ import {
   projectGroupKey,
   publishedReleaseSchema,
   questSettingsInputSchema,
+  removeGroupMemberSchema,
   snapshotSchema,
   staffDecisionSchema,
   stockItemSchema,
@@ -147,6 +182,8 @@ import {
   trackerContentReadSchema,
   trackerContentSchema,
   trackerControlSchema,
+  trackerDataIssue,
+  trackerDataIssues,
   trackerIngestResultSchema,
   trackerIngestSchema,
   trackerOutcomePageSchema,
@@ -158,8 +195,12 @@ import {
   trackerPreviewSchema,
   trackerQuerySchema,
   trackerStatusSchema,
-  trackerSummarySchema
-} from "../chunk-JON5SESL.js";
+  trackerSummarySchema,
+  trackerTriggerOutcomePageSchema,
+  trackerTriggerOutcomeQuerySchema,
+  updateGroupSchema,
+  whereSchemaIssue
+} from "../chunk-KGJSKGKI.js";
 
 // src/server/test-members.ts
 import { z } from "zod";
@@ -213,6 +254,12 @@ var testMemberHistorySchema = z.object({
 
 // src/server/webhooks.ts
 import { z as z2 } from "zod";
+var PayoutSourceKind = {
+  Quest: "quest",
+  Leaderboard: "leaderboard",
+  Engagement: "engagement",
+  Manual: "manual"
+};
 var webhookEventSchema = z2.object({
   id: z2.string().uuid(),
   version: z2.literal(1),
@@ -258,11 +305,16 @@ var webhookDeliverySchema = z2.object({
   replayOf: z2.string().uuid().nullable()
 });
 var webhookQuerySchema = z2.object({
+  /** A page's `nextCursor`: the deliveries after it, newest first. */
+  cursor: pageCursorSchema.optional(),
+  /** @deprecated Use `cursor`. Removed in 2.0.0. */
   before: z2.string().uuid().optional(),
   limit: z2.coerce.number().int().min(1).max(100).default(50)
 }).strict();
 var webhookDeliveryPageSchema = z2.object({
   items: z2.array(webhookDeliverySchema),
+  nextCursor: pageCursorSchema.nullable().default(null),
+  /** @deprecated Use `nextCursor`, passed back as `cursor`. Removed in 2.0.0. */
   next: z2.string().uuid().nullable()
 });
 var WEBHOOK_MAX_BYTES = 64 * 1024;
@@ -339,9 +391,10 @@ var resourceLifecycleResultSchema = z3.object({
 });
 
 // src/server/index.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/server/errors.ts
+import { z as z4 } from "zod";
 var ManagementErrorCode = {
   /** The input or an option failed validation before anything was sent (kind `client`). */
   InvalidInput: "invalid-input",
@@ -352,6 +405,10 @@ var ManagementErrorCode = {
   Aborted: "aborted",
   InvalidResponse: "invalid-response"
 };
+var managementErrorSchema = z4.looseObject({
+  error: z4.string(),
+  code: z4.string().optional()
+});
 var uncertainStatuses = /* @__PURE__ */ new Set([500, 502, 504]);
 function uncertainOutcome(init) {
   if (init.method === void 0 || init.method === "GET") {
@@ -402,10 +459,10 @@ var ManagementError = class extends RequestError {
 var DEFAULT_MANAGEMENT_TIMEOUT = MANAGEMENT_TIMEOUT;
 
 // src/server/hosting.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/server/starters.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var starterTemplates = [
   {
     id: "campaign",
@@ -438,63 +495,63 @@ var starterTemplates = [
     summary: "A headless Worker with typed routes and interactive API docs, for plugging Domino into your own product."
   }
 ];
-var starterIdSchema = z4.enum(
+var starterIdSchema = z5.enum(
   starterTemplates.map((template) => template.id)
 );
 
 // src/server/hosting.ts
-var outputPathSchema = z5.string().min(1).max(512).refine(
+var outputPathSchema = z6.string().min(1).max(512).refine(
   (path) => path.split("/").every(
     (part) => /^[\w-][\w.-]*$/.test(part) && part !== "node_modules"
   ),
   "Expected a relative build output path without hidden segments"
 );
-var appRoutingSchema = z5.enum(["legacy", "transparent"]).default("legacy");
+var appRoutingSchema = z6.enum(["legacy", "transparent"]).default("legacy");
 var APP_SECRET_LIMIT = 50;
 var APP_KV_LIMIT = 5;
 var APP_SQL_LIMIT = 5;
 var APP_MIGRATION_LIMIT = 100;
 var APP_MIGRATION_FILE_BYTES = 9e4;
 var APP_MIGRATION_TOTAL_BYTES = 1e6;
-var appSecretNameSchema = z5.string().regex(
+var appSecretNameSchema = z6.string().regex(
   /^[A-Z_][A-Z0-9_]{0,63}$/,
   "Use 1-64 uppercase letters, digits, and underscores, not starting with a digit"
 ).refine(
   (name) => !name.startsWith("DOMINO_") && name !== "ASSETS",
   "DOMINO_ names and ASSETS are reserved for Domino's own bindings"
 );
-var appSecretValueSchema = z5.string().min(1).refine(
+var appSecretValueSchema = z6.string().min(1).refine(
   (value) => new TextEncoder().encode(value).length <= 5120,
   "Secret values can be at most 5 KiB"
 );
-var appSecretInputSchema = z5.object({ value: appSecretValueSchema }).strict();
-var appSecretSchema = z5.object({
+var appSecretInputSchema = z6.object({ value: appSecretValueSchema }).strict();
+var appSecretSchema = z6.object({
   name: appSecretNameSchema,
-  updatedAt: z5.number(),
-  updatedBy: z5.string()
+  updatedAt: z6.number(),
+  updatedBy: z6.string()
 });
-var appSecretDeclarationSchema = z5.object({
-  description: z5.string().trim().min(1).max(500),
-  required: z5.boolean().default(true)
+var appSecretDeclarationSchema = z6.object({
+  description: z6.string().trim().min(1).max(500),
+  required: z6.boolean().default(true)
 }).strict();
-var appSecretDeclarationsSchema = z5.record(appSecretNameSchema, appSecretDeclarationSchema).refine(
+var appSecretDeclarationsSchema = z6.record(appSecretNameSchema, appSecretDeclarationSchema).refine(
   (secrets) => Object.keys(secrets).length <= APP_SECRET_LIMIT,
   `Declare at most ${APP_SECRET_LIMIT} app secrets`
 );
-var appSecretListSchema = z5.object({
-  secrets: z5.array(appSecretSchema),
-  declared: z5.array(appSecretDeclarationSchema.extend({ name: appSecretNameSchema })).default([])
+var appSecretListSchema = z6.object({
+  secrets: z6.array(appSecretSchema),
+  declared: z6.array(appSecretDeclarationSchema.extend({ name: appSecretNameSchema })).default([])
 });
-var hostedAppSecretsSchema = z5.object({ secrets: z5.record(appSecretNameSchema, appSecretValueSchema) }).strict();
-var storageDescription = z5.object({
-  description: z5.string().trim().min(1).max(500)
+var hostedAppSecretsSchema = z6.object({ secrets: z6.record(appSecretNameSchema, appSecretValueSchema) }).strict();
+var storageDescription = z6.object({
+  description: z6.string().trim().min(1).max(500)
 }).strict();
-var appStorageSchema = z5.object({
-  kv: z5.record(appSecretNameSchema, storageDescription).refine(
+var appStorageSchema = z6.object({
+  kv: z6.record(appSecretNameSchema, storageDescription).refine(
     (stores) => Object.keys(stores).length <= APP_KV_LIMIT,
     `Declare at most ${APP_KV_LIMIT} KV stores`
   ).default({}),
-  sql: z5.record(
+  sql: z6.record(
     appSecretNameSchema,
     storageDescription.extend({
       migrations: outputPathSchema.optional()
@@ -504,55 +561,60 @@ var appStorageSchema = z5.object({
     `Declare at most ${APP_SQL_LIMIT} SQL stores`
   ).default({})
 }).strict();
-var appStorageKindSchema = z5.enum(["kv", "sql"]);
-var appStorageListSchema = z5.object({
-  stores: z5.array(
-    z5.object({
-      kind: z5.string(),
+var appStorageKindSchema = z6.enum(["kv", "sql"]);
+var appStorageListSchema = z6.object({
+  stores: z6.array(
+    z6.object({
+      kind: z6.string(),
       name: appSecretNameSchema,
-      createdAt: z5.number().nullable(),
-      declared: z5.boolean(),
-      description: z5.string().optional()
+      createdAt: z6.number().nullable(),
+      declared: z6.boolean(),
+      description: z6.string().optional()
     })
   )
 });
 var APP_STORAGE_ROW_LIMIT = 50;
 var APP_STORAGE_PREVIEW_CHARACTERS = 2e3;
-var appStorageCellSchema = z5.union([
-  z5.string(),
-  z5.number(),
-  z5.null(),
-  z5.object({ text: z5.string(), truncated: z5.literal(true) }),
-  z5.object({ blob: z5.number().int().min(0) })
+var appStorageCellSchema = z6.union([
+  z6.string(),
+  z6.number(),
+  z6.null(),
+  z6.object({ text: z6.string(), truncated: z6.literal(true) }),
+  z6.object({ blob: z6.number().int().min(0) })
 ]);
-var appStorageTablesSchema = z5.object({
-  tables: z5.array(
+var appStorageTablesSchema = z6.object({
+  tables: z6.array(
     /** `kind` is SQLite's: `table` or `view`. */
-    z5.object({ name: z5.string(), kind: z5.string() })
+    z6.object({ name: z6.string(), kind: z6.string() })
   )
 });
-var appStorageRowsSchema = z5.object({
-  table: z5.string(),
-  columns: z5.array(z5.string()),
-  rows: z5.array(z5.array(appStorageCellSchema)),
-  offset: z5.number().int().min(0),
-  total: z5.number().int().min(0)
+var appStorageRowsSchema = z6.object({
+  table: z6.string(),
+  columns: z6.array(z6.string()),
+  rows: z6.array(z6.array(appStorageCellSchema)),
+  /** How many rows come before this page in storage order. */
+  offset: z6.number().int().min(0),
+  total: z6.number().int().min(0),
+  /** Pass back as `cursor` for the next page; null on the last one. */
+  nextCursor: pageCursorSchema.nullable().default(null)
 });
-var appStorageKeysSchema = z5.object({
-  keys: z5.array(
-    z5.object({ name: z5.string(), expiration: z5.number().nullable() })
+var appStorageKeysSchema = z6.object({
+  keys: z6.array(
+    z6.object({ name: z6.string(), expiration: z6.number().nullable() })
   ),
-  /** Pass back to read the next page; null on the last one. */
-  cursor: z5.string().nullable()
+  /** Pass back as `cursor` for the next page; null on the last one. */
+  nextCursor: pageCursorSchema.nullable().default(null),
+  /** @deprecated Use `nextCursor`. Removed in 2.0.0. */
+  cursor: z6.string().nullable()
 });
-var appStorageValueSchema = z5.object({
-  key: z5.string(),
-  size: z5.number().int().min(0),
+var appStorageValueSchema = z6.object({
+  key: z6.string(),
+  size: z6.number().int().min(0),
   /** Null when the value is not UTF-8 text. */
-  text: z5.string().nullable(),
-  truncated: z5.boolean()
+  text: z6.string().nullable(),
+  truncated: z6.boolean()
 });
-var appMigrationNameSchema = z5.string().max(255).regex(/^[\w-][\w.-]*\.sql$/);
+var appMigrationNameSchema = z6.string().max(255).regex(/^[\w-][\w.-]*\.sql$/);
 function compareAppMigrations(a, b) {
   const left = Number.parseInt(a.split("_")[0], 10);
   const right = Number.parseInt(b.split("_")[0], 10);
@@ -569,12 +631,12 @@ function compareAppMigrations(a, b) {
   }
   return a < b ? -1 : a > b ? 1 : 0;
 }
-var appMigrationsSchema = z5.record(
+var appMigrationsSchema = z6.record(
   appSecretNameSchema,
-  z5.array(
-    z5.object({
+  z6.array(
+    z6.object({
       name: appMigrationNameSchema,
-      sql: z5.string().min(1).refine(
+      sql: z6.string().min(1).refine(
         (sql) => new TextEncoder().encode(sql).length <= APP_MIGRATION_FILE_BYTES,
         `A migration file must not exceed ${APP_MIGRATION_FILE_BYTES} bytes`
       )
@@ -592,21 +654,21 @@ var appMigrationsSchema = z5.record(
 );
 var appScripts = {
   routing: appRoutingSchema,
-  devScript: z5.string().regex(/^[\w:-]+$/),
-  checkScript: z5.string().regex(/^[\w:-]+$/),
-  buildScript: z5.string().regex(/^[\w:-]+$/)
+  devScript: z6.string().regex(/^[\w:-]+$/),
+  checkScript: z6.string().regex(/^[\w:-]+$/),
+  buildScript: z6.string().regex(/^[\w:-]+$/)
 };
 var workerSettings = {
-  runWorkerFirst: z5.boolean().default(false),
+  runWorkerFirst: z6.boolean().default(false),
   main: outputPathSchema.refine(
     (path) => /\.m?js$/.test(path),
     "Expected a compiled JavaScript entry"
   ),
-  compatibilityDate: z5.string().regex(/^\d{4}-\d{2}-\d{2}$/),
-  compatibilityFlags: z5.array(z5.string().min(1)).max(50).default([]),
-  vars: z5.record(
-    z5.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).refine((name) => name !== "ASSETS"),
-    z5.string()
+  compatibilityDate: z6.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  compatibilityFlags: z6.array(z6.string().min(1)).max(50).default([]),
+  vars: z6.record(
+    z6.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).refine((name) => name !== "ASSETS"),
+    z6.string()
   ).default({}),
   secrets: appSecretDeclarationsSchema.default({}),
   storage: appStorageSchema.optional()
@@ -634,62 +696,62 @@ var distinctBindings = (worker, ctx) => {
     }
   }
 };
-var hostedAppSchema = z5.discriminatedUnion("kind", [
-  z5.object({
-    kind: z5.literal("static"),
+var hostedAppSchema = z6.discriminatedUnion("kind", [
+  z6.object({
+    kind: z6.literal("static"),
     directory: outputPathSchema,
     ...appScripts
   }).strict(),
-  z5.object({
-    kind: z5.literal("worker"),
+  z6.object({
+    kind: z6.literal("worker"),
     directory: outputPathSchema,
     assetsDirectory: outputPathSchema.optional(),
     ...appScripts,
     ...workerSettings
   }).strict().superRefine(distinctBindings)
 ]);
-var repositorySchema = z5.object({
-  id: z5.string().uuid(),
+var repositorySchema = z6.object({
+  id: z6.string().uuid(),
   organization: identifier,
   project: identifier,
-  remote: z5.string().url(),
-  defaultBranch: z5.string(),
-  status: z5.enum(["provisioning", "ready"])
+  remote: z6.string().url(),
+  defaultBranch: z6.string(),
+  status: z6.enum(["provisioning", "ready"])
 });
-var createRepositorySchema = z5.object({
+var createRepositorySchema = z6.object({
   /** Omitted: the starter chosen at project setup, else `campaign`. */
   starter: starterIdSchema.optional()
 }).strict();
-var deviceStartSchema = z5.object({
-  challenge: z5.string().regex(/^[a-f0-9]{64}$/)
+var deviceStartSchema = z6.object({
+  challenge: z6.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var deviceRedeemSchema = z5.object({
-  id: z5.string().uuid(),
-  verifier: z5.string().min(43).max(128)
+var deviceRedeemSchema = z6.object({
+  id: z6.string().uuid(),
+  verifier: z6.string().min(43).max(128)
 }).strict();
-var deviceApproveSchema = z5.object({
-  id: z5.string().uuid(),
-  code: z5.string().regex(/^[A-F0-9]{4}-[A-F0-9]{4}$/)
+var deviceApproveSchema = z6.object({
+  id: z6.string().uuid(),
+  code: z6.string().regex(/^[A-F0-9]{4}-[A-F0-9]{4}$/)
 }).strict();
-var commitSchema = z5.string().regex(/^[a-f0-9]{40}$/);
-var stageRequestSchema = z5.object({
+var commitSchema = z6.string().regex(/^[a-f0-9]{40}$/);
+var stageRequestSchema = z6.object({
   commit: commitSchema,
-  requestId: z5.string().uuid()
+  requestId: z6.string().uuid()
 }).strict();
-var buildIdentitySchema = z5.object({
+var buildIdentitySchema = z6.object({
   routing: appRoutingSchema,
-  slug: z5.string().min(1).max(35).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional(),
-  runtime: z5.enum(["simulation", "hosted-test"]).default("simulation"),
-  id: z5.string().uuid(),
-  repository: z5.string().uuid(),
+  slug: z6.string().min(1).max(35).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional(),
+  runtime: z6.enum(["simulation", "hosted-test"]).default("simulation"),
+  id: z6.string().uuid(),
+  repository: z6.string().uuid(),
   organization: identifier,
   project: identifier,
   commit: commitSchema,
-  createdAt: z5.number(),
-  actor: z5.string(),
-  commitMessage: z5.string().max(500).optional()
+  createdAt: z6.number(),
+  actor: z6.string(),
+  commitMessage: z6.string().max(500).optional()
 });
-var buildPhaseSchema = z5.enum([
+var buildPhaseSchema = z6.enum([
   "queued",
   "source",
   "install",
@@ -699,72 +761,72 @@ var buildPhaseSchema = z5.enum([
   "ready",
   "failed"
 ]);
-var buildStatusSchema = z5.object({
+var buildStatusSchema = z6.object({
   phase: buildPhaseSchema,
   failedPhase: buildPhaseSchema.optional(),
-  updatedAt: z5.number(),
-  message: z5.string()
+  updatedAt: z6.number(),
+  message: z6.string()
 });
 var hostedBuildSchema = buildIdentitySchema.extend({
   ...buildStatusSchema.shape,
-  finished: z5.boolean(),
-  current: z5.boolean(),
-  stagingUrl: z5.string().url()
-});
-var stagingAccessModeSchema = z5.enum(["console", "password"]);
-var stagingAccessSchema = z5.object({ mode: stagingAccessModeSchema });
-var stagingAccessInputSchema = z5.discriminatedUnion("mode", [
-  z5.object({ mode: z5.literal("console") }).strict(),
-  z5.object({
-    mode: z5.literal("password"),
-    password: z5.string().min(8).max(128)
+  finished: z6.boolean(),
+  current: z6.boolean(),
+  stagingUrl: z6.string().url()
+});
+var stagingAccessModeSchema = z6.enum(["console", "password"]);
+var stagingAccessSchema = z6.object({ mode: stagingAccessModeSchema });
+var stagingAccessInputSchema = z6.discriminatedUnion("mode", [
+  z6.object({ mode: z6.literal("console") }).strict(),
+  z6.object({
+    mode: z6.literal("password"),
+    password: z6.string().min(8).max(128)
   }).strict()
 ]);
-var stagingPathSchema = z5.string().max(2048).refine(
+var stagingPathSchema = z6.string().max(2048).refine(
   (path) => path.startsWith("/") && !path.startsWith("//") && !path.includes("\\"),
   "Expected a path on the staging host"
 );
-var stagingLinkSchema = z5.object({
-  url: z5.string().url(),
-  expiresAt: z5.number()
+var stagingLinkSchema = z6.object({
+  url: z6.string().url(),
+  expiresAt: z6.number()
 });
-var buildSnapshotSchema = z5.object({
-  builds: z5.array(hostedBuildSchema),
+var buildSnapshotSchema = z6.object({
+  builds: z6.array(hostedBuildSchema),
   current: hostedBuildSchema.nullable(),
   selected: hostedBuildSchema.nullable(),
-  logs: z5.string()
+  logs: z6.string()
 });
-var assetPathSchema = z5.string().max(512).refine(
+var assetPathSchema = z6.string().max(512).refine(
   (path) => path.startsWith("/") && // oxlint-disable-next-line no-control-regex -- Asset paths must reject control characters.
   !/[\\\u0000-\u001f?#%]/.test(path) && path.slice(1).split("/").every((part) => part.length > 0 && !part.startsWith(".")),
   "Expected a public asset path without hidden segments"
 );
-var base64Schema = z5.string().regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/);
+var base64Schema = z6.string().regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/);
 var stagedDeploymentLimits = {
   /** Bytes of JSON, uncompressed. */
   size: 64e6,
   /** Bytes of the Brotli-compressed object. */
   compressedSize: 1e7
 };
-var stagedDeploymentSchema = z5.object({
-  encoding: z5.literal("br"),
-  sha256: z5.string().regex(/^[0-9a-f]{64}$/),
-  compressedSize: z5.number().int().positive().max(stagedDeploymentLimits.compressedSize),
-  size: z5.number().int().positive().max(stagedDeploymentLimits.size)
+var stagedDeploymentSchema = z6.object({
+  encoding: z6.literal("br"),
+  sha256: z6.string().regex(/^[0-9a-f]{64}$/),
+  compressedSize: z6.number().int().positive().max(stagedDeploymentLimits.compressedSize),
+  size: z6.number().int().positive().max(stagedDeploymentLimits.size)
 }).strict();
 var stagedDeploymentContentSchema = stagedDeploymentSchema.extend({
-  content: z5.string().max(Math.ceil(stagedDeploymentLimits.compressedSize / 3) * 4)
+  content: z6.string().max(Math.ceil(stagedDeploymentLimits.compressedSize / 3) * 4)
 }).strict();
 var stagedDeploymentKey = (build, sha256) => `builds/${build}/deployment/${sha256}.br`;
 var artifactFields = {
   routing: appRoutingSchema,
-  worker: z5.object({
+  worker: z6.object({
     ...workerSettings,
     migrations: appMigrationsSchema.optional(),
-    modules: z5.array(
-      z5.object({
+    modules: z6.array(
+      z6.object({
         path: outputPathSchema.refine((path) => path !== "metadata"),
-        type: z5.enum([
+        type: z6.enum([
           "application/javascript+module",
           "application/wasm",
           "text/plain",
@@ -774,26 +836,26 @@ var artifactFields = {
       }).strict()
     ).min(1).max(500)
   }).strict().superRefine(distinctBindings).optional(),
-  assets: z5.array(
-    z5.object({
+  assets: z6.array(
+    z6.object({
       path: assetPathSchema,
       content: base64Schema.max(14e6),
-      size: z5.number().int().min(0).max(1e7)
+      size: z6.number().int().min(0).max(1e7)
     }).strict()
   ).max(500)
 };
-var buildArtifactsSchema = z5.discriminatedUnion("format", [
-  z5.object({
-    format: z5.literal(1),
+var buildArtifactsSchema = z6.discriminatedUnion("format", [
+  z6.object({
+    format: z6.literal(1),
     ...artifactFields,
-    quests: z5.unknown(),
-    catalog: z5.unknown()
+    quests: z6.unknown(),
+    catalog: z6.unknown()
   }).strict(),
-  z5.object({
-    format: z5.literal(2),
+  z6.object({
+    format: z6.literal(2),
     ...artifactFields,
     deployment: stagedDeploymentSchema,
-    images: z5.array(imageAssetArtifactSchema).max(10)
+    images: z6.array(imageAssetArtifactSchema).max(10)
   }).strict()
 ]).superRefine((value, ctx) => {
   if (value.worker) {
@@ -845,39 +907,39 @@ var buildArtifactsSchema = z5.discriminatedUnion("format", [
 });
 
 // src/server/development.ts
-import { z as z6 } from "zod";
-var developmentPreflightSchema = z6.object({
-  organization: z6.string(),
-  project: z6.string(),
-  environment: z6.enum(["test", "live"]),
-  identity: z6.object({
-    exchange: z6.literal("supported"),
-    activeIntegrations: z6.number().int().nonnegative()
+import { z as z7 } from "zod";
+var developmentPreflightSchema = z7.object({
+  organization: z7.string(),
+  project: z7.string(),
+  environment: z7.enum(["test", "live"]),
+  identity: z7.object({
+    exchange: z7.literal("supported"),
+    activeIntegrations: z7.number().int().nonnegative()
   }).optional(),
-  staging: z6.enum(["configured", "blocked"]),
-  development: z6.object({
-    status: z6.enum(["configured", "blocked"]),
+  staging: z7.enum(["configured", "blocked"]),
+  development: z7.object({
+    status: z7.enum(["configured", "blocked"]),
     // How `domino dev` reaches the preview origin: a Cloudflare tunnel, or a direct route on a
     // local development stack. APIs that predate the field use tunnels.
-    transport: z6.enum(["tunnel", "direct"]).default("tunnel"),
-    missing: z6.array(z6.string()),
-    authentication: z6.array(z6.string())
+    transport: z7.enum(["tunnel", "direct"]).default("tunnel"),
+    missing: z7.array(z7.string()),
+    authentication: z7.array(z7.string())
   }),
-  checks: z6.array(
-    z6.object({
-      id: z6.string(),
-      status: z6.enum(["ok", "error"]),
-      message: z6.string(),
-      missing: z6.array(z6.string()).optional(),
-      issues: z6.array(z6.string()).optional()
+  checks: z7.array(
+    z7.object({
+      id: z7.string(),
+      status: z7.enum(["ok", "error"]),
+      message: z7.string(),
+      missing: z7.array(z7.string()).optional(),
+      issues: z7.array(z7.string()).optional()
     })
   )
 });
 
 // src/server/hosted.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var hostedKeyPermissions = ["read", "points", "ingest"];
-var hostedKeyPermissionList = z7.array(z7.string()).transform(
+var hostedKeyPermissionList = z8.array(z8.string()).transform(
   (values) => values.filter(
     (value) => hostedKeyPermissions.includes(value)
   )
@@ -889,17 +951,17 @@ var hostedManagementBindings = [
   "DOMINO_PROJECT",
   "DOMINO_ENVIRONMENT"
 ];
-var hostedKeySecretSchema = z7.string().regex(/^dhk_[A-Za-z0-9_-]{43}$/, "Expected a hosted app key");
-var hostedKeySchema = z7.object({
-  id: z7.string().uuid(),
+var hostedKeySecretSchema = z8.string().regex(/^dhk_[A-Za-z0-9_-]{43}$/, "Expected a hosted app key");
+var hostedKeySchema = z8.object({
+  id: z8.string().uuid(),
   token: hostedKeySecretSchema,
   organization: identifier,
   project: identifier,
-  environment: z7.enum(["test", "live"]),
+  environment: z8.enum(["test", "live"]),
   permissions: hostedKeyPermissionList,
-  expiresAt: z7.number().nullable()
+  expiresAt: z8.number().nullable()
 }).strict();
-var hostedDeploymentKeySchema = hostedKeySchema.extend({ apiUrl: z7.string().url() }).strict();
+var hostedDeploymentKeySchema = hostedKeySchema.extend({ apiUrl: z8.string().url() }).strict();
 function hostedManagementClient(env) {
   const missing = hostedManagementBindings.filter((name) => !env[name]);
   if (missing.length) {
@@ -907,7 +969,7 @@ function hostedManagementClient(env) {
       `Missing ${missing.join(", ")}. Domino sets these for hosted apps and domino dev; update the project's vite.config.ts to forward them in development.`
     );
   }
-  const environment = z7.enum(["test", "live"]).parse(env.DOMINO_ENVIRONMENT);
+  const environment = z8.enum(["test", "live"]).parse(env.DOMINO_ENVIRONMENT);
   const token = env.DOMINO_MANAGEMENT_KEY;
   return createManagementClient({
     baseUrl: env.DOMINO_API_URL.replace(/\/+$/, ""),
@@ -919,9 +981,9 @@ function hostedManagementClient(env) {
 }
 
 // src/server/index.ts
-var environmentSchema = z8.enum(["test", "live"]);
-var roleSchema = z8.enum(["editor", "reviewer", "staff"]);
-var permissionSchema = z8.enum([
+var environmentSchema = z9.enum(["test", "live"]);
+var roleSchema = z9.enum(["editor", "reviewer", "staff"]);
+var permissionSchema = z9.enum([
   "read",
   "publish",
   "review",
@@ -941,7 +1003,7 @@ var permissionSchema = z8.enum([
    */
   "enroll"
 ]);
-var permissionListSchema = z8.array(z8.string()).transform(
+var permissionListSchema = z9.array(z9.string()).transform(
   (values) => values.filter(
     (value) => permissionSchema.safeParse(value).success
   )
@@ -951,33 +1013,33 @@ var rolePermissions = {
   reviewer: ["read", "review"],
   staff: ["read", "confirm", "handover"]
 };
-var projectSetupSchema = z8.object({
-  mode: z8.enum(["new", "existing"]),
-  brief: z8.string().trim().min(1).max(4e3)
+var projectSetupSchema = z9.object({
+  mode: z9.enum(["new", "existing"]),
+  brief: z9.string().trim().min(1).max(4e3)
 }).strict();
-var operatorUserSchema = z8.object({
-  id: z8.string(),
-  name: z8.string().nullable(),
-  email: z8.string().nullable(),
-  avatar: z8.string().nullable()
-});
-var projectSchema = z8.object({
-  slug: z8.string().min(1).max(35).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  createdBy: z8.string().nullable().optional(),
+var operatorUserSchema = z9.object({
+  id: z9.string(),
+  name: z9.string().nullable(),
+  email: z9.string().nullable(),
+  avatar: z9.string().nullable()
+});
+var projectSchema = z9.object({
+  slug: z9.string().min(1).max(35).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+  createdBy: z9.string().nullable().optional(),
   creator: operatorUserSchema.nullable().optional(),
   /** A response, so fields a newer server adds to the setup are dropped, not rejected. */
-  setup: z8.object(projectSetupSchema.shape).optional(),
+  setup: z9.object(projectSetupSchema.shape).optional(),
   /** The starter chosen at setup. A plain string, so later starters still parse. */
-  starter: z8.string().optional(),
-  id: z8.string().min(1),
+  starter: z9.string().optional(),
+  id: z9.string().min(1),
   organization: identifier,
   project: identifier,
-  name: z8.string(),
-  subtitle: z8.string(),
-  initials: z8.string(),
-  color: z8.string(),
+  name: z9.string(),
+  subtitle: z9.string(),
+  initials: z9.string(),
+  color: z9.string(),
   permissions: permissionListSchema,
-  environments: z8.array(environmentSchema)
+  environments: z9.array(environmentSchema)
 }).refine(
   (project) => !project.creator || project.creator.id === project.createdBy,
   {
@@ -985,45 +1047,45 @@ var projectSchema = z8.object({
     path: ["creator"]
   }
 );
-var projectInputSchema = z8.object({
+var projectInputSchema = z9.object({
   actionId: identifier,
-  name: z8.string().trim().min(1).max(80),
+  name: z9.string().trim().min(1).max(80),
   setup: projectSetupSchema.optional(),
   /** The starter a new hosted app begins from, with `setup.mode` "new". */
   starter: starterIdSchema.optional()
 }).strict();
-var projectUpdateInputSchema = z8.union([
-  z8.object({ name: projectInputSchema.shape.name }).strict(),
-  z8.object({
+var projectUpdateInputSchema = z9.union([
+  z9.object({ name: projectInputSchema.shape.name }).strict(),
+  z9.object({
     slug: projectSchema.shape.slug,
-    confirm: z8.string().min(1).max(80)
+    confirm: z9.string().min(1).max(80)
   }).strict()
 ]);
-var projectDeletionInputSchema = z8.object({ confirm: z8.string().min(1).max(80) }).strict();
-var projectDeletionSchema = z8.object({
+var projectDeletionInputSchema = z9.object({ confirm: z9.string().min(1).max(80) }).strict();
+var projectDeletionSchema = z9.object({
   project: identifier,
-  purgeAfter: z8.number().int()
+  purgeAfter: z9.number().int()
 });
-var projectTransferInputSchema = z8.object({ organization: identifier, confirm: z8.string().min(1).max(80) }).strict();
-var projectTransferSchema = z8.object({
+var projectTransferInputSchema = z9.object({ organization: identifier, confirm: z9.string().min(1).max(80) }).strict();
+var projectTransferSchema = z9.object({
   organization: identifier,
   project: identifier
 });
-var grantSchema = z8.object({
-  subject: z8.string().min(1).max(200),
-  roles: z8.array(roleSchema),
-  environments: z8.array(environmentSchema)
+var grantSchema = z9.object({
+  subject: z9.string().min(1).max(200),
+  roles: z9.array(roleSchema),
+  environments: z9.array(environmentSchema)
 }).strict();
-var grantRecordSchema = z8.object(grantSchema.shape);
-var stockAdditionSchema = z8.object({
+var grantRecordSchema = z9.object(grantSchema.shape);
+var stockAdditionSchema = z9.object({
   item: identifier,
-  quantity: z8.number().int(),
+  quantity: z9.number().int(),
   actionId: identifier
 });
-var completionRevokeSchema = z8.object({
+var completionRevokeSchema = z9.object({
   actionId: identifier,
-  reason: z8.string().trim().min(1).max(500),
-  freeOccurrence: z8.boolean().default(false)
+  reason: z9.string().trim().min(1).max(500),
+  freeOccurrence: z9.boolean().default(false)
 }).strict();
 var RevokedEntitlementOutcome = {
   /** No other completion grants the reward: it is void, after cancelling a handover in progress. */
@@ -1051,213 +1113,216 @@ var RevokedReferralOutcome = {
   /** Qualified on another accepted completion of the program's quest instead. */
   Requalified: "requalified"
 };
-var entitlementOutcomeSchema = z8.string().min(1).max(64);
-var deliveryOutcomeSchema = z8.string().min(1).max(64);
-var referralOutcomeSchema = z8.string().min(1).max(64);
-var completionRevocationSchema = z8.object({
+var entitlementOutcomeSchema = z9.string().min(1).max(64);
+var deliveryOutcomeSchema = z9.string().min(1).max(64);
+var referralOutcomeSchema = z9.string().min(1).max(64);
+var completionRevocationSchema = z9.object({
   completion: identifier,
+  /** The quest ID, or the board ID when `source.kind` is `leaderboard`. */
   quest: identifier,
   member: identifier,
-  revokedAt: z8.number(),
-  occurrenceFreed: z8.boolean(),
-  points: z8.array(
-    z8.object({
+  /** What paid the revoked completion. `source.id` repeats `quest`. */
+  source: completionSourceSchema.optional(),
+  revokedAt: z9.number(),
+  occurrenceFreed: z9.boolean(),
+  points: z9.array(
+    z9.object({
       entry: identifier,
       balance: identifier,
       reversal: identifier.nullable(),
-      reversed: z8.number().int(),
-      unreversed: z8.number().int()
+      reversed: z9.number().int(),
+      unreversed: z9.number().int()
     })
   ),
-  entitlements: z8.array(
-    z8.object({
+  entitlements: z9.array(
+    z9.object({
       entitlement: identifier,
       reward: identifier,
       outcome: entitlementOutcomeSchema,
-      status: z8.string()
+      status: z9.string()
     })
   ),
-  deliveries: z8.array(
-    z8.object({
-      delivery: z8.string(),
-      roleId: z8.string(),
+  deliveries: z9.array(
+    z9.object({
+      delivery: z9.string(),
+      roleId: z9.string(),
       outcome: deliveryOutcomeSchema,
       /**
        * By Relay's records, another accepted, unrevoked completion of the member also granted this
        * role to the same Discord account and server. Relay does not read Discord's membership.
        */
-      stillGranted: z8.boolean()
+      stillGranted: z9.boolean()
     })
   ),
-  referrals: z8.array(
-    z8.object({
+  referrals: z9.array(
+    z9.object({
       program: identifier,
       outcome: referralOutcomeSchema
     })
   ),
-  streakMilestone: z8.boolean()
-});
-var accessSchema = z8.object({
-  actor: z8.string(),
-  organization: z8.string(),
-  admin: z8.boolean(),
-  local: z8.boolean(),
-  projects: z8.array(projectSchema)
-});
-var querySchema = z8.object({
-  q: z8.string().max(200).default(""),
-  filter: z8.string().max(50).default("all"),
-  offset: z8.coerce.number().int().min(0).max(1e6).default(0),
-  limit: z8.coerce.number().int().min(1).max(100).default(25)
-});
-var accountProfileSchema = z8.object({
-  name: z8.string().optional(),
+  streakMilestone: z9.boolean()
+});
+var accessSchema = z9.object({
+  actor: z9.string(),
+  organization: z9.string(),
+  admin: z9.boolean(),
+  local: z9.boolean(),
+  projects: z9.array(projectSchema)
+});
+var querySchema = z9.object({
+  q: z9.string().max(200).default(""),
+  filter: z9.string().max(50).default("all"),
+  offset: z9.coerce.number().int().min(0).max(1e6).default(0),
+  limit: z9.coerce.number().int().min(1).max(100).default(25)
+});
+var accountProfileSchema = z9.object({
+  name: z9.string().optional(),
   /** The account's handle, where the provider has one (X and Discord). */
-  username: z8.string().optional(),
-  email: z8.string().optional(),
-  emailVerified: z8.boolean().default(false),
-  imageUrl: z8.string().url().optional()
+  username: z9.string().optional(),
+  email: z9.string().optional(),
+  emailVerified: z9.boolean().default(false),
+  imageUrl: z9.string().url().optional()
 });
-var memberAccountSchema = z8.object({
+var memberAccountSchema = z9.object({
   /** `wallet` for wallet sign-in, `account` for every other connected account. */
-  kind: z8.enum(["account", "wallet"]),
-  provider: z8.string(),
-  subject: z8.string(),
-  signInEnabled: z8.boolean(),
+  kind: z9.enum(["account", "wallet"]),
+  provider: z9.string(),
+  subject: z9.string(),
+  signInEnabled: z9.boolean(),
   profile: accountProfileSchema.optional()
 });
-var operationSchema = z8.object({
-  target: z8.string(),
-  paused: z8.boolean(),
-  revision: z8.number().int(),
-  reason: z8.string(),
-  actor: z8.string().nullable(),
-  changedAt: z8.number()
-});
-var operationInputSchema = z8.object({
-  target: z8.union([
-    z8.literal("redemptions"),
-    z8.string().regex(/^quest:[\w-]+$/)
+var operationSchema = z9.object({
+  target: z9.string(),
+  paused: z9.boolean(),
+  revision: z9.number().int(),
+  reason: z9.string(),
+  actor: z9.string().nullable(),
+  changedAt: z9.number()
+});
+var operationInputSchema = z9.object({
+  target: z9.union([
+    z9.literal("redemptions"),
+    z9.string().regex(/^quest:[\w-]+$/)
   ]),
-  paused: z8.boolean(),
-  revision: z8.number().int().nonnegative(),
-  reason: z8.string().trim().min(1).max(500),
+  paused: z9.boolean(),
+  revision: z9.number().int().nonnegative(),
+  reason: z9.string().trim().min(1).max(500),
   actionId: identifier
 }).strict();
-var questLifecycleInputSchema = z8.object({
+var questLifecycleInputSchema = z9.object({
   quest: identifier,
   expectedRelease: identifier.optional(),
-  archived: z8.boolean(),
-  reason: z8.string().trim().min(1).max(500),
+  archived: z9.boolean(),
+  reason: z9.string().trim().min(1).max(500),
   actionId: identifier
 }).strict();
-var questLifecycleSchema = z8.object({
+var questLifecycleSchema = z9.object({
   quest: identifier,
   key: identifier.nullable(),
-  title: z8.string(),
+  title: z9.string(),
   release: identifier,
-  lifecycle: z8.enum(["active", "paused", "archived"]),
-  changed: z8.boolean()
-});
-var memberSchema = z8.object({
-  id: z8.string(),
-  test: z8.boolean().optional(),
-  name: z8.string().nullable().optional(),
-  accounts: z8.array(memberAccountSchema).default([]),
-  attempts: z8.number(),
-  completions: z8.number(),
-  rewards: z8.number(),
-  lastActivity: z8.number().nullable()
-});
-var personSchema = z8.object({
-  id: z8.string(),
-  accounts: z8.array(memberAccountSchema).default([])
-});
-var metricsSchema = z8.object({
-  quests: z8.number(),
-  members: z8.number(),
-  attempts: z8.number(),
-  completions: z8.number(),
-  review: z8.number(),
-  failed: z8.number(),
-  entitlements: z8.number()
-});
-var readinessSchema = z8.object({
-  checks: z8.array(
-    z8.object({
-      id: z8.string(),
-      status: z8.enum(["ready", "blocked"]),
-      title: z8.string(),
-      detail: z8.string()
+  lifecycle: z9.enum(["active", "paused", "archived"]),
+  changed: z9.boolean()
+});
+var memberSchema = z9.object({
+  id: z9.string(),
+  test: z9.boolean().optional(),
+  name: z9.string().nullable().optional(),
+  accounts: z9.array(memberAccountSchema).default([]),
+  attempts: z9.number(),
+  completions: z9.number(),
+  rewards: z9.number(),
+  lastActivity: z9.number().nullable()
+});
+var personSchema = z9.object({
+  id: z9.string(),
+  accounts: z9.array(memberAccountSchema).default([])
+});
+var metricsSchema = z9.object({
+  quests: z9.number(),
+  members: z9.number(),
+  attempts: z9.number(),
+  completions: z9.number(),
+  review: z9.number(),
+  failed: z9.number(),
+  entitlements: z9.number()
+});
+var readinessSchema = z9.object({
+  checks: z9.array(
+    z9.object({
+      id: z9.string(),
+      status: z9.enum(["ready", "blocked"]),
+      title: z9.string(),
+      detail: z9.string()
     })
   )
 });
-var inventorySchema = z8.object({
-  item: z8.string(),
-  name: z8.string().nullable().default(null),
-  available: z8.number(),
-  reserved: z8.number(),
-  allocated: z8.number().default(0)
-});
-var auditRecordSchema = z8.object({
-  id: z8.string(),
-  action: z8.string(),
-  actor: z8.string().nullable(),
+var inventorySchema = z9.object({
+  item: z9.string(),
+  name: z9.string().nullable().default(null),
+  available: z9.number(),
+  reserved: z9.number(),
+  allocated: z9.number().default(0)
+});
+var auditRecordSchema = z9.object({
+  id: z9.string(),
+  action: z9.string(),
+  actor: z9.string().nullable(),
   user: operatorUserSchema.nullable().optional(),
-  detail: z8.string(),
-  at: z8.number(),
-  attempt: z8.string().nullable()
+  detail: z9.string(),
+  at: z9.number(),
+  attempt: z9.string().nullable()
 }).refine((record) => !record.user || record.user.id === record.actor, {
   message: "User profile must match the recorded actor",
   path: ["user"]
 });
-var pageSchema = z8.object({
+var pageSchema = z9.object({
   snapshot: snapshotSchema,
-  members: z8.array(memberSchema),
-  people: z8.array(personSchema).default([]),
+  members: z9.array(memberSchema),
+  people: z9.array(personSchema).default([]),
   metrics: metricsSchema,
-  total: z8.number(),
-  offset: z8.number(),
-  limit: z8.number(),
-  inventory: z8.array(inventorySchema),
-  operations: z8.array(operationSchema).default([]),
-  audit: z8.array(auditRecordSchema).default([]),
-  questCounts: z8.record(z8.string(), z8.number())
-});
-var managedOAuthAccountBaseSchema = z8.object({
-  provider: z8.enum(["x", "discord"]),
-  revision: z8.number().int().nonnegative()
-});
-var managedOAuthAccountSchema = z8.discriminatedUnion("status", [
+  total: z9.number(),
+  offset: z9.number(),
+  limit: z9.number(),
+  inventory: z9.array(inventorySchema),
+  operations: z9.array(operationSchema).default([]),
+  audit: z9.array(auditRecordSchema).default([]),
+  questCounts: z9.record(z9.string(), z9.number())
+});
+var managedOAuthAccountBaseSchema = z9.object({
+  provider: z9.enum(["x", "discord"]),
+  revision: z9.number().int().nonnegative()
+});
+var managedOAuthAccountSchema = z9.discriminatedUnion("status", [
   managedOAuthAccountBaseSchema.extend({
-    status: z8.literal("connected"),
-    subject: z8.string().min(1),
-    linkedAt: z8.number()
+    status: z9.literal("connected"),
+    subject: z9.string().min(1),
+    linkedAt: z9.number()
   }),
-  managedOAuthAccountBaseSchema.extend({ status: z8.literal("disconnected") })
+  managedOAuthAccountBaseSchema.extend({ status: z9.literal("disconnected") })
 ]);
-var memberOAuthUnlinkInputSchema = z8.object({
-  provider: z8.enum(["x", "discord"]),
-  subject: z8.string().min(1).max(4096),
-  revision: z8.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER - 1),
-  reason: z8.string().trim().min(1).max(500)
+var memberOAuthUnlinkInputSchema = z9.object({
+  provider: z9.enum(["x", "discord"]),
+  subject: z9.string().min(1).max(4096),
+  revision: z9.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER - 1),
+  reason: z9.string().trim().min(1).max(500)
 }).strict();
 var managedWalletSchema = linkedWalletSchema.extend({
-  status: z8.enum(["linked", "unlinked"]),
-  unlinkedAt: z8.number().int().nullable(),
+  status: z9.enum(["linked", "unlinked"]),
+  unlinkedAt: z9.number().int().nullable(),
   /** "member", or the operator or key that unlinked it. */
-  unlinkedBy: z8.string().nullable()
+  unlinkedBy: z9.string().nullable()
 });
 var managedMemberIdentitySchema = memberIdentitySchema.extend({
-  status: z8.enum(["linked", "unlinked"]),
-  unlinkedAt: z8.number().int().nullable(),
+  status: z9.enum(["linked", "unlinked"]),
+  unlinkedAt: z9.number().int().nullable(),
   /** The operator or key that unlinked it. */
-  unlinkedBy: z8.string().nullable()
+  unlinkedBy: z9.string().nullable()
 });
-var memberIdentityChangeInputSchema = z8.object({
+var memberIdentityChangeInputSchema = z9.object({
   kind: appIdentityKindSchema,
-  subject: z8.string().min(1).max(256),
-  reason: z8.string().trim().min(1).max(500)
+  subject: z9.string().min(1).max(256),
+  reason: z9.string().trim().min(1).max(500)
 }).strict();
 var balanceCheckSchema = walletBalanceSchema.pick({
   chain: true,
@@ -1267,57 +1332,65 @@ var balanceCheckSchema = walletBalanceSchema.pick({
   wallets: true,
   observedAt: true
 }).extend({ attempt: identifier });
-var walletBalanceChainsSchema = z8.object({
-  chains: z8.array(
-    z8.object({
-      chain: z8.union([
-        z8.literal(solanaMainnet),
+var walletBalanceChainsSchema = z9.object({
+  chains: z9.array(
+    z9.object({
+      chain: z9.union([
+        z9.literal(solanaMainnet),
         cosmosNetworkSchema,
         evmChainIdSchema
       ]),
-      name: z8.string(),
-      testnet: z8.boolean()
+      name: z9.string(),
+      testnet: z9.boolean()
     })
   )
 });
-var memberWalletUnlinkInputSchema = walletUnlinkInputSchema.extend({ reason: z8.string().trim().min(1).max(500) }).strict();
+var memberWalletUnlinkInputSchema = walletUnlinkInputSchema.extend({ reason: z9.string().trim().min(1).max(500) }).strict();
 var memberWalletSignInInputSchema = walletUnlinkInputSchema.extend({
-  enabled: z8.boolean(),
-  reason: z8.string().trim().min(1).max(500)
+  enabled: z9.boolean(),
+  reason: z9.string().trim().min(1).max(500)
 }).strict();
-var participantSignInSchema = z8.object({
-  providers: z8.array(
-    z8.object({ provider: authProviderSchema, configured: z8.boolean() })
+var participantSignInSchema = z9.object({
+  providers: z9.array(
+    z9.object({ provider: authProviderSchema, configured: z9.boolean() })
   ),
-  email: z8.boolean(),
+  email: z9.boolean(),
   /** Wallet families: `"solana"`, `"eip155"`, `"cosmos"`. */
   wallets: walletSignInNetworksSchema,
   /** Why participants cannot sign in to this project, or null. */
-  issue: z8.string().nullable(),
-  updatedAt: z8.number().nullable(),
-  updatedBy: z8.string().nullable()
+  issue: z9.string().nullable(),
+  updatedAt: z9.number().nullable(),
+  updatedBy: z9.string().nullable()
 });
-var participantSignInInputSchema = z8.object({
+var participantSignInInputSchema = z9.object({
   wallets: walletSignInNetworksSchema
 }).strict();
-var memberDetailSchema = z8.object({
+var completionRevocationShortfallSchema = z9.object({
+  completion: identifier,
+  quest: identifier,
+  revokedAt: z9.number().int().nonnegative().safe(),
+  unreversedPoints: z9.record(identifier, z9.number().int().positive().safe())
+});
+var memberDetailSchema = z9.object({
   snapshot: snapshotSchema,
   member: memberSchema,
   progress: memberProgressSchema,
+  /** Up to 25 revoked completions with an unreversed point remainder, newest first. */
+  revocationShortfalls: z9.array(completionRevocationShortfallSchema).default([]),
   /** Current and historical campaign enrollment state, including inactive enrollments. */
-  campaignEnrollments: z8.array(campaignEnrollmentSchema).default([]),
-  passes: z8.array(
-    z8.object({
-      provider: z8.string(),
-      event: z8.string(),
-      subject: z8.string(),
+  campaignEnrollments: z9.array(campaignEnrollmentSchema).default([]),
+  passes: z9.array(
+    z9.object({
+      provider: z9.string(),
+      event: z9.string(),
+      subject: z9.string(),
       attempt: identifier.nullable()
     })
   ).default([]),
   /** Linked and unlinked wallets. */
-  wallets: z8.array(managedWalletSchema),
+  wallets: z9.array(managedWalletSchema),
   /** The member's 10 most recent recorded balance reads, newest first. */
-  balanceChecks: z8.array(balanceCheckSchema),
+  balanceChecks: z9.array(balanceCheckSchema),
   /** The member's participant profile in this project. */
   profile: managedProfileSchema.nullable(),
   /**
@@ -1325,44 +1398,117 @@ var memberDetailSchema = z8.object({
    * member ID: their selected X and Discord accounts and their `app:<name>` identities in this
    * project, including app identities an operator unlinked, by kind.
    */
-  identities: z8.array(managedMemberIdentitySchema)
+  identities: z9.array(managedMemberIdentitySchema)
 });
-var stockInputSchema = z8.object({
+var stockInputSchema = z9.object({
   item: identifier,
-  quantity: z8.number().int().positive().max(1e6),
+  quantity: z9.number().int().positive().max(1e6),
   actionId: identifier
 }).strict();
-var ingestTrackerScopeSchema = z8.array(identifier).min(1).max(100).nullable();
-var tokenScopeInputSchema = z8.object({ ingestTrackers: ingestTrackerScopeSchema }).strict();
-var tokenInputSchema = z8.object({
-  name: z8.string().trim().min(1).max(80),
+var ingestTrackerScopeSchema = z9.array(identifier).min(1).max(100).nullable();
+var tokenScopeInputSchema = z9.object({ ingestTrackers: ingestTrackerScopeSchema }).strict();
+var tokenInputSchema = z9.object({
+  name: z9.string().trim().min(1).max(80),
   project: identifier,
   environment: environmentSchema,
-  permissions: z8.array(permissionSchema).min(1),
+  permissions: z9.array(permissionSchema).min(1),
   ingestTrackers: ingestTrackerScopeSchema.optional(),
-  days: z8.number().int().min(1).max(90).default(30)
+  days: z9.number().int().min(1).max(90).default(30)
 }).strict();
-var tokenSchema = z8.object({
-  id: z8.string(),
-  name: z8.string(),
-  project: z8.string(),
+var tokenSchema = z9.object({
+  id: z9.string(),
+  name: z9.string(),
+  project: z9.string(),
   environment: environmentSchema,
   permissions: permissionListSchema,
   ingestTrackers: ingestTrackerScopeSchema.optional(),
-  expiresAt: z8.number()
+  expiresAt: z9.number()
 });
-var issuedTokenSchema = tokenSchema.extend({ token: z8.string() });
-var teamSchema = z8.array(
-  z8.object({ id: z8.string(), label: z8.string() })
+var issuedTokenSchema = tokenSchema.extend({ token: z9.string() });
+var teamSchema = z9.array(
+  z9.object({ id: z9.string(), label: z9.string() })
 );
-var memberLookupSchema = z8.object({
-  provider: z8.string().min(1).max(200),
-  subject: z8.string().min(1).max(2048)
+var memberLookupSchema = z9.object({
+  provider: z9.string().min(1).max(200),
+  subject: z9.string().min(1).max(2048)
 }).strict();
-var verifiedPassSchema = z8.object({
+var booleanQuery = z9.union([
+  z9.boolean(),
+  z9.enum(["true", "false"]).transform((v) => v === "true")
+]);
+var managedMemberQuerySchema = z9.strictObject({
+  q: z9.string().max(200).optional(),
+  needsReview: booleanQuery.optional(),
+  limit: z9.coerce.number().int().min(1).max(100).optional(),
+  cursor: pageCursorSchema.optional()
+});
+var managedMemberPageSchema = z9.object({
+  items: z9.array(memberSchema),
+  total: z9.number().int().nonnegative(),
+  nextCursor: z9.string().nullable()
+});
+var projectMetricsSchema = metricsSchema.extend({
+  completionsByQuest: z9.array(
+    z9.object({ quest: identifier, completions: z9.number() })
+  )
+});
+var pageLimit = z9.coerce.number().int().min(1).max(100).optional();
+var managedAttemptQuerySchema = z9.strictObject({
+  q: z9.string().max(200).optional(),
+  status: z9.string().min(1).max(50).optional(),
+  limit: pageLimit,
+  cursor: pageCursorSchema.optional()
+});
+var managedAttemptPageSchema = z9.object({
+  items: z9.array(attemptSchema),
+  releases: z9.array(publishedReleaseSchema),
+  people: z9.array(personSchema),
+  total: z9.number().int().nonnegative(),
+  nextCursor: z9.string().nullable()
+});
+var managedAttemptSchema = z9.object({
+  attempt: attemptSchema,
+  release: publishedReleaseSchema.nullable(),
+  events: z9.array(eventSchema),
+  person: personSchema
+});
+var managedEntitlementQuerySchema = z9.strictObject({
+  q: z9.string().max(200).optional(),
+  status: z9.string().min(1).max(50).optional(),
+  limit: pageLimit,
+  cursor: pageCursorSchema.optional()
+});
+var managedEntitlementPageSchema = z9.object({
+  items: z9.array(entitlementSchema),
+  people: z9.array(personSchema),
+  total: z9.number().int().nonnegative(),
+  nextCursor: z9.string().nullable()
+});
+var managedEntitlementSchema = z9.object({
+  entitlement: entitlementSchema,
+  person: personSchema
+});
+var managedStockItemSchema = inventorySchema.extend({
+  offers: z9.array(identifier)
+});
+var auditQuerySchema = z9.strictObject({
+  category: z9.enum(["reviews", "rewards", "configuration"]).optional(),
+  q: z9.string().max(200).optional(),
+  limit: pageLimit,
+  cursor: pageCursorSchema.optional()
+});
+var accessHistoryQuerySchema = auditQuerySchema.omit({
+  category: true
+});
+var auditPageSchema = z9.object({
+  items: z9.array(auditRecordSchema),
+  total: z9.number().int().nonnegative(),
+  nextCursor: z9.string().nullable()
+});
+var verifiedPassSchema = z9.object({
   provider: identifier,
   event: identifier,
-  subject: z8.string().min(1).max(2048),
+  subject: z9.string().min(1).max(2048),
   member: identifier,
   quest: identifier
 }).strict();
@@ -1372,6 +1518,11 @@ function withActionId(input) {
 function actionIdOf(input) {
   return typeof input === "object" && input !== null && "actionId" in input && typeof input.actionId === "string" ? input.actionId : void 0;
 }
+function groupKey(group) {
+  return identifier.parse(
+    typeof group === "string" ? group : projectGroupKey(group)
+  );
+}
 function queryString(values) {
   const query = new URLSearchParams(
     Object.entries(values).flatMap(
@@ -1380,10 +1531,6 @@ function queryString(values) {
   ).toString();
   return query ? "?" + query : "";
 }
-var serverErrorSchema = z8.looseObject({
-  error: z8.string(),
-  code: z8.string().optional()
-});
 function checkedTimeout(timeout) {
   if (timeout !== void 0 && !validTimeout(timeout)) {
     throw new ManagementError({
@@ -1401,7 +1548,7 @@ function clientFailure(error) {
   return new ManagementError({
     kind: "client",
     code: ManagementErrorCode.InvalidInput,
-    message: error instanceof z8.ZodError ? `Invalid management request: ${z8.prettifyError(error)}` : error instanceof Error ? error.message : "Invalid management request",
+    message: error instanceof z9.ZodError ? `Invalid management request: ${z9.prettifyError(error)}` : error instanceof Error ? error.message : "Invalid management request",
     cause: error
   });
 }
@@ -1422,6 +1569,9 @@ function guarded(api) {
   );
 }
 function createManagementClient(options) {
+  return managementClient(options);
+}
+function managementClient(options) {
   const clientTimeout = checkedTimeout(options.timeout) ?? DEFAULT_MANAGEMENT_TIMEOUT;
   function callLifetime(call) {
     return lifetime(
@@ -1544,7 +1694,7 @@ function createManagementClient(options) {
         body = JSON.parse(text);
       } catch {
       }
-      const parsed = serverErrorSchema.safeParse(body);
+      const parsed = managementErrorSchema.safeParse(body);
       const { error, code, ...details } = parsed.success ? parsed.data : { error: `Request failed (${response.status})`, code: void 0 };
       throw new ManagementError({
         ...context,
@@ -1653,12 +1803,81 @@ function createManagementClient(options) {
       call
     );
   }
-  const ok = z8.object({ ok: z8.literal(true) });
+  const ok = z9.object({ ok: z9.literal(true) });
+  function pointHistory(member, ledger, query = {}, call) {
+    return get(
+      `/points/${identifier.parse(member)}/${identifier.parse(ledger)}/history${queryString(typeof query === "number" ? { before: query } : pageQuerySchema.parse(query))}`,
+      managedPointHistoryPageSchema,
+      call
+    );
+  }
+  function referralParticipants(query = {}, call) {
+    return get(
+      `/referrals/participants${queryString(typeof query === "number" ? { before: query } : pageQuerySchema.parse(query))}`,
+      referralManagementSchema,
+      call
+    );
+  }
+  function createPointLedger(input, call) {
+    return create(
+      "/point-ledgers",
+      pointLedgerSchema,
+      createPointLedgerSchema,
+      input,
+      call
+    );
+  }
+  function recordPoints(input, call) {
+    return post(
+      "/points",
+      pointsResultSchema,
+      pointsMutationSchema.parse(input),
+      call
+    );
+  }
+  function publishDeployment(target, call) {
+    const id = typeof target === "string" ? identifier.parse(target) : publishDeploymentSchema.parse(target).id;
+    return post(`/deployments/${id}/publish`, deploymentResultSchema, {}, call);
+  }
+  function submitDeployment(target, call) {
+    const id = typeof target === "string" ? identifier.parse(target) : submitDeploymentSchema.parse(target).id;
+    return post(`/deployments/${id}/submit`, deploymentRecordSchema, {}, call);
+  }
+  function rejectDeployment(target, inputOrCall, call) {
+    const { id, ...input } = typeof target === "string" ? {
+      id: identifier.parse(target),
+      ...deploymentRejectionSchema.parse(inputOrCall)
+    } : rejectDeploymentSchema.parse(target);
+    return post(
+      `/deployments/${id}/reject`,
+      deploymentRecordSchema,
+      input,
+      typeof target === "string" ? call : inputOrCall
+    );
+  }
+  function promoteDeployment(target, inputOrCall, call) {
+    return repeatDeployment("promote", target, inputOrCall, call);
+  }
+  function rollbackDeployment(target, inputOrCall, call) {
+    return repeatDeployment("rollback", target, inputOrCall, call);
+  }
+  function repeatDeployment(verb, target, inputOrCall, call) {
+    const { id, ...input } = typeof target === "string" ? {
+      id: identifier.parse(target),
+      ...deploymentActionSchema.parse(withActionId(inputOrCall ?? {}))
+    } : promoteDeploymentSchema.parse(withActionId(target));
+    return post(
+      `/deployments/${id}/${verb}`,
+      deploymentRecordSchema,
+      input,
+      typeof target === "string" ? call : inputOrCall
+    );
+  }
   return guarded({
     raw,
     request,
     trackers: {
-      list: (call) => get("/trackers", z8.array(trackerStatusSchema), call),
+      list: (call) => get("/trackers", z9.array(trackerStatusSchema), call),
       get: (reference, call) => get(
         `/trackers/${identifier.parse(reference)}`,
         trackerStatusSchema,
@@ -1691,12 +1910,25 @@ function createManagementClient(options) {
         trackerIngestSchema.parse(input),
         call
       ),
-      /** Why each tracker-triggered quest admitted or skipped a record observation, newest first. */
+      /**
+       * Why each tracker-triggered quest admitted or skipped a record observation, newest first.
+       *
+       * @deprecated Use `triggerOutcomes`, which pages by `cursor` and `nextCursor`. Removed in 2.0.0.
+       */
       outcomes: (reference, query = {}, call) => get(
         `/trackers/${identifier.parse(reference)}/outcomes${queryString(trackerOutcomeQuerySchema.parse(query))}`,
         trackerOutcomePageSchema,
         call
       ),
+      /**
+       * Why each tracker-triggered quest admitted or skipped a record observation, newest first.
+       * Pass a page's `nextCursor` back as `cursor` for the next page.
+       */
+      triggerOutcomes: (reference, query = {}, call) => get(
+        `/trackers/${identifier.parse(reference)}/trigger-outcomes${queryString(trackerTriggerOutcomeQuerySchema.parse(query))}`,
+        trackerTriggerOutcomePageSchema,
+        call
+      ),
       /**
        * Re-runs admission for a skipped observation under the quest's current release, links,
        * membership and enrollment, releasing historical activity whatever the quest's historical
@@ -1730,11 +1962,21 @@ function createManagementClient(options) {
         engagementChangeSchema.parse(input),
         call
       ),
+      /** @deprecated Use `ruleVersions(rule, { cursor })`. Removed in 2.0.0. */
       versions: (input, call) => get(
         "/engagement/versions" + queryString(engagementVersionQuerySchema.parse(input)),
         engagementVersionPageSchema,
         call
       ),
+      /**
+       * An engagement rule's published versions, newest first. Pass a page's `nextCursor` back as
+       * `cursor` for the next page.
+       */
+      ruleVersions: (rule, query = {}, call) => get(
+        `/engagement/rules/${identifier.parse(rule)}/versions${queryString(pageQuerySchema.parse(query))}`,
+        engagementRuleVersionPageSchema,
+        call
+      ),
       boundaries: (input, call) => get(
         "/engagement/boundaries" + queryString(engagementPageQuerySchema.parse(input)),
         engagementBoundaryPageSchema,
@@ -1746,7 +1988,7 @@ function createManagementClient(options) {
         engagementPublishSchema.parse(input),
         call
       ),
-      list: (call) => get("/engagement", z8.array(engagementRuleSchema), call),
+      list: (call) => get("/engagement", z9.array(engagementRuleSchema), call),
       page: (input, call) => get(
         "/engagement/history" + queryString(engagementPageQuerySchema.parse(input)),
         engagementPageSchema,
@@ -1766,13 +2008,32 @@ function createManagementClient(options) {
       )
     },
     pointLedgers: {
-      list: (call) => get("/point-ledgers", z8.array(managedPointLedgerSchema), call),
-      save: (input, call) => post(
-        "/point-ledgers/update",
+      list: (call) => get("/point-ledgers", z9.array(managedPointLedgerSchema), call),
+      /**
+       * Creates a point ledger, with a stable `key` when code refers to it; requires `publish`. In
+       * live, only a person in Console can create one.
+       */
+      create: createPointLedger,
+      /**
+       * Renames a point ledger, by key or ID, and replaces its description (empty when omitted);
+       * requires `publish`. In live, only a person in Console can change one.
+       */
+      update: (ledger, input, call) => post(
+        `/point-ledgers/${identifier.parse(ledger)}/update`,
         managedPointLedgerSchema,
-        pointLedgerSchema.parse(input),
+        pointLedgerPropertiesSchema.parse(input),
         call
       ),
+      /** @deprecated Use `update(ledger, { name, description })`. Removed in 2.0.0. */
+      save: (input, call) => {
+        const { id, ...properties } = pointLedgerSchema.parse(input);
+        return post(
+          `/point-ledgers/${id}/update`,
+          managedPointLedgerSchema,
+          properties,
+          call
+        );
+      },
       archive: (ledger, call) => post(
         `/point-ledgers/${identifier.parse(ledger)}/archive`,
         managedPointLedgerSchema,
@@ -1781,33 +2042,24 @@ function createManagementClient(options) {
       )
     },
     points: {
-      ledgers: (call) => get("/point-ledgers", z8.array(managedPointLedgerSchema), call),
-      createLedger: (input, call) => create(
-        "/point-ledgers",
-        pointLedgerSchema,
-        createPointLedgerSchema,
-        input,
-        call
-      ),
-      update: (input, call) => post(
-        "/points",
-        pointsResultSchema,
-        pointsMutationSchema.parse(input),
-        call
-      ),
+      /** @deprecated Use `pointLedgers.list()`, which reads the same ledgers. Removed in 2.0.0. */
+      ledgers: (call) => get("/point-ledgers", z9.array(managedPointLedgerSchema), call),
+      /** @deprecated Use `pointLedgers.create(input)`. Removed in 2.0.0. */
+      createLedger: createPointLedger,
+      /**
+       * Records a change to a member's balance in one ledger: an `award`, a `spend`, an `adjust`,
+       * a `reverse` of an earlier award, or a `set` to an absolute total; requires `points`
+       * permission. The action ID makes a retry answer with the first result.
+       */
+      record: recordPoints,
+      /** @deprecated Use `record`, which makes the same change. Removed in 2.0.0. */
+      update: recordPoints,
       balance: (member, balance, call) => get(
         `/points/${identifier.parse(member)}/${identifier.parse(balance)}`,
         pointsAccountSchema,
         call
       ),
-      history: (member, balance, before, call) => get(
-        `/points/${identifier.parse(member)}/${identifier.parse(balance)}/history${queryString({ before })}`,
-        z8.object({
-          items: z8.array(pointsEntrySchema),
-          next: z8.number().nullable()
-        }),
-        call
-      )
+      history: pointHistory
     },
     referrals: {
       /** A member's referral point history, newest first. Pass `nextCursor` as `cursor`. */
@@ -1816,21 +2068,68 @@ function createManagementClient(options) {
         referralHistorySchema,
         call
       ),
-      list: (call) => get("/referrals", z8.array(publishedReferralSchema), call),
-      participants: (before, call) => get(
-        `/referrals/participants${queryString({ before })}`,
-        referralManagementSchema,
+      list: (call) => get("/referrals", z9.array(publishedReferralSchema), call),
+      participants: referralParticipants,
+      /**
+       * Suspends or restores a member's referral relationship, with a reason; requires `publish`.
+       * A suspended member earns their inviter nothing.
+       */
+      suspend: (member, input, call) => post(
+        `/referral-relationships/${identifier.parse(member)}/suspend`,
+        ok,
+        referralSuspensionSchema.parse(withActionId(input)),
         call
       ),
-      control: (input, call) => post(
-        "/referrals/control",
+      /**
+       * Qualifies or unqualifies a member in a referral program after checking a condition outside
+       * Relay, with a reason; requires `publish`.
+       */
+      qualify: (program, member, input, call) => post(
+        `/referral-programs/${identifier.parse(program)}/members/${identifier.parse(member)}/qualify`,
         ok,
-        referralControlSchema.parse(input),
+        referralQualificationSchema.parse(withActionId(input)),
         call
-      )
+      ),
+      /**
+       * Marks a referral reward held for review reconciled, so its entitlement can be handed over
+       * again, with a reason; requires `publish`.
+       */
+      resolveReward: (entitlement, input, call) => post(
+        `/referral-rewards/${identifier.parse(entitlement)}/resolve`,
+        ok,
+        referralRewardResolutionSchema.parse(withActionId(input)),
+        call
+      ),
+      /** @deprecated Use `suspend`, `qualify` or `resolveReward`. Removed in 2.0.0. */
+      control: (input, call) => {
+        const parsed = referralControlSchema.parse(input);
+        const { actionId, reason } = parsed;
+        if (parsed.kind === "suspend") {
+          return post(
+            `/referral-relationships/${parsed.member}/suspend`,
+            ok,
+            { actionId, suspended: parsed.suspended, reason },
+            call
+          );
+        }
+        if (parsed.kind === "qualify") {
+          return post(
+            `/referral-programs/${parsed.program}/members/${parsed.member}/qualify`,
+            ok,
+            { actionId, qualified: parsed.qualified, reason },
+            call
+          );
+        }
+        return post(
+          `/referral-rewards/${parsed.entitlement}/resolve`,
+          ok,
+          { actionId, reason },
+          call
+        );
+      }
     },
     leaderboards: {
-      list: (call) => get("/leaderboards", z8.array(publishedLeaderboardSchema), call),
+      list: (call) => get("/leaderboards", z9.array(publishedLeaderboardSchema), call),
       standings: (board, input = {}, call) => {
         const query = leaderboardQuerySchema.parse(input);
         return get(
@@ -1844,12 +2143,12 @@ function createManagementClient(options) {
       },
       history: (board, call) => get(
         `/leaderboards/${identifier.parse(board)}/history`,
-        z8.array(publishedLeaderboardSchema),
+        z9.array(publishedLeaderboardSchema),
         call
       ),
       exclusions: (board, call) => get(
         `/leaderboards/${identifier.parse(board)}/exclusions`,
-        z8.array(z8.object({ member: identifier })),
+        z9.array(z9.object({ member: identifier })),
         call
       ),
       exclude: (board, input, call) => post(
@@ -1858,15 +2157,22 @@ function createManagementClient(options) {
         leaderboardExclusionSchema.parse(input),
         call
       ),
+      /**
+       * Adds a member to a group, creating the group (titled with its key) when it is new, or
+       * removes one.
+       *
+       * @deprecated Use `groups.addMember` and `groups.removeMember` instead; create the group
+       * first with `groups.create`. Removed in 2.0.0.
+       */
       group: (group, input, call) => post(
-        `/leaderboard-groups/${identifier.parse(typeof group === "string" ? group : projectGroupKey(group))}`,
+        `/leaderboard-groups/${groupKey(group)}`,
         ok,
         leaderboardGroupSchema.parse(input),
         call
       ),
       settlements: (board, call) => get(
         `/leaderboards/${identifier.parse(board)}/settlements`,
-        z8.array(leaderboardSettlementSummarySchema),
+        z9.array(leaderboardSettlementSummarySchema),
         call
       ),
       settlement: (settlement, call) => get(
@@ -1881,8 +2187,72 @@ function createManagementClient(options) {
         call
       )
     },
+    /**
+     * Groups: named sets of members that prerequisites (`inGroup`), leaderboards and referral rules
+     * read by key. Reads need `read`; changes need `publish`, in live too.
+     */
+    groups: {
+      /** Groups by key, archived ones included. Pass `nextCursor` back as `cursor`. */
+      list: (query = {}, call) => get(
+        `/groups${queryString(groupPageQuerySchema.parse(query))}`,
+        groupPageSchema,
+        call
+      ),
+      get: (group, call) => get(`/groups/${groupKey(group)}`, managedGroupSchema, call),
+      /** Creates a group. A key already in use fails with 409. */
+      create: (input, call) => create("/groups", managedGroupSchema, createGroupSchema, input, call),
+      /** Renames a group. Its key and members stay. */
+      update: (group, input, call) => post(
+        `/groups/${groupKey(group)}/update`,
+        managedGroupSchema,
+        updateGroupSchema.parse(input),
+        call
+      ),
+      /**
+       * Freezes a group's membership. Its members still count for prerequisites, leaderboards
+       * and referral rules.
+       */
+      archive: (group, call) => post(
+        `/groups/${groupKey(group)}/archive`,
+        managedGroupSchema,
+        {},
+        call
+      ),
+      unarchive: (group, call) => post(
+        `/groups/${groupKey(group)}/unarchive`,
+        managedGroupSchema,
+        {},
+        call
+      ),
+      /** A group's current members by member ID. Pass `nextCursor` back as `cursor`. */
+      members: (group, query = {}, call) => get(
+        `/groups/${groupKey(group)}/members${queryString(groupPageQuerySchema.parse(query))}`,
+        groupMemberPageSchema,
+        call
+      ),
+      /** One current membership; 404 when the member is not in the group. */
+      member: (group, member, call) => get(
+        `/groups/${groupKey(group)}/members/${identifier.parse(member)}`,
+        groupMemberSchema,
+        call
+      ),
+      /** Adds a member, or answers their membership when they already belong. */
+      addMember: (group, input, call) => post(
+        `/groups/${groupKey(group)}/members`,
+        groupMemberSchema,
+        addGroupMemberSchema.parse(withActionId(input)),
+        call
+      ),
+      /** Removes a member; removing someone who is not a member changes nothing. */
+      removeMember: (group, member, input, call) => post(
+        `/groups/${groupKey(group)}/members/${identifier.parse(member)}/remove`,
+        ok,
+        removeGroupMemberSchema.parse(withActionId(input)),
+        call
+      )
+    },
     deployments: {
-      list: (call) => get("/deployments", z8.array(deploymentRecordSchema), call),
+      list: (call) => get("/deployments", z9.array(deploymentRecordSchema), call),
       get: (deployment, call) => get(
         `/deployments/${identifier.parse(deployment)}`,
         deploymentRecordSchema,
@@ -1897,42 +2267,11 @@ function createManagementClient(options) {
           call
         );
       },
-      publish: (input, call) => post(
-        "/deployments/publish",
-        deploymentResultSchema,
-        publishDeploymentSchema.parse(input),
-        call
-      ),
-      submit: (input, call) => post(
-        "/deployments/submit",
-        deploymentRecordSchema,
-        submitDeploymentSchema.parse(input),
-        call
-      ),
-      reject: (input, call) => post(
-        "/deployments/reject",
-        deploymentRecordSchema,
-        rejectDeploymentSchema.parse(input),
-        call
-      ),
-      promote: (input, call) => {
-        const parsed = promoteDeploymentSchema.parse(withActionId(input));
-        return post(
-          "/deployments/promote",
-          deploymentRecordSchema,
-          parsed,
-          call
-        );
-      },
-      rollback: (input, call) => {
-        const parsed = rollbackDeploymentSchema.parse(withActionId(input));
-        return post(
-          "/deployments/rollback",
-          deploymentRecordSchema,
-          parsed,
-          call
-        );
-      }
+      publish: publishDeployment,
+      submit: submitDeployment,
+      reject: rejectDeployment,
+      promote: promoteDeployment,
+      rollback: rollbackDeployment
     },
     catalog: {
       allocateQuest: (input = {}, call) => create(
@@ -1974,8 +2313,31 @@ function createManagementClient(options) {
         call
       )
     },
-    /** Staff-confirmed quests and reviews. */
+    /** The project's headline counts; requires `read` permission. */
+    metrics: {
+      read: (call) => get("/metrics", projectMetricsSchema, call)
+    },
+    /** Attempts, staff-confirmed quests and reviews. */
     attempts: {
+      /**
+       * One page of the project's attempts, newest first, with the releases they were admitted
+       * under and the members they name, and `total`, how many match. Pass a page's `nextCursor`
+       * back as `cursor` for the next page; requires `read` permission.
+       */
+      list: (query = {}, call) => get(
+        `/attempts${queryString(managedAttemptQuerySchema.parse(query))}`,
+        managedAttemptPageSchema,
+        call
+      ),
+      /**
+       * One attempt with its release, its recorded events and its member; requires `read`
+       * permission. Fails with 404 when the project has no such attempt.
+       */
+      get: (attempt, call) => get(
+        `/attempts/${identifier.parse(attempt)}`,
+        managedAttemptSchema,
+        call
+      ),
       /**
        * Submits a staff-confirmed quest (`manual({ actor: "staff" })`) for a member; requires
        * `confirm` permission. Resolves with the queued attempt, or with the original attempt when
@@ -2065,8 +2427,27 @@ function createManagementClient(options) {
         call
       )
     },
-    /** Operator corrections of a member's reward entitlement; require `review` permission. */
+    /** Members' reward entitlements; corrections require `review` permission. */
     entitlements: {
+      /**
+       * One page of the project's entitlements, newest first, with the members they name, and
+       * `total`, how many match. Pass a page's `nextCursor` back as `cursor` for the next page;
+       * requires `read` permission.
+       */
+      list: (query = {}, call) => get(
+        `/entitlements${queryString(managedEntitlementQuerySchema.parse(query))}`,
+        managedEntitlementPageSchema,
+        call
+      ),
+      /**
+       * One entitlement and its member; requires `read` permission. Fails with 404 when the
+       * project has no such entitlement.
+       */
+      get: (entitlement, call) => get(
+        `/entitlements/${identifier.parse(entitlement)}`,
+        managedEntitlementSchema,
+        call
+      ),
       /**
        * Voids an available entitlement granted by mistake, at the `revision` the operator saw, with
        * a reason. It can no longer be handed over. A quest that grants the member the same reward
@@ -2104,6 +2485,8 @@ function createManagementClient(options) {
       )
     },
     operations: {
+      /** Every paused or resumed operation: redemptions and each quest's participation; requires `read`. */
+      list: (call) => get("/operations", z9.array(operationSchema), call),
       /**
        * Pauses or resumes redemptions or one quest's participation, against the `revision` the
        * operator saw, with a reason; requires `publish` permission.
@@ -2116,6 +2499,8 @@ function createManagementClient(options) {
       )
     },
     inventory: {
+      /** Every stock item with its counts and the offers that sell it; requires `read` permission. */
+      list: (call) => get("/stock-items", z9.array(managedStockItemSchema), call),
       createItem: (input, call) => create(
         "/stock-items",
         stockItemSchema,
@@ -2130,7 +2515,7 @@ function createManagementClient(options) {
         stockInputSchema.parse(withActionId(input)),
         call
       ),
-      catalog: (call) => get("/pickup-inventory", z8.array(pickupCatalogSchema), call),
+      catalog: (call) => get("/pickup-inventory", z9.array(pickupCatalogSchema), call),
       configure: (input, call) => post(
         "/pickup-inventory",
         pickupCatalogSchema,
@@ -2144,10 +2529,10 @@ function createManagementClient(options) {
       )
     },
     offers: {
-      list: (call) => get("/offers", z8.array(offerSchema), call),
+      list: (call) => get("/offers", z9.array(offerSchema), call),
       redemptions: (input = {}, call) => get(
         `/redemptions${queryString({ member: input.member })}`,
-        z8.array(redemptionSchema),
+        z9.array(redemptionSchema),
         call
       ),
       /** Pauses or resumes an offer at the revision the operator saw. */
@@ -2195,7 +2580,7 @@ function createManagementClient(options) {
      * them; API keys and project-scoped playground sessions cannot.
      */
     tokens: {
-      list: (call) => get("/tokens", z8.array(tokenSchema), call),
+      list: (call) => get("/tokens", z9.array(tokenSchema), call),
       /**
        * Issues a key for one project and environment, limited to permissions the caller holds
        * there. The secret `token` is in this response only.
@@ -2203,14 +2588,14 @@ function createManagementClient(options) {
       create: (input, call) => post("/tokens", issuedTokenSchema, tokenInputSchema.parse(input), call),
       /** Replace a personal key's ingestion restriction without changing its secret. */
       scope: (id, input, call) => request(
-        `/tokens/${encodeURIComponent(z8.string().min(1).parse(id))}/scope`,
+        `/tokens/${encodeURIComponent(z9.string().min(1).parse(id))}/scope`,
         tokenSchema,
         tokenScopeInputSchema.parse(input),
         "PUT",
         call
       ),
       revoke: (id, call) => request(
-        `/tokens/${encodeURIComponent(z8.string().min(1).parse(id))}`,
+        `/tokens/${encodeURIComponent(z9.string().min(1).parse(id))}`,
         ok,
         void 0,
         "DELETE",
@@ -2219,7 +2604,7 @@ function createManagementClient(options) {
     },
     /** Who holds which roles on the client's project; organization administrators only. */
     grants: {
-      list: (call) => get("/grants", z8.array(grantRecordSchema), call),
+      list: (call) => get("/grants", z9.array(grantRecordSchema), call),
       /** Replaces one person's roles and environments on the project. The audit log records it. */
       set: (input, call) => request(
         "/grants",
@@ -2235,7 +2620,7 @@ function createManagementClient(options) {
     },
     /** Signed activity notifications for one project/environment; writes require publish permission. */
     webhooks: {
-      list: (call) => get("/webhooks", z8.array(webhookEndpointSchema), call),
+      list: (call) => get("/webhooks", z9.array(webhookEndpointSchema), call),
       create: (input, call) => post(
         "/webhooks",
         webhookSecretSchema,
@@ -2243,31 +2628,31 @@ function createManagementClient(options) {
         call
       ),
       update: (id, input, call) => request(
-        `/webhooks/${z8.string().uuid().parse(id)}`,
+        `/webhooks/${z9.string().uuid().parse(id)}`,
         webhookEndpointSchema,
         webhookUpdateSchema.parse(input),
         "PUT",
         call
       ),
       disable: (id, call) => post(
-        `/webhooks/${z8.string().uuid().parse(id)}/disable`,
+        `/webhooks/${z9.string().uuid().parse(id)}/disable`,
         webhookEndpointSchema,
         {},
         call
       ),
       rotateSecret: (id, call) => post(
-        `/webhooks/${z8.string().uuid().parse(id)}/rotate-secret`,
+        `/webhooks/${z9.string().uuid().parse(id)}/rotate-secret`,
         webhookSecretSchema,
         {},
         call
       ),
       deliveries: (id, query = {}, call) => get(
-        `/webhooks/${z8.string().uuid().parse(id)}/deliveries${queryString(webhookQuerySchema.parse(query))}`,
+        `/webhooks/${z9.string().uuid().parse(id)}/deliveries${queryString(webhookQuerySchema.parse(query))}`,
         webhookDeliveryPageSchema,
         call
       ),
       replay: (id, delivery, call) => post(
-        `/webhooks/${z8.string().uuid().parse(id)}/deliveries/${z8.string().uuid().parse(delivery)}/replay`,
+        `/webhooks/${z9.string().uuid().parse(id)}/deliveries/${z9.string().uuid().parse(delivery)}/replay`,
         webhookDeliverySchema,
         {},
         call
@@ -2278,7 +2663,7 @@ function createManagementClient(options) {
      * environment. Organization administrators, from a Console session only.
      */
     identityIntegrations: {
-      list: (call) => get("/identity-integrations", z8.array(identityIntegrationSchema), call),
+      list: (call) => get("/identity-integrations", z9.array(identityIntegrationSchema), call),
       /** The secret `token` is in this response only. */
       create: (input, call) => post(
         "/identity-integrations",
@@ -2288,7 +2673,7 @@ function createManagementClient(options) {
       ),
       /** Replaces the key's secret and extends it by 90 days; the old secret stops working. */
       rotate: (id, call) => post(
-        `/identity-integrations/${z8.string().uuid().parse(id)}/rotate`,
+        `/identity-integrations/${z9.string().uuid().parse(id)}/rotate`,
         identityIntegrationSecretSchema,
         {},
         call
@@ -2300,7 +2685,7 @@ function createManagementClient(options) {
        */
       kinds: (call) => get(
         "/identity-integrations/kinds",
-        z8.array(identityKindClaimSchema),
+        z9.array(identityKindClaimSchema),
         call
       ),
       /**
@@ -2308,18 +2693,57 @@ function createManagementClient(options) {
        * and keep attributing tracker records; unlink them on the member to stop that.
        */
       revoke: (id, call) => request(
-        `/identity-integrations/${z8.string().uuid().parse(id)}`,
-        z8.null(),
+        `/identity-integrations/${z9.string().uuid().parse(id)}`,
+        z9.null(),
         void 0,
         "DELETE",
         call
       )
     },
+    /**
+     * One of Console's former screens (`overview`, `quests`, `activity`, `members`, `rewards`,
+     * `releases`, `settings`, `audit`), paged by `offset`.
+     *
+     * @deprecated Replace each page as follows. `overview` uses `metrics.read`, `attempts.list`,
+     * `quests.list` and `operations.list`; its `detail` has no effect. `quests` uses `quests.list`
+     * and finds a `detail` quest in that result. `activity` uses `attempts.list`, and its `detail`
+     * uses `attempts.get`. `members` uses `members.list`; `page()` ignores its `detail`, while
+     * `members.get` reads a member. `rewards` uses `entitlements.list` and `inventory.list`, and
+     * its `detail` uses `entitlements.get`. No resource read lists historical releases or reads
+     * one historical release, so `releases` and its `detail` have no exact replacement;
+     * `quests.list` returns current releases only. `settings` uses `metrics.read`, `quests.list`
+     * and `operations.list`; its `detail` has no effect. `audit` uses `audit.list`, except
+     * `filter: "access"` uses `audit.access`; its `detail` has no effect. On every page,
+     * `detail: "new"` is client-side create mode and triggers no replacement read. Resource lists
+     * take `cursor` instead of `offset`. Removed in 2.0.0.
+     */
     page: (page, query, call) => get(`/${page}${queryString(query)}`, pageSchema, call),
+    /** The project's audit history; requires `read` permission. */
+    audit: {
+      /**
+       * One page of the project's operations in this environment (reviews, reward changes and
+       * configuration), newest first, and `total`, how many match. Pass a page's `nextCursor`
+       * back as `cursor` for the next page.
+       */
+      list: (query = {}, call) => get(
+        `/audit/list${queryString(auditQuerySchema.parse(query))}`,
+        auditPageSchema,
+        call
+      ),
+      /**
+       * One page of the project's access and API key changes across test and live, newest first.
+       * Requires an organization administrator's Console session or CLI sign-in.
+       */
+      access: (query = {}, call) => get(
+        `/audit/access${queryString(accessHistoryQuerySchema.parse(query))}`,
+        auditPageSchema,
+        call
+      )
+    },
     resources: {
       list: (call) => get(
         "/resources",
-        z8.object({ resources: z8.array(managedResourceSchema) }),
+        z9.object({ resources: z9.array(managedResourceSchema) }),
         call
       ),
       lifecycle: (input, call) => post(
@@ -2355,7 +2779,7 @@ function createManagementClient(options) {
         testMemberCreateSchema.parse(input),
         call
       ),
-      list: (call) => get("/test-members", z8.array(testMemberSchema), call),
+      list: (call) => get("/test-members", z9.array(testMemberSchema), call),
       history: (member, query = {}, call) => get(
         `/test-members/${identifier.parse(member)}/history${queryString(testMemberHistoryQuerySchema.parse(query))}`,
         testMemberHistorySchema,
@@ -2396,6 +2820,16 @@ function createManagementClient(options) {
           call
         )
       },
+      /**
+       * One page of the project's members, most recently joined first, with their accounts and
+       * activity counts, and `total`, how many match. Pass a page's `nextCursor` back as `cursor`
+       * for the next page; requires `read` permission.
+       */
+      list: (query = {}, call) => get(
+        `/members/list${queryString(managedMemberQuerySchema.parse(query))}`,
+        managedMemberPageSchema,
+        call
+      ),
       /** A member's detail: accounts, progress, passes, wallets and profile. */
       get: (member, call) => get(`/members/${encodeURIComponent(member)}`, memberDetailSchema, call),
       /**
@@ -2412,26 +2846,26 @@ function createManagementClient(options) {
       /** Who each member is: up to 100 distinct IDs; unknown IDs come back without accounts. */
       people: (members, call) => get(
         `/people${queryString({ ids: members.join(",") })}`,
-        z8.array(personSchema),
+        z9.array(personSchema),
         call
       ),
       /** Current X and Discord quest account selections; requires read permission. */
       oauthAccounts: (member, call) => get(
         `/members/${encodeURIComponent(member)}/oauth-accounts`,
-        z8.array(managedOAuthAccountSchema),
+        z9.array(managedOAuthAccountSchema),
         call
       ),
       /** Unlinks the reviewed selection across this organization/environment, preserving ownership and sign-in. */
       unlinkOAuthAccount: (member, input, call) => post(
         `/members/${encodeURIComponent(member)}/oauth-accounts/unlink`,
-        z8.array(managedOAuthAccountSchema),
+        z9.array(managedOAuthAccountSchema),
         memberOAuthUnlinkInputSchema.parse(input),
         call
       ),
       /** Unlinks a member's wallet from the project with a reason; requires `review` permission. The address stays bound to the member. */
       unlinkWallet: (member, input, call) => post(
         `/members/${encodeURIComponent(member)}/wallets/unlink`,
-        z8.array(managedWalletSchema),
+        z9.array(managedWalletSchema),
         memberWalletUnlinkInputSchema.parse(input),
         call
       ),
@@ -2442,14 +2876,14 @@ function createManagementClient(options) {
        */
       unlinkIdentity: (member, input, call) => post(
         `/members/${encodeURIComponent(member)}/identities/unlink`,
-        z8.array(managedMemberIdentitySchema),
+        z9.array(managedMemberIdentitySchema),
         memberIdentityChangeInputSchema.parse(input),
         call
       ),
       /** Relinks an `app:<name>` identity an operator unlinked from this member, with a reason; requires `review` permission. */
       relinkIdentity: (member, input, call) => post(
         `/members/${encodeURIComponent(member)}/identities/relink`,
-        z8.array(managedMemberIdentitySchema),
+        z9.array(managedMemberIdentitySchema),
         memberIdentityChangeInputSchema.parse(input),
         call
       ),
@@ -2459,7 +2893,7 @@ function createManagementClient(options) {
        */
       setWalletSignIn: (member, input, call) => post(
         `/members/${encodeURIComponent(member)}/wallets/sign-in`,
-        z8.array(managedWalletSchema),
+        z9.array(managedWalletSchema),
         memberWalletSignInInputSchema.parse(input),
         call
       )
@@ -2494,13 +2928,18 @@ function createManagementClient(options) {
         appStorageTablesSchema,
         call
       ),
-      /** One page of 50 rows in the table's storage order, which rows changing in between can shift. */
+      /**
+       * One page of 50 rows in the table's storage order, which rows changing in between can shift.
+       * Pass a page's `nextCursor` back as `cursor` for the next page.
+       */
       rows: (name, table, options2 = {}, call) => get(
-        `/storage/sql/${appSecretNameSchema.parse(name)}/rows?${new URLSearchParams({ table, offset: String(options2.offset ?? 0) })}`,
+        `/storage/sql/${appSecretNameSchema.parse(name)}/rows?${new URLSearchParams(
+          options2.cursor === void 0 ? { table, offset: String(options2.offset ?? 0) } : { table, cursor: pageCursorSchema.parse(options2.cursor) }
+        )}`,
         appStorageRowsSchema,
         call
       ),
-      /** One page of a KV store's keys; pass the returned `cursor` for the next. */
+      /** One page of a KV store's keys. Pass a page's `nextCursor` back as `cursor` for the next. */
       keys: (name, options2 = {}, call) => get(
         `/storage/kv/${appSecretNameSchema.parse(name)}/keys?${new URLSearchParams(
           Object.entries(options2).filter(
@@ -2598,6 +3037,11 @@ function createManagementClient(options) {
       )
     },
     quests: {
+      /**
+       * Each quest's current release, the most recently published first, archived quests
+       * included; requires `read` permission.
+       */
+      list: (call) => get("/quests/list", z9.array(publishedReleaseSchema), call),
       /** Pending and exhausted asynchronous balance checks. Requires read. */
       automaticScheduling: (query = {}, call) => get(
         `/quests/automatic-scheduling${queryString(automaticSchedulingQuerySchema.parse(query))}`,
@@ -2699,17 +3143,22 @@ export {
   APP_SQL_LIMIT,
   APP_STORAGE_PREVIEW_CHARACTERS,
   APP_STORAGE_ROW_LIMIT,
+  CompletionSourceKind,
   DEFAULT_MANAGEMENT_TIMEOUT,
   ManagementError,
   ManagementErrorCode,
+  PayoutSourceKind,
+  REFERRAL_INTEGRATION_REWARD_ERROR,
   RevokedDeliveryOutcome,
   RevokedEntitlementOutcome,
   RevokedReferralOutcome,
   WEBHOOK_MAX_BYTES,
+  accessHistoryQuerySchema,
   accessSchema,
   accountProfileSchema,
   activityTypeSchema,
   activityTypes,
+  addGroupMemberSchema,
   appMigrationNameSchema,
   appRoutingSchema,
   appSecretDeclarationSchema,
@@ -2728,6 +3177,8 @@ export {
   appStorageTablesSchema,
   appStorageValueSchema,
   assetPathSchema,
+  auditPageSchema,
+  auditQuerySchema,
   auditRecordSchema,
   balanceCheckSchema,
   buildArtifactsSchema,
@@ -2738,18 +3189,28 @@ export {
   commitSchema,
   compareAppMigrations,
   completionRevocationSchema,
+  completionRevocationShortfallSchema,
   completionRevokeSchema,
+  containsReferralIntegrationReward,
+  createGroupSchema,
   createManagementClient,
   createRepositorySchema,
+  deploymentActionSchema,
+  deploymentRejectionSchema,
   developmentPreflightSchema,
   deviceApproveSchema,
   deviceRedeemSchema,
   deviceStartSchema,
+  engagementRuleVersionPageSchema,
   entitlementCorrectionSchema,
   entitlementSchema,
   environmentSchema,
   grantRecordSchema,
   grantSchema,
+  groupMemberPageSchema,
+  groupMemberSchema,
+  groupPageQuerySchema,
+  groupPageSchema,
   hostedAppSchema,
   hostedAppSecretsSchema,
   hostedBuildSchema,
@@ -2759,16 +3220,31 @@ export {
   hostedKeySecretSchema,
   hostedManagementBindings,
   hostedManagementClient,
+  identityIntegrationInputSchema,
   identityIntegrationSchema,
   identityKindClaimSchema,
   ingestTrackerScopeSchema,
   inventorySchema,
+  isIntegrationParticipantPath,
   isManagementError,
+  isParticipantRoute,
   issuedTokenSchema,
+  managedAttemptPageSchema,
+  managedAttemptQuerySchema,
+  managedAttemptSchema,
+  managedEntitlementPageSchema,
+  managedEntitlementQuerySchema,
+  managedEntitlementSchema,
+  managedGroupSchema,
   managedMemberIdentitySchema,
+  managedMemberPageSchema,
+  managedMemberQuerySchema,
   managedOAuthAccountSchema,
+  managedPointHistoryPageSchema,
   managedResourceSchema,
+  managedStockItemSchema,
   managedWalletSchema,
+  managementErrorSchema,
   memberAccountSchema,
   memberDetailSchema,
   memberIdentityChangeInputSchema,
@@ -2783,28 +3259,44 @@ export {
   operationSchema,
   operatorUserSchema,
   pageSchema,
+  parseImageExtraction,
+  parseImageResult,
+  participantExchangeSchema,
+  participantRoutePattern,
+  participantRoutes,
   participantSignInInputSchema,
   participantSignInSchema,
   permissionSchema,
   personSchema,
+  pointLedgerPropertiesSchema,
   projectDeletionInputSchema,
   projectDeletionSchema,
   projectInputSchema,
+  projectMetricsSchema,
   projectSchema,
   projectSetupSchema,
   projectTransferInputSchema,
   projectTransferSchema,
   projectUpdateInputSchema,
   querySchema,
+  questConfiguration,
   questLifecycleInputSchema,
   questLifecycleSchema,
   readinessSchema,
+  referralManagementSchema,
+  referralQualificationSchema,
+  referralRewardResolutionSchema,
+  referralSuspensionSchema,
+  removeGroupMemberSchema,
   repositorySchema,
   resourceLifecycleInputSchema,
   resourceLifecycleKindSchema,
   resourceLifecycleResultSchema,
   rolePermissions,
   roleSchema,
+  sequenceCursorSchema,
+  sourceDataSchema,
+  sourceRoles,
   stageRequestSchema,
   stagedDeploymentContentSchema,
   stagedDeploymentKey,
@@ -2831,6 +3323,11 @@ export {
   tokenInputSchema,
   tokenSchema,
   tokenScopeInputSchema,
+  trackerDataIssue,
+  trackerDataIssues,
+  trackerTriggerOutcomePageSchema,
+  updateGroupSchema,
+  validateQuestShape,
   verifiedPassSchema,
   verifyWebhook,
   walletBalanceChainsSchema,
@@ -2841,5 +3338,6 @@ export {
   webhookInputSchema,
   webhookQuerySchema,
   webhookSecretSchema,
-  webhookUpdateSchema
+  webhookUpdateSchema,
+  whereSchemaIssue
 };