@domino-sdk/relay 1.56.0 → 1.60.0

package/dist/server/index.js

@@ -1,7 +1,7 @@
 import {
   attemptCaptureSchema,
   capturedFactSchema
-} from "../chunk-MNU6UPXY.js";
+} from "../chunk-OTEUP2SG.js";
 import {
   activityTypeSchema,
   activityTypes,
@@ -27,7 +27,7 @@ import {
   publishDeploymentSchema,
   rejectDeploymentSchema,
   submitDeploymentSchema
-} from "../chunk-CXKXPB7K.js";
+} from "../chunk-Y2IGFLD2.js";
 import {
   analyticsBreakdowns,
   analyticsCatalog,
@@ -42,7 +42,7 @@ import {
   analyticsRanges,
   analyticsReadSchema,
   dashboardDefinitionSchema
-} from "../chunk-ULQU7KC4.js";
+} from "../chunk-N3LJ6GFK.js";
 import "../chunk-4OC7REYX.js";
 import {
   DEFAULT_MANAGEMENT_TIMEOUT,
@@ -63,22 +63,22 @@ import {
   participantExchangeSchema,
   questConfiguration,
   sequenceCursorSchema
-} from "../chunk-G6XVBYH7.js";
+} from "../chunk-KWFY7L7X.js";
 import {
   parseImageExtraction,
   parseImageResult
-} from "../chunk-W5U2WXG3.js";
+} from "../chunk-KUPVQXUJ.js";
 import {
   imageAssetArtifactSchema,
   xUserLookupInputSchema,
   xUserSchema,
   xUsernameSchema
-} from "../chunk-CK7HO32Z.js";
+} from "../chunk-YOAPPIWN.js";
 import {
   sourceDataSchema,
   sourceRoles,
   validateQuestShape
-} from "../chunk-H2MD6E7Z.js";
+} from "../chunk-VWMIA2TT.js";
 import {
   isIntegrationParticipantPath,
   isParticipantRoute,
@@ -87,7 +87,7 @@ import {
 } from "../chunk-MHPKEVEW.js";
 import {
   withActionId
-} from "../chunk-INSWI2VZ.js";
+} from "../chunk-4OFH4BNX.js";
 import {
   allocateQuestSchema,
   allocatedQuestSchema,
@@ -97,6 +97,7 @@ import {
   collectionPreviewSchema,
   collectionResolveSchema,
   creatorAccountProviderSchema,
+  discordRoleRewardsSchema,
   memberEnrollmentInputSchema,
   publishQuestDraftSchema,
   questCatalogSchema,
@@ -107,7 +108,7 @@ import {
   rewardDeliveryQuerySchema,
   rewardDeliverySchema,
   saveQuestDraftSchema
-} from "../chunk-RBPMT53S.js";
+} from "../chunk-XQKUJL7H.js";
 import {
   badgeMutationResultSchema,
   badgeMutationSchema,
@@ -155,7 +156,7 @@ import {
   referralQualificationSchema,
   referralRewardResolutionSchema,
   referralSuspensionSchema
-} from "../chunk-BJYMTCWG.js";
+} from "../chunk-MJEJQH5A.js";
 import {
   createPointLedgerSchema,
   managedPointLedgerSchema,
@@ -164,16 +165,14 @@ import {
   pointLedgerSchema,
   profileModerationSchema,
   profileSettingsInputSchema,
-  profileSettingsSchema,
-  telegramChatConnectionSchema,
-  telegramChatIdSchema,
-  telegramChatsSchema
-} from "../chunk-VSHV7FEA.js";
-import "../chunk-KBVH4XZC.js";
-import "../chunk-ABJ4G47X.js";
-import "../chunk-QNQNKIAA.js";
+  profileSettingsSchema
+} from "../chunk-YNW2ZUUP.js";
+import "../chunk-6ZG7WNYX.js";
+import "../chunk-N7YOS4ZU.js";
+import "../chunk-422J3QRW.js";
 import {
   CompletionSourceKind,
+  acceptAnywaySchema,
   addGroupMemberSchema,
   appIdentityKindSchema,
   attemptSchema,
@@ -201,6 +200,7 @@ import {
   eventSchema,
   evmAddressSchema,
   evmChainIdSchema,
+  groupArchiveInputSchema,
   groupMemberPageSchema,
   groupMemberSchema,
   groupPageQuerySchema,
@@ -208,13 +208,16 @@ import {
   identifier,
   knownResponse,
   lazyResponseReaders,
+  lifecycleReasonSchema,
   linkedWalletSchema,
   managedGroupSchema,
+  managedTrackerCreateSchema,
   managementStateQuerySchema,
   memberCampaignEnrollmentInputSchema,
   memberCampaignWithdrawalInputSchema,
   memberIdentitySchema,
   memberProgressSchema,
+  offsetDateTimeSchema,
   pageCursorSchema,
   pageQuerySchema,
   pickupAvailabilitySchema,
@@ -234,10 +237,12 @@ import {
   stockItemSchema,
   streakProgressSchema,
   submitSchema,
+  telegramChatConnectionSchema,
+  telegramChatIdSchema,
+  telegramChatsSchema,
   trackerContentReadSchema,
   trackerContentSchema,
   trackerControlSchema,
-  trackerCreateSchema,
   trackerDataIssue,
   trackerDataIssues,
   trackerIngestResultSchema,
@@ -261,7 +266,7 @@ import {
   walletSignInNetworksSchema,
   walletUnlinkInputSchema,
   whereSchemaIssue
-} from "../chunk-BHHUSBSD.js";
+} from "../chunk-GBSDAD3N.js";
 
 // src/server/identity-links.ts
 import * as z from "zod";
@@ -357,10 +362,18 @@ var state2 = {
    */
   signIn: z2.boolean().nullable()
 };
+var account = {
+  /**
+   * True for an X, Discord or Telegram account a member import attached on the organization's
+   * word, until the member links that provider's account through Domino. Absent from Relay
+   * versions without it.
+   */
+  imported: z2.boolean().optional()
+};
 var memberIdentityStateSchema = z2.discriminatedUnion("kind", [
   walletIdentitySelectorSchema.strip().extend(state2),
-  oauthIdentitySelectorSchema.strip().extend(state2),
-  telegramIdentitySelectorSchema.strip().extend(state2),
+  oauthIdentitySelectorSchema.strip().extend({ ...state2, ...account }),
+  telegramIdentitySelectorSchema.strip().extend({ ...state2, ...account }),
   appIdentitySelectorSchema.strip().extend(state2)
 ]);
 var memberIdentityStatePageSchema = z2.object({
@@ -472,6 +485,25 @@ var leaderboardSettlementExportSchema = z4.object({
     })
   )
 });
+var csvField = (value) => {
+  const text = value == null ? "" : String(value);
+  return /[",\r\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+};
+function settlementPayoutCsv(exported) {
+  const unit = exported.pool === null ? "" : exported.pool.unit === "points" ? "points" : exported.pool.unit.code;
+  return [
+    ["member", "score", "rank", "share", "amount", "unit", "wallets"],
+    ...exported.rows.map((row) => [
+      row.member,
+      row.score,
+      row.rank,
+      row.share,
+      row.amount,
+      row.share === null ? "" : unit,
+      row.wallets.map((wallet) => `${wallet.network ?? wallet.chain}:${wallet.address}`).join(" ")
+    ])
+  ].map((fields) => fields.map(csvField).join(",")).join("\n");
+}
 
 // src/server/inventory-items.ts
 import * as z5 from "zod";
@@ -552,7 +584,10 @@ var testMemberSchema = z7.object({
   test: z7.literal(true),
   /** Current project-calendar date (YYYY-MM-DD), computed by the server. */
   today: z7.iso.date().optional(),
-  /** Number of calendar days advanced; absent means zero for older servers. */
+  /**
+   * Number of calendar days advanced with `days`; absent means zero for older servers. Hours,
+   * minutes and `to` leave it unchanged, so read the member's date from `today`.
+   */
   offsetDays: z7.number().int().min(0).optional(),
   /** Linked wallet addresses, by chain then newest first; absent from older servers. */
   wallets: z7.array(testMemberWalletSchema).optional(),
@@ -590,6 +625,19 @@ var testMemberAdvanceSchema = z7.object({
   actionId: identifier,
   days: z7.number().int().min(1).max(30)
 }).strict();
+var testMemberClockAdvanceSchema = z7.union([
+  testMemberAdvanceSchema,
+  z7.object({ actionId: identifier, hours: z7.number().int().min(1).max(720) }).strict(),
+  z7.object({
+    actionId: identifier,
+    minutes: z7.number().int().min(1).max(43200)
+  }).strict(),
+  z7.object({
+    actionId: identifier,
+    /** An ISO 8601 instant with an offset, such as `2026-10-10T00:00:00+02:00`. */
+    to: z7.iso.datetime({ offset: true })
+  }).strict()
+]);
 var testMemberResetResultSchema = z7.object({
   member: identifier,
   deleted: z7.literal(true)
@@ -739,7 +787,7 @@ var testMemberHistorySchema = z7.object({
 import * as z8 from "zod";
 var importTimeSchema = z8.union([
   z8.number().int().nonnegative().safe(),
-  z8.iso.datetime({ offset: true }).transform((value) => Date.parse(value))
+  offsetDateTimeSchema().transform((value) => Date.parse(value))
 ]);
 var importWalletSchema = z8.discriminatedUnion("chain", [
   z8.object({
@@ -763,6 +811,14 @@ var importXSchema = z8.object({
   kind: z8.literal("x"),
   subject: z8.string().regex(/^[1-9][0-9]{0,19}$/, "Use the numeric X user ID")
 }).strict();
+var importTelegramSchema = z8.object({
+  kind: z8.literal("telegram"),
+  subject: z8.string().regex(/^[1-9][0-9]{0,19}$/, "Use the numeric Telegram user ID")
+}).strict();
+var importDiscordSchema = z8.object({
+  kind: z8.literal("discord"),
+  subject: z8.string().regex(/^[1-9][0-9]{0,19}$/, "Use the numeric Discord user ID")
+}).strict();
 var importAppIdentitySchema = z8.object({ kind: appIdentityKindSchema, subject: z8.string().min(1).max(256) }).strict();
 var memberImportIdentitySchema = z8.union([
   importAppIdentitySchema,
@@ -773,10 +829,32 @@ var memberImportAccountSchema = z8.union([
   importWalletSchema,
   importXSchema
 ]);
+var memberImportVouchedAccountSchema = z8.union([
+  importWalletSchema,
+  importXSchema,
+  importTelegramSchema,
+  importDiscordSchema
+]);
 var memberImportActionSchema = z8.object({
   at: importTimeSchema,
   key: z8.string().min(1).max(200).optional()
 }).strict();
+var memberImportReferralSchema = z8.object({
+  /**
+   * The inviter: the `ref` of another row of this import, or the sign-in identity of a member
+   * who already exists in this environment.
+   */
+  inviter: z8.union([
+    z8.string().trim().min(1).max(200),
+    memberImportIdentitySchema
+  ]),
+  /** When the member accepted the invitation. */
+  acceptedAt: importTimeSchema,
+  /** Referral programs, by authoring key or ID, the member qualified in, and when. */
+  qualified: z8.array(
+    z8.object({ program: z8.string().min(1).max(200), at: importTimeSchema }).strict()
+  ).max(50).default([])
+}).strict();
 var memberImportRowSchema = z8.object({
   /** The member's ID on the platform they come from. Unique within an import. */
   ref: z8.string().trim().min(1).max(200),
@@ -795,7 +873,11 @@ var memberImportRowSchema = z8.object({
       quest: z8.string().min(1).max(200),
       actions: z8.array(memberImportActionSchema).min(1).max(3660)
     }).strict()
-  ).max(200).default([])
+  ).max(200).default([]),
+  referral: memberImportReferralSchema.optional()
+}).strict();
+var memberImportFullRowSchema = memberImportRowSchema.extend({
+  accounts: z8.array(memberImportVouchedAccountSchema).max(20).default([])
 }).strict();
 var memberImportCreateSchema = z8.object({
   actionId: identifier,
@@ -803,6 +885,7 @@ var memberImportCreateSchema = z8.object({
   source: z8.string().trim().min(1).max(100)
 }).strict();
 var memberImportRowsInputSchema = z8.object({ rows: z8.array(memberImportRowSchema).min(1).max(500) }).strict();
+var memberImportFullRowsInputSchema = z8.object({ rows: z8.array(memberImportFullRowSchema).min(1).max(500) }).strict();
 var MemberImportRefusalCode = {
   /** An account or identity belongs to another member in the project. */
   AccountLinkedElsewhere: "account-linked-elsewhere",
@@ -810,8 +893,12 @@ var MemberImportRefusalCode = {
   IdentityUnlinked: "identity-unlinked",
   /** An earlier row of the import names the same account. */
   DuplicateAccount: "duplicate-account",
-  /** The member already has another X account selected. */
+  /** The row names two X accounts, or the member already has another X account selected. */
   XAccountSelected: "x-account-selected",
+  /** The row names two Telegram accounts, or the member already has another one selected. */
+  TelegramAccountSelected: "telegram-account-selected",
+  /** The row names two Discord accounts, or the member already has another one selected. */
+  DiscordAccountSelected: "discord-account-selected",
   /** The member would hold more wallets of a chain family than a member can link. */
   LimitReached: "limit-reached",
   UnknownLedger: "unknown-ledger",
@@ -826,8 +913,20 @@ var MemberImportRefusalCode = {
   FutureAction: "future-action",
   /** The row's sign-in wallet or X account is linked to its member without sign-in. */
   SignInDisabled: "sign-in-disabled",
-  /** The row names one point ledger or quest twice, by any of its names. */
-  DuplicateEntry: "duplicate-entry"
+  /** The row names one point ledger, quest or referral program twice, by any of its names. */
+  DuplicateEntry: "duplicate-entry",
+  /** The inviter is no row of this import, and no member of the environment signs in with it. */
+  UnknownInviter: "unknown-inviter",
+  /** The row names its own member as the inviter. */
+  SelfReferral: "self-referral",
+  /** The member already has an inviter. An import never replaces one. */
+  InviterAlreadyAccepted: "inviter-already-accepted",
+  /** The inviter was invited, directly or through others, by this row's member. */
+  ReferralCycle: "referral-cycle",
+  /** The row that names the inviter was refused, so the inviter is never imported. */
+  InviterRefused: "inviter-refused",
+  /** No referral program of that key or ID in this environment, or it is archived. */
+  UnknownReferralProgram: "unknown-referral-program"
 };
 var refusalCodeSchema = z8.string();
 var memberImportRefusalSchema = z8.object({
@@ -871,11 +970,79 @@ var memberImportSummarySchema = z8.object({
   actions: z8.array(
     z8.object({ quest: z8.string(), total: z8.number().int().nonnegative() })
   ),
+  /**
+   * Accepted referrals the ready rows record, and their qualifications by program as the rows
+   * name it. Absent from a summary written before imports carried referrals.
+   */
+  referrals: z8.object({
+    accepted: z8.number().int().nonnegative(),
+    qualified: z8.array(
+      z8.object({
+        program: z8.string(),
+        total: z8.number().int().nonnegative()
+      })
+    )
+  }).optional(),
   /** Refused rows, by refusal code. A row can have several. */
   refusals: z8.array(
     z8.object({ code: refusalCodeSchema, rows: z8.number().int().nonnegative() })
   )
 });
+var memberImportRevertInputSchema = z8.object({
+  actionId: identifier,
+  reason: z8.string().trim().min(1).max(500)
+}).strict();
+var memberImportRevertOutcomeSchema = z8.object({
+  reversed: z8.object({
+    /** Applied rows the revert went through. */
+    rows: z8.number().int().nonnegative(),
+    /** Opening balance entries reversed. */
+    entries: z8.number().int().nonnegative(),
+    /** Imported completions revoked. */
+    completions: z8.number().int().nonnegative(),
+    /** Links the rows created that the revert removed. */
+    links: z8.number().int().nonnegative()
+  }),
+  /**
+   * Imported points the revert could not take back, by member and point ledger: the member had
+   * spent or reserved them. A revert takes only free points, as a completion's revocation does,
+   * so no balance goes below zero and Relay records no debt.
+   */
+  unreversedPoints: z8.array(
+    z8.object({
+      member: identifier,
+      ledger: identifier,
+      amount: z8.number().int().positive()
+    })
+  ),
+  /**
+   * Links the rows created that stay, because the member relied on them since: `signed-in` with
+   * it, or `proved` a vouched wallet. `kind` is `wallet`, the provider (`x`, `telegram`,
+   * `discord`) or `app:<name>`; `account` is the address or subject.
+   */
+  keptLinks: z8.array(
+    z8.object({
+      member: identifier,
+      kind: z8.string(),
+      account: z8.string(),
+      reason: z8.string()
+    })
+  ),
+  /**
+   * True when rows were applied before imports recorded the links they created: those rows'
+   * links all stay, and only their balances and completions were reversed.
+   */
+  linksUntracked: z8.boolean()
+});
+var memberImportRevertSchema = z8.object({
+  reason: z8.string(),
+  requestedAt: z8.number().int(),
+  requestedBy: z8.string().nullable(),
+  /** Applied rows reverted so far. */
+  rows: z8.number().int().nonnegative(),
+  revertedAt: z8.number().int().nullable(),
+  outcome: memberImportRevertOutcomeSchema.nullable()
+});
 var memberImportSchema = z8.object({
   id: identifier,
   source: z8.string(),
@@ -890,7 +1057,7 @@ var memberImportSchema = z8.object({
   rows: z8.number().int().nonnegative(),
   /** The latest check's summary, or null before the first check and after rows change. */
   summary: memberImportSummarySchema.nullable(),
-  /** While applying and after: rows applied and refused so far. */
+  /** While applying and after, stopped included: rows applied and refused so far. */
   progress: z8.object({
     applied: z8.number().int().nonnegative(),
     refused: z8.number().int().nonnegative()
@@ -901,7 +1068,12 @@ var memberImportSchema = z8.object({
   appliedAt: z8.number().int().nullable(),
   appliedBy: z8.string().nullable(),
   canceledAt: z8.number().int().nullable(),
-  canceledBy: z8.string().nullable()
+  canceledBy: z8.string().nullable(),
+  /** Set when the import was stopped while applying; it then reads as `applied` with `appliedAt` null. */
+  stoppedAt: z8.number().int().nullish(),
+  stoppedBy: z8.string().nullish(),
+  /** Set once a revert was asked for; the import still reads as `applied`. */
+  revert: memberImportRevertSchema.nullish()
 });
 var memberImportPageSchema = z8.object({
   items: z8.array(memberImportSchema),
@@ -1062,13 +1234,31 @@ var resourceLifecycleInputSchema = z10.object({
   kind: resourceLifecycleKindSchema,
   resource: identifier,
   archived: z10.boolean(),
-  reason: z10.string().trim().min(1).max(500),
+  reason: lifecycleReasonSchema,
   expectedArchivedAt: z10.number().int().nonnegative().nullable().optional()
 }).strict();
 var resourceLifecycleResultSchema = z10.object({
   resource: managedResourceSchema,
   changed: z10.boolean()
 });
+var managedOfferSchema = managedResourceSchema.extend({
+  kind: z10.literal("offer")
+});
+var managedResourceListSchema = z10.object({
+  resources: z10.array(managedResourceSchema),
+  offers: z10.array(managedOfferSchema).default([])
+});
+var offerLifecycleResultSchema = z10.object({
+  resource: managedOfferSchema,
+  changed: z10.boolean()
+});
+var offerLifecycleInputSchema = z10.strictObject({
+  actionId: z10.string().uuid(),
+  offer: identifier,
+  archived: z10.boolean(),
+  reason: z10.string().trim().min(1).max(500),
+  expectedArchivedAt: z10.number().int().nonnegative().nullable().optional()
+});
 var resourceLifecyclePaths = {
   tracker: "/trackers",
   referral: "/referral-programs",
@@ -1407,6 +1597,10 @@ function nextScheduleRun(schedule, after) {
   return next.getTime();
 }
 var appScheduleStateSchema = z14.enum(["active", "paused", "archived"]);
+var appScheduleStateInputSchema = z14.object({
+  state: appScheduleStateSchema,
+  reason: lifecycleReasonSchema.optional()
+}).strict();
 var APP_SCHEDULE_RESULT_BYTES = 16384;
 var appScheduleDiagnosticSchema = z14.object({
   level: z14.enum(["error", "warning", "info"]),
@@ -1537,6 +1731,46 @@ ${body}`)
 
 // src/server/starters.ts
 import * as z15 from "zod";
+var starters = [
+  {
+    id: "campaign",
+    title: "Campaign tour",
+    summary: "A neutral quest app with a guided tour of every quest kind. The blank canvas for anything."
+  },
+  {
+    id: "classic",
+    title: "Classic questboard",
+    summary: "The familiar Domino portal: quests in a grid grouped by section, a claim page, points, and a leaderboard."
+  },
+  {
+    id: "waitlist",
+    title: "Waitlist",
+    summary: "Collect sign-ups before launch. People move up the line by inviting friends."
+  },
+  {
+    id: "referral",
+    title: "Referral program",
+    summary: "Give every member an invite link and reward them when friends join and qualify."
+  },
+  {
+    id: "discord",
+    title: "Discord activation",
+    summary: "Turn new Discord members into regulars with quests for joining, introducing themselves, and taking part, rewarded with roles."
+  },
+  {
+    id: "loyalty",
+    title: "Loyalty program",
+    summary: "Members earn points in a campaign, qualify into a members' group, and spend points on offers, some for members only."
+  },
+  {
+    id: "api",
+    title: "API",
+    summary: "A headless Worker with typed routes and interactive API docs, for plugging Domino into your own product."
+  }
+];
+var offeredStarterSchema = z15.string().refine((id) => starters.some((starter) => starter.id === id), {
+  error: `Unknown starter. Choose one of: ${starters.map((starter) => starter.id).join(", ")}.`
+});
 var starterTemplates = [
   {
     id: "campaign",
@@ -1810,6 +2044,10 @@ var repositorySchema = z16.object({
   defaultBranch: z16.string(),
   status: z16.enum(["provisioning", "ready"])
 });
+var repositoryCreateSchema = z16.object({
+  /** Omitted: the starter chosen at project setup, else `campaign`. */
+  starter: offeredStarterSchema.optional()
+}).strict();
 var createRepositorySchema = z16.object({
   /** Omitted: the starter chosen at project setup, else `campaign`. */
   starter: starterIdSchema.optional()
@@ -1922,10 +2160,18 @@ var stagingAccessInputSchema = z16.discriminatedUnion("mode", [
     password: z16.string().min(8).max(128)
   }).strict()
 ]);
-var stagingPathSchema = z16.string().max(2048).refine(
-  (path) => path.startsWith("/") && !path.startsWith("//") && !path.includes("\\"),
-  "Expected a path on the staging host"
-);
+var stagingOrigin = "https://staging.invalid";
+var stagingPathSchema = z16.string().max(2048).refine((path) => {
+  if (!path.startsWith("/") || path.startsWith("//") || path.includes("\\") || // oxlint-disable-next-line no-control-regex
+  /[\u0000-\u001f\u007f]/.test(path)) {
+    return false;
+  }
+  try {
+    return new URL(path, stagingOrigin).origin === stagingOrigin;
+  } catch {
+    return false;
+  }
+}, "Expected a path on the staging host");
 var stagingLinkSchema = z16.object({
   url: z16.string().url(),
   expiresAt: z16.number()
@@ -1984,12 +2230,13 @@ var artifactFields = {
     }).strict()
   ).max(500)
 };
+var inlineCode = () => z16.unknown().optional().transform((value) => value);
 var buildArtifactsSchema = z16.discriminatedUnion("format", [
   z16.object({
     format: z16.literal(1),
     ...artifactFields,
-    quests: z16.unknown(),
-    catalog: z16.unknown()
+    quests: inlineCode(),
+    catalog: inlineCode()
   }).strict(),
   z16.object({
     format: z16.literal(2),
@@ -2192,6 +2439,13 @@ var projectSchema = z19.object({
     path: ["creator"]
   }
 );
+var projectCreateInputSchema = z19.object({
+  actionId: identifier,
+  name: z19.string().trim().min(1).max(80),
+  setup: projectSetupSchema.optional(),
+  /** The starter a new hosted app begins from, with `setup.mode` "new". */
+  starter: offeredStarterSchema.optional()
+}).strict();
 var projectInputSchema = z19.object({
   actionId: identifier,
   name: z19.string().trim().min(1).max(80),
@@ -2200,7 +2454,7 @@ var projectInputSchema = z19.object({
   starter: starterIdSchema.optional()
 }).strict();
 var projectUpdateInputSchema = z19.union([
-  z19.object({ name: projectInputSchema.shape.name }).strict(),
+  z19.object({ name: projectCreateInputSchema.shape.name }).strict(),
   z19.object({
     slug: projectSchema.shape.slug,
     confirm: z19.string().min(1).max(80)
@@ -2309,12 +2563,87 @@ var completionRevocationSchema = z19.object({
   ),
   streakMilestone: z19.boolean()
 });
+var completionRestoreSchema = z19.object({
+  actionId: identifier,
+  reason: z19.string().trim().min(1).max(500)
+}).strict();
+var RestoredEntitlementOutcome = {
+  /** The revocation voided it, and it is available again. */
+  Restored: "restored",
+  /** The revocation lowered or flagged it: its earned tier is the completion's again. */
+  Raised: "raised",
+  /** It changed since the revocation (an operator restored, voided or corrected it), so it stays. */
+  Kept: "kept"
+};
+var RestoredDeliveryOutcome = {
+  /** The grant had not reached Discord, and it is queued again. */
+  Requeued: "requeued",
+  /** The grant counts again for reconciliation, and its delivery status stays. */
+  Kept: "kept"
+};
+var RestoredReferralOutcome = {
+  /** The member qualifies on this completion again. */
+  Qualified: "qualified",
+  /** The program is disabled or gone, or the referral is suspended, so nothing changed. */
+  Kept: "kept"
+};
+var openOutcome = z19.string().min(1).max(64);
+var completionRestorationSchema = z19.object({
+  completion: identifier,
+  /** The quest ID, or the board ID when `source.kind` is `leaderboard`. */
+  quest: identifier,
+  member: identifier,
+  source: completionSourceSchema.optional(),
+  restoredAt: z19.number(),
+  points: z19.array(
+    z19.object({
+      entry: identifier,
+      balance: identifier,
+      reversal: identifier,
+      amount: z19.number().int()
+    })
+  ),
+  badges: z19.array(z19.object({ badge: identifier })),
+  groups: z19.array(z19.object({ group: identifier, added: z19.boolean() })),
+  entitlements: z19.array(
+    z19.object({
+      entitlement: identifier,
+      reward: identifier,
+      outcome: openOutcome,
+      status: z19.string()
+    })
+  ),
+  deliveries: z19.array(
+    z19.object({
+      delivery: z19.string(),
+      roleId: z19.string(),
+      outcome: openOutcome
+    })
+  ),
+  referrals: z19.array(
+    z19.object({
+      program: identifier,
+      outcome: openOutcome
+    })
+  ),
+  streakMilestone: z19.boolean()
+});
 var accessSchema = z19.object({
   actor: z19.string(),
   organization: z19.string(),
   admin: z19.boolean(),
   local: z19.boolean(),
-  projects: z19.array(projectSchema)
+  projects: z19.array(projectSchema),
+  /** The credential's own kind and scope, when it is an organization automation key. */
+  credential: z19.object({
+    kind: z19.string(),
+    id: z19.string(),
+    name: z19.string(),
+    /** The projects it reaches; null for every project of the organization. */
+    projects: z19.array(z19.string()).nullable(),
+    createProjects: z19.boolean(),
+    permissions: permissionListSchema
+  }).optional()
 });
 var querySchema = z19.object({
   q: z19.string().max(200).default(""),
@@ -2479,7 +2808,12 @@ var managedTelegramAccountSchema = z19.discriminatedUnion("status", [
     status: z19.literal("connected"),
     /** The numeric Telegram user ID. */
     subject: z19.string().min(1),
-    linkedAt: z19.number()
+    linkedAt: z19.number(),
+    /**
+     * True when a member import attached the account with the organization's word for it, not the
+     * member's proof. Absent from Relay versions without it.
+     */
+    imported: z19.boolean().optional()
   }),
   managedTelegramAccountBaseSchema.extend({
     status: z19.literal("disconnected")
@@ -2505,8 +2839,9 @@ var managedWalletSchema = linkedWalletSchema.extend({
 });
 var managedMemberIdentitySchema = memberIdentitySchema.extend({
   /**
-   * True for an X account a member import attached, until the member links or signs in with it
-   * through X. Absent from Relay versions without imports.
+   * True for an X or Discord account a member import attached, until the member links that
+   * provider's account, or signs in with the X account, through Domino. Absent from Relay versions
+   * without imports.
    */
   imported: z19.boolean().optional(),
   /**
@@ -2569,6 +2904,17 @@ var participantSignInSchema = z19.object({
     login: z19.boolean(),
     miniAppBotId: telegramBotIdSchema.nullable()
   }).optional(),
+  /**
+   * The creator-account providers, such as `youtube`, and whether Domino configured each, so
+   * members can link accounts that trackers like `youtube.shorts()` read. Absent from older Relay
+   * versions.
+   */
+  creatorAccounts: z19.array(
+    z19.object({
+      provider: creatorAccountProviderSchema,
+      configured: z19.boolean()
+    })
+  ).optional(),
   updatedAt: z19.number().nullable(),
   updatedBy: z19.string().nullable()
 });
@@ -2582,12 +2928,24 @@ var completionRevocationShortfallSchema = z19.object({
   revokedAt: z19.number().int().nonnegative().safe(),
   unreversedPoints: z19.record(identifier, z19.number().int().positive().safe())
 });
+var revokedCompletionSchema = z19.object({
+  completion: identifier,
+  quest: identifier,
+  /** The completion key: its occurrence, such as `once` or a day. */
+  key: z19.string(),
+  revokedAt: z19.number().int().nonnegative().safe(),
+  /** Why it was revoked, and what the revoke did, which a restore re-applies. */
+  reason: z19.string().optional(),
+  revocation: completionRevocationSchema.optional()
+});
 var memberDetailSchema = z19.object({
   snapshot: snapshotSchema,
   member: memberSchema,
   progress: memberProgressSchema,
   /** Up to 25 revoked completions with an unreversed point remainder, newest first. */
   revocationShortfalls: z19.array(completionRevocationShortfallSchema).default([]),
+  /** Up to 25 revoked completions, newest first. Relay older than restore leaves it out. */
+  revokedCompletions: z19.array(revokedCompletionSchema).optional(),
   /** Current and historical campaign enrollment state, including inactive enrollments. */
   campaignEnrollments: z19.array(campaignEnrollmentSchema).default([]),
   passes: z19.array(
@@ -2614,7 +2972,17 @@ var memberDetailSchema = z19.object({
    * The creator accounts the member linked (a YouTube channel), whose content managed tracker
    * sources attribute to them. Absent from Relay versions without creator accounts.
    */
-  creatorAccounts: z19.array(managedCreatorAccountSchema).optional()
+  creatorAccounts: z19.array(managedCreatorAccountSchema).optional(),
+  /**
+   * Who invited the member, when they accepted, and the member import that recorded it, or null
+   * when nobody invited them. Absent from Relay versions before imported referrals.
+   */
+  referral: z19.object({
+    inviter: identifier,
+    acceptedAt: z19.number().int().nonnegative(),
+    suspended: z19.boolean(),
+    import: identifier.nullable()
+  }).nullable().optional()
 });
 var managedMemberProgressSchema = z19.object({
   member: identifier,
@@ -2682,6 +3050,44 @@ var issuedServiceKeySchema = serviceKeySchema.extend({
   secret: z19.string().uuid(),
   token: z19.string()
 });
+var automationKeyPermissionSchema = z19.enum([
+  "read",
+  "publish",
+  "inventory",
+  "points",
+  "ingest",
+  "enroll"
+]);
+var automationKeyInputSchema = z19.object({
+  name: z19.string().trim().min(1).max(80),
+  permissions: z19.array(automationKeyPermissionSchema).min(1),
+  /** The projects it reaches. Omit it for every project of the organization, current and future. */
+  projects: z19.array(identifier).min(1).max(100).optional(),
+  /** Whether it may create projects. A project it creates joins its `projects` list. */
+  createProjects: z19.boolean().default(false),
+  /** Days until the first secret expires. Omit it for a key that never expires. */
+  expiresInDays: z19.number().int().min(1).max(3650).optional()
+}).strict();
+var automationKeySchema = z19.object({
+  id: z19.string().uuid(),
+  organization: z19.string(),
+  name: z19.string(),
+  permissions: permissionListSchema,
+  /** The projects it reaches; null for every project of the organization. */
+  projects: z19.array(z19.string()).nullable(),
+  createProjects: z19.boolean(),
+  /** The Clerk user ID of the administrator who created it. */
+  createdBy: z19.string(),
+  createdAt: z19.number(),
+  /** The latest use of any of its secrets, revoked ones included; null when none was used. */
+  lastUsedAt: z19.number().nullable(),
+  /** Its working secrets, oldest first. Any of them authenticates the key. */
+  secrets: z19.array(credentialSecretSchema)
+});
+var issuedAutomationKeySchema = automationKeySchema.extend({
+  secret: z19.string().uuid(),
+  token: z19.string()
+});
 var teamSchema = z19.array(
   z19.object({ id: z19.string(), label: z19.string() })
 );
@@ -2753,6 +3159,7 @@ var managedAttemptSchema = z19.object({
   attempt: attemptSchema,
   release: publishedReleaseSchema.nullable(),
   events: z19.array(eventSchema),
+  supersededBy: z19.string().nullable().optional(),
   person: personSchema
 });
 var managedEntitlementQuerySchema = z19.strictObject({
@@ -2938,6 +3345,31 @@ function managementClient(options) {
       typeof target === "string" ? call : inputOrCall
     );
   }
+  function setAppScheduleState(state3, inputOrCall, call) {
+    const reasoned = call !== void 0 || inputOrCall !== void 0 && "reason" in inputOrCall;
+    return request(
+      "/schedules/state",
+      appScheduleListSchema,
+      appScheduleStateInputSchema.parse({
+        ...reasoned ? inputOrCall : {},
+        state: state3
+      }),
+      "PUT",
+      reasoned ? call : inputOrCall
+    );
+  }
+  function archiveManagedGroup(verb) {
+    function change(group, inputOrCall, call) {
+      const reasoned = call !== void 0 || inputOrCall !== void 0 && "reason" in inputOrCall;
+      return post(
+        `/groups/${groupKey(group)}/${verb}`,
+        managedGroupSchema,
+        reasoned ? groupArchiveInputSchema.parse(inputOrCall) : {},
+        reasoned ? call : inputOrCall
+      );
+    }
+    return change;
+  }
   function archiveManagedPointLedger(ledger, inputOrCall, call) {
     const input = inputOrCall && "reason" in inputOrCall ? resourceArchiveInputSchema.parse(withActionId(inputOrCall)) : {};
     const options2 = inputOrCall && "reason" in inputOrCall ? call : inputOrCall;
@@ -3015,22 +3447,25 @@ function managementClient(options) {
     },
     trackers: {
       /**
-       * Creates an X search tracker as data in test, with the same validation as `defineTracker`;
-       * requires `publish`. Its first collection searches from `window.start`. Live refuses it with
-       * `promotion-required`: the tracker reaches live through a promotion. A key a deployment
-       * already publishes is refused with `tracker-owned-by-code`.
+       * Creates a tracker as data in test, with the same validation as `defineTracker`; requires
+       * `publish`. Name its source with `source`, such as `{ kind: "discord-messages", text: true }`,
+       * or an X search with `query` alone. An X tracker's first collection searches from
+       * `window.start`. Live refuses it with `promotion-required`: the tracker reaches live through
+       * a promotion. A key a deployment already publishes is refused with `tracker-owned-by-code`.
        */
       create: (input, call) => create(
         "/trackers",
         trackerStatusSchema,
-        trackerCreateSchema,
+        managedTrackerCreateSchema,
         input,
         call
       ),
       /**
-       * Changes a tracker created with `create`, in test; fields left out keep their value. A new
-       * query or window collects from now on and never searches the past. A tracker defined in
-       * code changes only through a deployment (`tracker-owned-by-code`).
+       * Changes a tracker created with `create`, in test; fields left out keep their value. `source`
+       * replaces the source's settings but never its kind (`validation-failed`). A new query or
+       * window collects from now on and never searches the past, and turning Discord message text
+       * off erases the text already stored. A tracker defined in code changes only through a
+       * deployment (`tracker-owned-by-code`).
        */
       update: (reference, input, call) => post(
         `/trackers/${identifier.parse(reference)}/update`,
@@ -3512,20 +3947,11 @@ function managementClient(options) {
       ),
       /**
        * Freezes a group's membership. Its members still count for prerequisites, leaderboards
-       * and referral rules.
+       * and referral rules. Pass `{ reason }` to record why in the audit log.
        */
-      archive: (group, call) => post(
-        `/groups/${groupKey(group)}/archive`,
-        managedGroupSchema,
-        {},
-        call
-      ),
-      unarchive: (group, call) => post(
-        `/groups/${groupKey(group)}/unarchive`,
-        managedGroupSchema,
-        {},
-        call
-      ),
+      archive: archiveManagedGroup("archive"),
+      /** Lets a group's membership change again, with an optional `{ reason }` for the audit log. */
+      unarchive: archiveManagedGroup("unarchive"),
       /** 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))}`,
@@ -3927,6 +4353,24 @@ function managementClient(options) {
         staffDecisionSchema.parse(withActionId(input)),
         call
       ),
+      /**
+       * Accepts a rejected attempt anyway, with a reason, for any member; requires `review`
+       * permission. The evaluator's or a reviewer's rejection stays in the attempt's events, its
+       * retry cooldown ends, and the acceptance pays as a reviewer's approval would, with the
+       * normal accepted events and webhook. Only the member's latest attempt on a quest that isn't
+       * archived (409 `attempt-superseded`, `quest-archived`); a cap the acceptance would break is
+       * refused, not bypassed (409 `completion-cooldown`, `budget-exhausted`, `completion-revoked`,
+       * `already-completed`). Replaying the action ID returns the first result.
+       */
+      acceptAnyway: (input, call) => {
+        const { attempt, ...body } = input;
+        return post(
+          `/attempts/${identifier.parse(attempt)}/accept-anyway`,
+          attemptSchema,
+          acceptAnywaySchema.parse(withActionId(body)),
+          call
+        );
+      },
       /** Evaluates a failed attempt again under a new generation; requires `review` permission. */
       retry: (attempt, call) => post(
         `/attempts/${identifier.parse(attempt)}/retry`,
@@ -3966,6 +4410,26 @@ function managementClient(options) {
           completionRevokeSchema.parse(withActionId(body)),
           call
         );
+      },
+      /**
+       * Restores a revoked completion with a reason; requires `review` permission. In one
+       * transaction it clears the revocation and re-applies what the revocation recorded: awards
+       * back the points it reversed (not those it could not reverse), re-awards its badges, re-adds
+       * its group memberships, restores the tiered rewards it voided and raises those it lowered,
+       * queues its stopped Discord role grants again, re-qualifies its referrals, and restores a
+       * streak milestone. Budgets stay spent. Fails with 409 `completion-not-revoked` when the
+       * completion counts already, and with 409 `occurrence-taken` when the revocation freed the
+       * occurrence and another completion holds it now. Replaying the action ID returns the first
+       * result.
+       */
+      restore: (input, call) => {
+        const { completion, ...body } = input;
+        return post(
+          `/completions/${identifier.parse(completion)}/restore`,
+          completionRestorationSchema,
+          completionRestoreSchema.parse(withActionId(body)),
+          call
+        );
       }
     },
     /** Staff handover of a member's reward entitlement; requires `handover` permission. */
@@ -4027,6 +4491,20 @@ function managementClient(options) {
         entitlementCorrectionSchema.parse(withActionId(input)),
         call
       ),
+      /**
+       * Restores an entitlement an operator voided, at the `revision` the operator saw, with a
+       * reason. It is available again at the tier an accepted completion still earns, with any
+       * referral review the void settled. Fails with 409 `entitlement-status` when it isn't void;
+       * when a completion revocation voided it, or no accepted completion still earns it, with the
+       * revoked `completion` to restore instead; when canceling a redemption voided it; and for a
+       * referral reward voided before voids kept their referral reviews.
+       */
+      restore: (entitlement, input, call) => post(
+        `/entitlements/${identifier.parse(entitlement)}/restore`,
+        entitlementSchema,
+        entitlementCorrectionSchema.parse(withActionId(input)),
+        call
+      ),
       /**
        * Corrects a collection recorded by mistake, at the `revision` the operator saw, with a
        * reason. The entitlement is available again and any pickup size it held returns to stock.
@@ -4141,6 +4619,25 @@ function managementClient(options) {
       )
     },
     offers: {
+      /**
+       * Archive an offer in test, with a reason the audit log records: members stop seeing it and
+       * redeeming it fails with `offer-paused`, while its redemptions stay cancelable and it stays
+       * archived when its code deploys again. Live gets the change through a promotion. Requires
+       * `publish` permission.
+       */
+      archive: (offer, input, call) => post(
+        `/offers/${identifier.parse(offer)}/archive`,
+        offerLifecycleResultSchema,
+        resourceArchiveInputSchema.parse(withActionId(input)),
+        call
+      ),
+      /** Restore an archived offer in test. Requires `publish` permission. */
+      unarchive: (offer, input, call) => post(
+        `/offers/${identifier.parse(offer)}/unarchive`,
+        offerLifecycleResultSchema,
+        resourceArchiveInputSchema.parse(withActionId(input)),
+        call
+      ),
       pause: (offer, input, call) => post(
         `/offers/${identifier.parse(offer)}/pause`,
         offerSchema,
@@ -4182,7 +4679,7 @@ function managementClient(options) {
     },
     readiness: (call) => get("/readiness", readinessSchema, call),
     access: (call) => get("/access", accessSchema, call),
-    createProject: (input, call) => create("/projects", projectSchema, projectInputSchema, input, call),
+    createProject: (input, call) => create("/projects", projectSchema, projectCreateInputSchema, input, call),
     updateProject: (input, call) => request(
       "/project",
       projectSchema,
@@ -4272,6 +4769,47 @@ function managementClient(options) {
         call
       )
     },
+    /**
+     * Organization automation keys (`dak_`): credentials for a headless agent or CI across the
+     * organization's projects, owned by no person. They write in test only. Only an organization
+     * administrator in Console manages them.
+     */
+    automationKeys: {
+      list: (call) => get("/automation-keys", z19.array(automationKeySchema), call),
+      /** The secret `token` is in this response only. */
+      create: (input, call) => post(
+        "/automation-keys",
+        issuedAutomationKeySchema,
+        automationKeyInputSchema.parse(input),
+        call
+      ),
+      /**
+       * Rotation: issues another secret. The key's other secrets keep working until you revoke
+       * them with `revokeSecret`. The new `token` is in this response only.
+       */
+      addSecret: (id, input = {}, call) => post(
+        `/automation-keys/${z19.string().uuid().parse(id)}/secrets`,
+        issuedAutomationKeySchema,
+        credentialSecretInputSchema.parse(input),
+        call
+      ),
+      /** Stops one secret working. A key's last secret cannot be revoked; revoke the key instead. */
+      revokeSecret: (id, secret, call) => request(
+        `/automation-keys/${z19.string().uuid().parse(id)}/secrets/${z19.string().uuid().parse(secret)}`,
+        automationKeySchema,
+        void 0,
+        "DELETE",
+        call
+      ),
+      /** Deletes the key; every secret stops working. */
+      revoke: (id, call) => request(
+        `/automation-keys/${z19.string().uuid().parse(id)}`,
+        z19.null(),
+        void 0,
+        "DELETE",
+        call
+      )
+    },
     /** Who holds which roles on the client's project; organization administrators only. */
     grants: {
       list: (call) => get("/grants", z19.array(grantRecordSchema), call),
@@ -4473,11 +5011,7 @@ function managementClient(options) {
     questTypes: resourceArchiveMethods("quest-type"),
     images: resourceArchiveMethods("image"),
     resources: {
-      list: (call) => get(
-        "/resources",
-        z19.object({ resources: z19.array(managedResourceSchema) }),
-        call
-      ),
+      list: (call) => get("/resources", managedResourceListSchema, call),
       /** @deprecated Use the resource archive/unarchive methods. Removed in 2.0.0. */
       lifecycle: (input, call) => post(
         "/resources/lifecycle",
@@ -4515,6 +5049,12 @@ function managementClient(options) {
     ),
     /** Operations of the Discord role reward kind on assignments it delivered. */
     discordRoles: {
+      /**
+       * Every Discord role the project's reward deliveries grant in this environment, with the
+       * quests that requested it and its deliveries counted by status. Unlike `rewardDeliveries`,
+       * it covers the whole history, so a role granted only long ago still appears.
+       */
+      list: (call) => get("/reward-deliveries/roles", discordRoleRewardsSchema, call),
       /**
        * Hands the role assignment a delivery made to an external administrator or bot: Relay stops
        * removing it automatically, in every project and environment that shares the assignment.
@@ -4581,11 +5121,15 @@ function managementClient(options) {
         testMemberAcceptAnywaySchema.parse(withActionId(input)),
         call
       ),
-      /** Move forward 1–30 project-calendar days, up to 90 total. Reset deletes the member. */
+      /**
+       * Move the member's clock forward by 1–30 project-calendar days, 1–720 hours, 1–43200
+       * minutes, or `to` a later instant; at most 90 days ahead of real time. Reset deletes the
+       * member.
+       */
       advance: (member, input, call) => post(
         `/test-members/${identifier.parse(member)}/clock`,
         testMemberSchema,
-        testMemberAdvanceSchema.parse(withActionId(input)),
+        testMemberClockAdvanceSchema.parse(withActionId(input)),
         call
       ),
       /**
@@ -4660,7 +5204,8 @@ function managementClient(options) {
      * this project and environment. Add rows, `check` them (the dry run), read the summary and the
      * refused rows, then `apply`. Checking and applying run in the background: read the import
      * until its status is `checked` or `applied`. Needs `publish` permission. In live, only a
-     * person signed in to Console applies an import; keys and CLI sessions prepare and check it.
+     * person signed in to Console applies an import; keys and CLI sessions prepare, check, cancel,
+     * stop and revert it.
      */
     memberImports: {
       create: (input, call) => post(
@@ -4692,7 +5237,7 @@ function managementClient(options) {
       addRows: (id, rows, call) => post(
         `/member-imports/${identifier.parse(id)}/rows`,
         memberImportSchema,
-        memberImportRowsInputSchema.parse({ rows }),
+        memberImportFullRowsInputSchema.parse({ rows }),
         call
       ),
       /** Starts the dry run: every row is checked against the project, and nothing changes. */
@@ -4715,6 +5260,31 @@ function managementClient(options) {
         memberImportSchema,
         {},
         call
+      ),
+      /**
+       * Stops an applying import: the row being applied finishes, no further row is applied, and
+       * the import reads as `applied` with `appliedAt` null and `stoppedAt` set. Its remaining rows
+       * stay `ready`; a stopped import can't be applied again, so import the rest in a new import. Stopping a stopped import changes nothing.
+       */
+      stop: (id, call) => post(
+        `/member-imports/${identifier.parse(id)}/stop`,
+        memberImportSchema,
+        {},
+        call
+      ),
+      /**
+       * Starts reverting an applied or stopped import, in the background: each applied row's
+       * opening balances are reversed as far as the member still has the points, its imported
+       * completions revoked, and the links it created removed unless the member signed in with
+       * one since. Members stay in the project. Read the import until `revert.revertedAt` is set;
+       * `revert.outcome` then lists the points members had spent and the links kept. An import is
+       * reverted once; the same `actionId` answers the import again.
+       */
+      revert: (id, input, call) => post(
+        `/member-imports/${identifier.parse(id)}/revert`,
+        memberImportSchema,
+        memberImportRevertInputSchema.parse(withActionId(input)),
+        call
       )
     },
     /** The project's members, as operators see them. */
@@ -5022,13 +5592,8 @@ function managementClient(options) {
         {},
         call
       ),
-      setState: (state3, call) => request(
-        "/schedules/state",
-        appScheduleListSchema,
-        { state: appScheduleStateSchema.parse(state3) },
-        "PUT",
-        call
-      ),
+      /** Activates, pauses or archives the project's schedules, with an optional audited reason. */
+      setState: setAppScheduleState,
       recover: (name, input, call) => post(
         `/schedules/${appScheduleNameSchema.parse(name)}/recover`,
         appScheduleListSchema,
@@ -5480,6 +6045,9 @@ var managementResponseSchemas = lazyResponseReaders({
   get completionRevocationSchema() {
     return knownResponse(completionRevocationSchema);
   },
+  get completionRestorationSchema() {
+    return knownResponse(completionRestorationSchema);
+  },
   get contentPerformancePageSchema() {
     return knownResponse(contentPerformancePageSchema);
   },
@@ -5504,6 +6072,9 @@ var managementResponseSchemas = lazyResponseReaders({
   get deploymentResultSchema() {
     return knownResponse(deploymentResultSchema);
   },
+  get discordRoleRewardsSchema() {
+    return knownResponse(discordRoleRewardsSchema);
+  },
   get engagementBoundaryPageSchema() {
     return knownResponse(engagementBoundaryPageSchema);
   },
@@ -5555,6 +6126,12 @@ var managementResponseSchemas = lazyResponseReaders({
   get issuedServiceKeySchema() {
     return knownResponse(issuedServiceKeySchema);
   },
+  get automationKeySchema() {
+    return knownResponse(automationKeySchema);
+  },
+  get issuedAutomationKeySchema() {
+    return knownResponse(issuedAutomationKeySchema);
+  },
   get leaderboardPageSchema() {
     return knownResponse(leaderboardPageSchema);
   },
@@ -5627,6 +6204,12 @@ var managementResponseSchemas = lazyResponseReaders({
   get managedResourceSchema() {
     return knownResponse(managedResourceSchema);
   },
+  get managedResourceListSchema() {
+    return knownResponse(managedResourceListSchema);
+  },
+  get offerLifecycleResultSchema() {
+    return knownResponse(offerLifecycleResultSchema);
+  },
   get managedStockItemSchema() {
     return knownResponse(managedStockItemSchema);
   },
@@ -5956,6 +6539,9 @@ var managementResponses = lazyResponseReaders({
   get completionRevocationSchema() {
     return responseSchema(completionRevocationSchema);
   },
+  get completionRestorationSchema() {
+    return responseSchema(completionRestorationSchema);
+  },
   get contentPerformancePageSchema() {
     return responseSchema(contentPerformancePageSchema);
   },
@@ -5980,6 +6566,9 @@ var managementResponses = lazyResponseReaders({
   get deploymentResultSchema() {
     return responseSchema(deploymentResultSchema);
   },
+  get discordRoleRewardsSchema() {
+    return responseSchema(discordRoleRewardsSchema);
+  },
   get engagementBoundaryPageSchema() {
     return responseSchema(engagementBoundaryPageSchema);
   },
@@ -6031,6 +6620,12 @@ var managementResponses = lazyResponseReaders({
   get issuedServiceKeySchema() {
     return responseSchema(issuedServiceKeySchema);
   },
+  get automationKeySchema() {
+    return responseSchema(automationKeySchema);
+  },
+  get issuedAutomationKeySchema() {
+    return responseSchema(issuedAutomationKeySchema);
+  },
   get leaderboardPageSchema() {
     return responseSchema(leaderboardPageSchema);
   },
@@ -6103,6 +6698,12 @@ var managementResponses = lazyResponseReaders({
   get managedResourceSchema() {
     return responseSchema(managedResourceSchema);
   },
+  get managedResourceListSchema() {
+    return responseSchema(managedResourceListSchema);
+  },
+  get offerLifecycleResultSchema() {
+    return responseSchema(offerLifecycleResultSchema);
+  },
   get managedStockItemSchema() {
     return responseSchema(managedStockItemSchema);
   },
@@ -6317,6 +6918,9 @@ export {
   MemberImportRefusalCode,
   PayoutSourceKind,
   REFERRAL_INTEGRATION_REWARD_ERROR,
+  RestoredDeliveryOutcome,
+  RestoredEntitlementOutcome,
+  RestoredReferralOutcome,
   RevokedDeliveryOutcome,
   RevokedEntitlementOutcome,
   RevokedReferralOutcome,
@@ -6353,6 +6957,7 @@ export {
   appScheduleRunSchema,
   appScheduleRunsSchema,
   appScheduleSchema,
+  appScheduleStateInputSchema,
   appScheduleStateSchema,
   appSchedulesSchema,
   appSecretDeclarationSchema,
@@ -6377,6 +6982,9 @@ export {
   auditPageSchema,
   auditQuerySchema,
   auditRecordSchema,
+  automationKeyInputSchema,
+  automationKeyPermissionSchema,
+  automationKeySchema,
   balanceCheckSchema,
   billingCheckoutInputSchema,
   billingIntervals,
@@ -6395,6 +7003,8 @@ export {
   capturedFactSchema,
   commitSchema,
   compareAppMigrations,
+  completionRestorationSchema,
+  completionRestoreSchema,
   completionRevocationSchema,
   completionRevocationShortfallSchema,
   completionRevokeSchema,
@@ -6428,6 +7038,7 @@ export {
   environmentSchema,
   grantRecordSchema,
   grantSchema,
+  groupArchiveInputSchema,
   groupMemberPageSchema,
   groupMemberSchema,
   groupPageQuerySchema,
@@ -6456,6 +7067,7 @@ export {
   isIntegrationParticipantPath,
   isManagementError,
   isParticipantRoute,
+  issuedAutomationKeySchema,
   issuedServiceKeySchema,
   issuedTokenSchema,
   leaderboardSettlementExportSchema,
@@ -6480,11 +7092,13 @@ export {
   managedMemberProgressSchema,
   managedMemberQuerySchema,
   managedOAuthAccountSchema,
+  managedOfferSchema,
   managedPointHistoryPageSchema,
   managedQuestEnrollmentPageSchema,
   managedQuestEnrollmentSchema,
   managedReleasePageSchema,
   managedReleaseQuerySchema,
+  managedResourceListSchema,
   managedResourceSchema,
   managedStockItemSchema,
   managedTelegramAccountSchema,
@@ -6508,10 +7122,16 @@ export {
   memberImportAccountSchema,
   memberImportActionSchema,
   memberImportCreateSchema,
+  memberImportFullRowSchema,
+  memberImportFullRowsInputSchema,
   memberImportIdentitySchema,
   memberImportListQuerySchema,
   memberImportPageSchema,
+  memberImportReferralSchema,
   memberImportRefusalSchema,
+  memberImportRevertInputSchema,
+  memberImportRevertOutcomeSchema,
+  memberImportRevertSchema,
   memberImportRowPageSchema,
   memberImportRowQuerySchema,
   memberImportRowResultSchema,
@@ -6519,6 +7139,7 @@ export {
   memberImportRowsInputSchema,
   memberImportSchema,
   memberImportSummarySchema,
+  memberImportVouchedAccountSchema,
   memberLookupSchema,
   memberOAuthUnlinkInputSchema,
   memberSchema,
@@ -6528,6 +7149,9 @@ export {
   metricsSchema,
   nextScheduleRun,
   oauthIdentitySelectorSchema,
+  offerLifecycleInputSchema,
+  offerLifecycleResultSchema,
+  offeredStarterSchema,
   operationInputSchema,
   operationSchema,
   operatorUserSchema,
@@ -6544,6 +7168,7 @@ export {
   personSchema,
   pointLedgerPropertiesSchema,
   projectBillingSchema,
+  projectCreateInputSchema,
   projectDeletionInputSchema,
   projectDeletionSchema,
   projectInputSchema,
@@ -6577,12 +7202,14 @@ export {
   referralRewardResolutionSchema,
   referralSuspensionSchema,
   removeGroupMemberSchema,
+  repositoryCreateSchema,
   repositorySchema,
   resourceArchiveInputSchema,
   resourceLifecycleInputSchema,
   resourceLifecycleKindSchema,
   resourceLifecyclePaths,
   resourceLifecycleResultSchema,
+  revokedCompletionSchema,
   rolePermissions,
   roleSchema,
   scheduleResult,
@@ -6590,6 +7217,7 @@ export {
   sequenceCursorSchema,
   serviceKeyInputSchema,
   serviceKeySchema,
+  settlementPayoutCsv,
   sourceDataSchema,
   sourceRoles,
   stageRequestSchema,
@@ -6604,6 +7232,7 @@ export {
   stagingPathSchema,
   starterIdSchema,
   starterTemplates,
+  starters,
   stockAdditionSchema,
   stockInputSchema,
   teamSchema,
@@ -6615,6 +7244,7 @@ export {
   testMemberAccountUnlinkSchema,
   testMemberActionSchema,
   testMemberAdvanceSchema,
+  testMemberClockAdvanceSchema,
   testMemberCreateSchema,
   testMemberDiscordMessageSchema,
   testMemberDiscordReactionSchema,