@domino-sdk/relay 1.59.0 → 1.61.0

package/dist/server/index.js

@@ -1,7 +1,7 @@
 import {
   attemptCaptureSchema,
   capturedFactSchema
-} from "../chunk-KBCTII6C.js";
+} from "../chunk-7A4J67ZL.js";
 import {
   activityTypeSchema,
   activityTypes,
@@ -27,7 +27,7 @@ import {
   publishDeploymentSchema,
   rejectDeploymentSchema,
   submitDeploymentSchema
-} from "../chunk-M2JQPDUX.js";
+} from "../chunk-VURRFVNP.js";
 import {
   analyticsBreakdowns,
   analyticsCatalog,
@@ -42,7 +42,7 @@ import {
   analyticsRanges,
   analyticsReadSchema,
   dashboardDefinitionSchema
-} from "../chunk-W42KMMH5.js";
+} from "../chunk-DYXDZFKA.js";
 import "../chunk-4OC7REYX.js";
 import {
   DEFAULT_MANAGEMENT_TIMEOUT,
@@ -63,22 +63,22 @@ import {
   participantExchangeSchema,
   questConfiguration,
   sequenceCursorSchema
-} from "../chunk-LDLOB2UZ.js";
+} from "../chunk-DHXDBAJF.js";
 import {
   parseImageExtraction,
   parseImageResult
-} from "../chunk-YRSU2X2P.js";
+} from "../chunk-5I54XBK2.js";
 import {
   imageAssetArtifactSchema,
   xUserLookupInputSchema,
   xUserSchema,
   xUsernameSchema
-} from "../chunk-IBROKMFV.js";
+} from "../chunk-L77O64I4.js";
 import {
   sourceDataSchema,
   sourceRoles,
   validateQuestShape
-} from "../chunk-YMWRLAAP.js";
+} from "../chunk-RHBS5FJL.js";
 import {
   isIntegrationParticipantPath,
   isParticipantRoute,
@@ -87,7 +87,7 @@ import {
 } from "../chunk-MHPKEVEW.js";
 import {
   withActionId
-} from "../chunk-KYUQEZZA.js";
+} from "../chunk-QEAS4ZGS.js";
 import {
   allocateQuestSchema,
   allocatedQuestSchema,
@@ -108,7 +108,7 @@ import {
   rewardDeliveryQuerySchema,
   rewardDeliverySchema,
   saveQuestDraftSchema
-} from "../chunk-6U5WWH3W.js";
+} from "../chunk-QNUHWK7R.js";
 import {
   badgeMutationResultSchema,
   badgeMutationSchema,
@@ -156,7 +156,7 @@ import {
   referralQualificationSchema,
   referralRewardResolutionSchema,
   referralSuspensionSchema
-} from "../chunk-UEMLYPKJ.js";
+} from "../chunk-3Y3L2F54.js";
 import {
   createPointLedgerSchema,
   managedPointLedgerSchema,
@@ -165,14 +165,11 @@ import {
   pointLedgerSchema,
   profileModerationSchema,
   profileSettingsInputSchema,
-  profileSettingsSchema,
-  telegramChatConnectionSchema,
-  telegramChatIdSchema,
-  telegramChatsSchema
-} from "../chunk-XGXDINGM.js";
-import "../chunk-R4S6BFOH.js";
-import "../chunk-TZJT5CRF.js";
-import "../chunk-EQF4ID47.js";
+  profileSettingsSchema
+} from "../chunk-SE4PFJPT.js";
+import "../chunk-XBV2CK2H.js";
+import "../chunk-EN3M5Z4J.js";
+import "../chunk-PPB7HALD.js";
 import {
   CompletionSourceKind,
   acceptAnywaySchema,
@@ -198,6 +195,7 @@ import {
   counterModerationSchema,
   createGroupSchema,
   createStockItemSchema,
+  discordServerSchema,
   entitlementCorrectionSchema,
   entitlementSchema,
   eventSchema,
@@ -221,6 +219,7 @@ import {
   memberIdentitySchema,
   memberProgressSchema,
   offsetDateTimeSchema,
+  organizationDiscordServersSchema,
   pageCursorSchema,
   pageQuerySchema,
   pickupAvailabilitySchema,
@@ -228,6 +227,7 @@ import {
   projectCalendarInputSchema,
   projectCalendarSchema,
   projectGroupKey,
+  projectIntegrationSchema,
   publishedReleaseSchema,
   questSettingsInputSchema,
   questSubmissionSchema,
@@ -240,6 +240,9 @@ import {
   stockItemSchema,
   streakProgressSchema,
   submitSchema,
+  telegramChatConnectionSchema,
+  telegramChatIdSchema,
+  telegramChatsSchema,
   trackerContentReadSchema,
   trackerContentSchema,
   trackerControlSchema,
@@ -266,7 +269,7 @@ import {
   walletSignInNetworksSchema,
   walletUnlinkInputSchema,
   whereSchemaIssue
-} from "../chunk-AWWCEP7F.js";
+} from "../chunk-ZDJLPN4L.js";
 
 // src/server/identity-links.ts
 import * as z from "zod";
@@ -362,10 +365,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({
@@ -576,7 +587,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(),
@@ -614,6 +628,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)
@@ -787,6 +814,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,
@@ -797,10 +832,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),
@@ -819,7 +876,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,
@@ -827,6 +888,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",
@@ -834,8 +896,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",
@@ -850,8 +916,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({
@@ -895,11 +973,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(),
@@ -914,7 +1060,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()
@@ -925,7 +1071,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),
@@ -1093,6 +1244,24 @@ 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",
@@ -2642,7 +2811,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")
@@ -2668,8 +2842,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(),
   /**
@@ -2800,7 +2975,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,
@@ -4437,6 +4622,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,
@@ -4810,11 +5014,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",
@@ -4924,11 +5124,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
       ),
       /**
@@ -5003,7 +5207,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(
@@ -5035,7 +5240,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. */
@@ -5058,6 +5263,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. */
@@ -5636,6 +5866,45 @@ function managementClient(options) {
         call
       )
     },
+    /**
+     * This project and environment's Discord connection. An organization administrator installs
+     * Domino's bot into a new server in Console; once one project of the organization connects a
+     * server, `connect` connects it to another project of the same organization and environment.
+     */
+    discord: {
+      /** The project's Discord connection: its server and status; requires `read` permission. */
+      connection: async (call) => {
+        const list = await get("/integrations", z19.array(z19.unknown()), call);
+        return projectIntegrationSchema.parse(
+          list.find(
+            (item) => z19.object({ provider: z19.literal("discord") }).safeParse(item).success
+          )
+        );
+      },
+      /**
+       * The servers other projects of the organization connect and keep ready in this environment,
+       * which `connect` accepts; requires `read` permission.
+       */
+      servers: (call) => get(
+        "/integrations/discord/servers",
+        organizationDiscordServersSchema,
+        call
+      ),
+      /**
+       * Connects a server from `servers()` to this project and environment, without installing
+       * the bot again; requires `publish` permission. Domino's bot must still see the server.
+       * Fails with 409 `server-not-connected-in-organization` for any other server (an
+       * administrator installs it in Console), 409 `integration-connected` when the project
+       * already has a Discord connection, and 422 `server-not-reachable` when the bot lost it.
+       * Connecting the server the project already connects changes nothing.
+       */
+      connect: (server, call) => post(
+        `/integrations/discord/servers/${encodeURIComponent(discordServerSchema.shape.id.parse(server))}/connect`,
+        projectIntegrationSchema,
+        {},
+        call
+      )
+    },
     /**
      * The Telegram chats this project and environment connected through Domino's bot, which
      * `ctx.telegram.member()` and `telegram.reactions()` read. Telegram is not one of the
@@ -5962,6 +6231,12 @@ var managementResponseSchemas = lazyResponseReaders({
   get telegramChatsSchema() {
     return knownResponse(telegramChatsSchema);
   },
+  get organizationDiscordServersSchema() {
+    return knownResponse(organizationDiscordServersSchema);
+  },
+  get projectIntegrationSchema() {
+    return knownResponse(projectIntegrationSchema);
+  },
   get telegramChatConnectionSchema() {
     return knownResponse(telegramChatConnectionSchema);
   },
@@ -5977,6 +6252,12 @@ var managementResponseSchemas = lazyResponseReaders({
   get managedResourceSchema() {
     return knownResponse(managedResourceSchema);
   },
+  get managedResourceListSchema() {
+    return knownResponse(managedResourceListSchema);
+  },
+  get offerLifecycleResultSchema() {
+    return knownResponse(offerLifecycleResultSchema);
+  },
   get managedStockItemSchema() {
     return knownResponse(managedStockItemSchema);
   },
@@ -6450,6 +6731,12 @@ var managementResponses = lazyResponseReaders({
   get telegramChatsSchema() {
     return responseSchema(telegramChatsSchema);
   },
+  get organizationDiscordServersSchema() {
+    return responseSchema(organizationDiscordServersSchema);
+  },
+  get projectIntegrationSchema() {
+    return responseSchema(projectIntegrationSchema);
+  },
   get telegramChatConnectionSchema() {
     return responseSchema(telegramChatConnectionSchema);
   },
@@ -6465,6 +6752,12 @@ var managementResponses = lazyResponseReaders({
   get managedResourceSchema() {
     return responseSchema(managedResourceSchema);
   },
+  get managedResourceListSchema() {
+    return responseSchema(managedResourceListSchema);
+  },
+  get offerLifecycleResultSchema() {
+    return responseSchema(offerLifecycleResultSchema);
+  },
   get managedStockItemSchema() {
     return responseSchema(managedStockItemSchema);
   },
@@ -6853,11 +7146,13 @@ export {
   managedMemberProgressSchema,
   managedMemberQuerySchema,
   managedOAuthAccountSchema,
+  managedOfferSchema,
   managedPointHistoryPageSchema,
   managedQuestEnrollmentPageSchema,
   managedQuestEnrollmentSchema,
   managedReleasePageSchema,
   managedReleaseQuerySchema,
+  managedResourceListSchema,
   managedResourceSchema,
   managedStockItemSchema,
   managedTelegramAccountSchema,
@@ -6881,10 +7176,16 @@ export {
   memberImportAccountSchema,
   memberImportActionSchema,
   memberImportCreateSchema,
+  memberImportFullRowSchema,
+  memberImportFullRowsInputSchema,
   memberImportIdentitySchema,
   memberImportListQuerySchema,
   memberImportPageSchema,
+  memberImportReferralSchema,
   memberImportRefusalSchema,
+  memberImportRevertInputSchema,
+  memberImportRevertOutcomeSchema,
+  memberImportRevertSchema,
   memberImportRowPageSchema,
   memberImportRowQuerySchema,
   memberImportRowResultSchema,
@@ -6892,6 +7193,7 @@ export {
   memberImportRowsInputSchema,
   memberImportSchema,
   memberImportSummarySchema,
+  memberImportVouchedAccountSchema,
   memberLookupSchema,
   memberOAuthUnlinkInputSchema,
   memberSchema,
@@ -6901,6 +7203,8 @@ export {
   metricsSchema,
   nextScheduleRun,
   oauthIdentitySelectorSchema,
+  offerLifecycleInputSchema,
+  offerLifecycleResultSchema,
   offeredStarterSchema,
   operationInputSchema,
   operationSchema,
@@ -6994,6 +7298,7 @@ export {
   testMemberAccountUnlinkSchema,
   testMemberActionSchema,
   testMemberAdvanceSchema,
+  testMemberClockAdvanceSchema,
   testMemberCreateSchema,
   testMemberDiscordMessageSchema,
   testMemberDiscordReactionSchema,