@domino-sdk/relay 1.22.0 → 1.23.0

package/dist/accounts-B31dWEYD.d.ts

@@ -0,0 +1,292 @@
+import { z } from 'zod';
+
+/** A Discord message as `ctx.discord.message()` reads it, from the project's Discord server. */
+declare const discordMessageSchema: z.ZodObject<{
+    guildId: z.ZodString;
+    channelId: z.ZodString;
+    messageId: z.ZodString;
+    userId: z.ZodString;
+    content: z.ZodNullable<z.ZodString>;
+    replyTo: z.ZodNullable<z.ZodString>;
+    publishedAt: z.ZodNumber;
+}, z.core.$strict>;
+type DiscordMessage = z.infer<typeof discordMessageSchema>;
+/**
+ * Messages posted in the project's Discord server, written by the Discord gateway. The record's
+ * `author` is the message author's Discord account. Message text is stored only with `text: true`.
+ * Edits update stored text. Deleting a message, or turning text off, removes retained text.
+ */
+declare const discordMessagesSourceSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"discord-messages">;
+    /** Store each message's text in `data.text`. Off unless set. */
+    text: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/**
+ * Reactions added in the project's Discord server, written by the Discord gateway. The record's
+ * `author` is the reactor's Discord account and its `messageAuthor` account is the message's
+ * author, when Discord could name it.
+ */
+declare const discordReactionsSourceSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"discord-reactions">;
+}, z.core.$strict>;
+/** The `data` of a `discord.messages()` record. IDs are Discord snowflakes. */
+declare const discordMessageDataSchema: z.ZodObject<{
+    guildId: z.ZodString;
+    channelId: z.ZodString;
+    messageId: z.ZodString;
+    replyTo: z.ZodNullable<z.ZodString>;
+    publishedAt: z.ZodNumber;
+}, z.core.$strip>;
+type DiscordMessageData = z.infer<typeof discordMessageDataSchema>;
+/**
+ * The `data` of a `discord.messages({ text: true })` record. `text` is null when the platform's
+ * bot does not receive message content.
+ */
+declare const discordMessageTextDataSchema: z.ZodObject<{
+    guildId: z.ZodString;
+    channelId: z.ZodString;
+    messageId: z.ZodString;
+    replyTo: z.ZodNullable<z.ZodString>;
+    publishedAt: z.ZodNumber;
+    text: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type DiscordMessageTextData = z.infer<typeof discordMessageTextDataSchema>;
+/** The `data` of a `discord.reactions()` record. IDs are Discord snowflakes. */
+declare const discordReactionDataSchema: z.ZodObject<{
+    guildId: z.ZodString;
+    channelId: z.ZodString;
+    messageId: z.ZodString;
+    emoji: z.ZodObject<{
+        id: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    reactorRoles: z.ZodArray<z.ZodString>;
+    messagePublishedAt: z.ZodNumber;
+}, z.core.$strip>;
+type DiscordReactionData = z.infer<typeof discordReactionDataSchema>;
+/** Rewards and resource selectors supported by the Discord integration. */
+declare const discordRewardSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"integration">;
+    provider: z.ZodLiteral<"discord">;
+    action: z.ZodLiteral<"grant-role">;
+    roleId: z.ZodString;
+}, z.core.$strict>;
+declare const discordResourceSourceSchema: z.ZodUnion<readonly [z.ZodObject<{
+    provider: z.ZodLiteral<"discord">;
+    resource: z.ZodLiteral<"channel">;
+    types: z.ZodArray<z.ZodEnum<{
+        text: "text";
+        announcement: "announcement";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    provider: z.ZodLiteral<"discord">;
+    resource: z.ZodLiteral<"role">;
+    assignable: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>]>;
+
+/**
+ * The Telegram sign-in a project offers, beside `providers` in `relay.auth.providers()`.
+ *
+ * @compat output
+ */
+declare const telegramSignInMethodsSchema: z.ZodObject<{
+    login: z.ZodBoolean;
+    miniApp: z.ZodBoolean;
+}, z.core.$strip>;
+type TelegramSignInMethods = z.infer<typeof telegramSignInMethodsSchema>;
+/**
+ * The member's Telegram account, as `AccountConnection` describes the other providers'. `subject`
+ * is the numeric Telegram user ID; `configured` is whether Telegram Login is.
+ *
+ * @compat output
+ */
+declare const telegramAccountConnectionSchema: z.ZodObject<{
+    configured: z.ZodBoolean;
+    status: z.ZodEnum<{
+        disconnected: "disconnected";
+        connected: "connected";
+        reconnect: "reconnect";
+    }>;
+    subject: z.ZodNullable<z.ZodString>;
+    revision: z.ZodNumber;
+    provider: z.ZodLiteral<"telegram">;
+}, z.core.$strip>;
+type TelegramAccountConnection = z.infer<typeof telegramAccountConnectionSchema>;
+/** The signed launch data a Telegram Mini App receives, `Telegram.WebApp.initData`. */
+declare const telegramInitDataSchema: z.ZodString;
+/** `POST /v1/auth/telegram/mini-app`: sign in, or connect Telegram to the signed-in member. */
+declare const telegramMiniAppSignInSchema: z.ZodObject<{
+    initData: z.ZodString;
+    mode: z.ZodEnum<{
+        "sign-in": "sign-in";
+        connect: "connect";
+    }>;
+}, z.core.$strict>;
+/** A Telegram chat ID as a decimal string: negative for groups, supergroups and channels. */
+declare const telegramChatIdSchema: z.ZodString;
+/**
+ * A chat bound to the project through Domino's bot. `status` is `ready` while the bot can read
+ * the chat as an administrator, `attention` with an `issue` once it cannot.
+ *
+ * @compat output
+ */
+declare const telegramChatSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    title: z.ZodString;
+    username: z.ZodNullable<z.ZodString>;
+    status: z.ZodString;
+    issue: z.ZodNullable<z.ZodString>;
+    connectedAt: z.ZodNumber;
+}, z.core.$strip>;
+type TelegramChat = z.infer<typeof telegramChatSchema>;
+/**
+ * The project's Telegram chats in this environment, and Domino's bot. `configured` is whether
+ * Domino configured its bot; without it no chat can be added.
+ *
+ * @compat output
+ */
+declare const telegramChatsSchema: z.ZodObject<{
+    configured: z.ZodBoolean;
+    bot: z.ZodNullable<z.ZodObject<{
+        username: z.ZodString;
+    }, z.core.$strip>>;
+    chats: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        title: z.ZodString;
+        username: z.ZodNullable<z.ZodString>;
+        status: z.ZodString;
+        issue: z.ZodNullable<z.ZodString>;
+        connectedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type TelegramChats = z.infer<typeof telegramChatsSchema>;
+/**
+ * A chat installation in progress: open `url` in Telegram, start Domino's bot and choose the chat.
+ * It expires at `expiresAt`, epoch milliseconds.
+ *
+ * @compat output
+ */
+declare const telegramChatConnectionSchema: z.ZodObject<{
+    url: z.ZodString;
+    expiresAt: z.ZodNumber;
+}, z.core.$strip>;
+type TelegramChatConnection = z.infer<typeof telegramChatConnectionSchema>;
+/** `ctx.telegram.member({ chat })`: a chat the project bound, by its numeric ID or @username. */
+declare const telegramMemberInputSchema: z.ZodObject<{
+    chat: z.ZodString;
+}, z.core.$strict>;
+/** A member's status in a chat as Telegram reports it; a later Telegram may add others. */
+type TelegramChatMemberStatus = "creator" | "administrator" | "member" | "restricted" | (string & {});
+/**
+ * The member's place in a Telegram chat, read with Domino's bot when quest code asks.
+ *
+ * @compat output
+ */
+declare const telegramChatMemberSchema: z.ZodObject<{
+    userId: z.ZodString;
+    username: z.ZodNullable<z.ZodString>;
+    status: z.ZodCustom<TelegramChatMemberStatus, TelegramChatMemberStatus>;
+    isMember: z.ZodBoolean;
+    isAdmin: z.ZodBoolean;
+    untilDate: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+type TelegramChatMember = z.infer<typeof telegramChatMemberSchema>;
+/**
+ * Reads a chat the project connected, for the member's linked Telegram account. The account is
+ * pinned at the attempt's first Telegram call, so later links and unlinks do not change the
+ * attempt; each call reads the chat as it is then. A chat the project has not connected, or whose bot lost access,
+ * throws `CapabilityError` with code `"integration-required"`; a Telegram outage throws
+ * `"provider-unavailable"`.
+ */
+interface TelegramReader {
+    /** The member in `chat`; null when they are not in it or have not linked Telegram. */
+    member(input: {
+        chat: string;
+    }): Promise<TelegramChatMember | null>;
+}
+/**
+ * The namespace of the tracker source `telegram.reactions()` makes. Relay alone writes its
+ * records; ingestion into it is refused.
+ */
+declare const telegramReactionsNamespace = "telegram-reactions";
+/**
+ * One reaction a Telegram user added to a message, as a `telegram.reactions()` record's `data`.
+ * Every field is a scalar, so a trigger's `where` can select on it.
+ *
+ * @compat output
+ */
+declare const telegramReactionDataSchema: z.ZodObject<{
+    chatId: z.ZodString;
+    chatType: z.ZodString;
+    messageId: z.ZodNumber;
+    reactionType: z.ZodString;
+    emoji: z.ZodNullable<z.ZodString>;
+    customEmojiId: z.ZodNullable<z.ZodString>;
+    reactorStatus: z.ZodString;
+    reactorIsAdmin: z.ZodBoolean;
+}, z.core.$strip>;
+type TelegramReactionData = z.infer<typeof telegramReactionDataSchema>;
+
+declare const authProviderSchema: z.ZodEnum<{
+    discord: "discord";
+    google: "google";
+    apple: "apple";
+    x: "x";
+}>;
+type AuthProvider = z.infer<typeof authProviderSchema>;
+declare const accountConnectionSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        discord: "discord";
+        google: "google";
+        apple: "apple";
+        x: "x";
+    }>;
+    configured: z.ZodBoolean;
+    status: z.ZodEnum<{
+        disconnected: "disconnected";
+        connected: "connected";
+        reconnect: "reconnect";
+    }>;
+    subject: z.ZodNullable<z.ZodString>;
+    revision: z.ZodNumber;
+}, z.core.$strip>;
+type AccountConnection = z.infer<typeof accountConnectionSchema>;
+declare const discordMemberInputSchema: z.ZodObject<{}, z.core.$strict>;
+declare const discordMessageInputSchema: z.ZodObject<{
+    channelId: z.ZodString;
+    messageId: z.ZodString;
+}, z.core.$strict>;
+declare const discordMemberSchema: z.ZodObject<{
+    userId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    nickname: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    displayName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    boostingSince: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    roles: z.ZodArray<z.ZodString>;
+    joinedAt: z.ZodNullable<z.ZodString>;
+    pending: z.ZodBoolean;
+}, z.core.$strip>;
+type DiscordMember = z.infer<typeof discordMemberSchema>;
+/**
+ * Reads the project's connected Discord server for the member's linked Discord account. The
+ * account and the integration are pinned at the attempt's first Discord read: later links and
+ * unlinks do not change the attempt. Provider failures, and an integration that is not ready,
+ * throw `CapabilityError` with code `"provider-unavailable"`.
+ */
+interface DiscordReader {
+    /** The member's server membership; null when they are not in the server or have not linked Discord. */
+    member(): Promise<DiscordMember | null>;
+    /**
+     * A message in the connected server; null when it does not exist. The bot reads it, so the
+     * member needs no linked Discord account. A channel outside the connected server, or one the
+     * bot cannot see, throws
+     * `CapabilityError` with code `"author-error"`.
+     */
+    message(input: {
+        channelId: string;
+        messageId: string;
+    }): Promise<DiscordMessage | null>;
+}
+
+export { type AccountConnection as A, discordRewardSchema as B, telegramAccountConnectionSchema as C, type DiscordMessageData as D, telegramChatConnectionSchema as E, telegramChatIdSchema as F, telegramChatMemberSchema as G, telegramChatSchema as H, telegramChatsSchema as I, telegramInitDataSchema as J, telegramMemberInputSchema as K, telegramMiniAppSignInSchema as L, telegramReactionDataSchema as M, telegramReactionsNamespace as N, telegramSignInMethodsSchema as O, type TelegramAccountConnection as T, type AuthProvider as a, type TelegramSignInMethods as b, type DiscordMessageTextData as c, discordMessagesSourceSchema as d, discordReactionsSourceSchema as e, type DiscordReactionData as f, type TelegramReader as g, type DiscordReader as h, type TelegramChatMember as i, type TelegramChatMemberStatus as j, type TelegramReactionData as k, type DiscordMember as l, type DiscordMessage as m, type TelegramChat as n, type TelegramChatConnection as o, type TelegramChats as p, accountConnectionSchema as q, authProviderSchema as r, discordMemberInputSchema as s, discordMemberSchema as t, discordMessageDataSchema as u, discordMessageInputSchema as v, discordMessageSchema as w, discordMessageTextDataSchema as x, discordReactionDataSchema as y, discordResourceSourceSchema as z };

package/dist/{attempt-captures-ByzZyggX.d.ts → attempt-captures-JDIgz2lY.d.ts}

@@ -1,4 +1,4 @@
-import { O as OpenIdentityKind } from './schema-Br3c1GOu.js';
+import { O as OpenIdentityKind } from './schema-D57mhL2q.js';
 import { z } from 'zod';
 
 /** One capability call of the captured evaluation run, as Relay stored it. */

package/dist/authoring.d.ts

@@ -1,17 +1,18 @@
-import { x as xContentBodySchema, I as IdentityKind, n as customSourceSchema, W as WithRecordData, o as WithContent, p as WithAccountRoles, q as ResourceHandle, r as QuestHandle, L as LedgerReference, G as GroupHandle, u as TrackerSource, v as trackerDefinitionSchema, y as Tracker, z as TrackerData, B as SourceRoles, C as LedgerHandle, D as xSearchSourceSchema, X as XTweet, F as XContentMetric, H as TrackerTriggerPolicy, J as Where, N as MemberIdentity, U as TrackerTriggerContext, V as TrackerReader, Y as TextReviewInput, Z as TextResult, P as PhotoResult, _ as Decision, $ as rewardSchema, a0 as TrackerTriggerMode, a1 as RoleOf, a2 as WhereSetting, a3 as ContentBody, a4 as BadgeHandle, a5 as ContentMetricName, a6 as triggerSchema, d as QuestPresentation, e as QuestProfile, f as QuizEvidence, a7 as TieredRewardDefinition } from './schema-Br3c1GOu.js';
-export { a8 as LedgerSetting, a9 as TrackerDataSchema, aa as TrackerPage, ab as TrackerReadQuery, ac as trackerDataSchema, ad as trackerTriggerContextSchema } from './schema-Br3c1GOu.js';
+import { x as xContentBodySchema, I as IdentityKind, n as customSourceSchema, W as WithRecordData, o as WithContent, p as WithAccountRoles, q as ResourceHandle, r as QuestHandle, L as LedgerReference, G as GroupHandle, u as TrackerSource, v as trackerDefinitionSchema, y as Tracker, z as TrackerData, B as SourceRoles, C as LedgerHandle, D as TrackerDataSchema, F as xSearchSourceSchema, X as XTweet, H as XContentMetric, J as TrackerTriggerPolicy, N as Where, U as MemberIdentity, V as TrackerTriggerContext, Y as TrackerReader, Z as TextReviewInput, _ as TextResult, P as PhotoResult, $ as Decision, a0 as rewardSchema, a1 as TrackerTriggerMode, a2 as RoleOf, a3 as WhereSetting, a4 as ContentBody, a5 as BadgeHandle, a6 as ContentMetricName, a7 as triggerSchema, d as QuestPresentation, e as QuestProfile, f as QuizEvidence, a8 as TieredRewardDefinition } from './schema-D57mhL2q.js';
+export { a9 as LedgerSetting, aa as TrackerPage, ab as TrackerReadQuery, ac as trackerDataSchema, ad as trackerTriggerContextSchema } from './schema-D57mhL2q.js';
 import { z } from 'zod';
 export { z } from 'zod';
-import { f as badgeDeclarationSchema, B as Badge } from './offers-CPqiF3dZ.js';
-export { g as defineOffer } from './offers-CPqiF3dZ.js';
-import { E as EngagementBudget, q as leaderboardDefinitionSchema, r as AuthoringIdentity, s as pointLedgerDeclarationSchema, t as referralAuthoringSchema, C as CampaignDefinition, A as AvailabilityWindow } from './groups-jLLG7MML.js';
-export { u as defineCampaign, v as defineGroup } from './groups-jLLG7MML.js';
-import { d as discordMessagesSourceSchema, D as DiscordMessageData, b as DiscordMessageTextData, c as discordReactionsSourceSchema, e as DiscordReactionData, f as DiscordReader } from './accounts-5ciAkCMP.js';
+import { f as badgeDeclarationSchema, B as Badge } from './offers-CEwkAGsB.js';
+export { g as defineOffer } from './offers-CEwkAGsB.js';
+import { E as EngagementBudget, q as leaderboardDefinitionSchema, r as AuthoringIdentity, s as pointLedgerDeclarationSchema, t as referralAuthoringSchema, C as CampaignDefinition, A as AvailabilityWindow } from './groups-CfyRewkJ.js';
+export { u as defineCampaign, v as defineGroup } from './groups-CfyRewkJ.js';
+import { d as discordMessagesSourceSchema, D as DiscordMessageData, c as DiscordMessageTextData, e as discordReactionsSourceSchema, f as DiscordReactionData, g as TelegramReader, h as DiscordReader } from './accounts-B31dWEYD.js';
+export { i as TelegramChatMember, j as TelegramChatMemberStatus, k as TelegramReactionData } from './accounts-B31dWEYD.js';
 import { Q as QuizContent, a as StreakPolicy } from './streaks-CWyq8Px5.js';
-import { R as ResourceSource, S as Setting, I as IntegrationModule, B as Budget, a as IntegerSettings } from './integrations-Cr9EhGI_.js';
-import { P as Prerequisite, T as TextEvidence, U as UrlEvidence, a as TextOptions, b as UrlOptions } from './submission-input-BEJ9qENg.js';
-export { c as balanceAtLeast, d as completed, i as inGroup } from './submission-input-BEJ9qENg.js';
-import { I as ImageReader } from './images-BPiPqVKn.js';
+import { R as ResourceSource, S as Setting, I as IntegrationModule, B as Budget, a as IntegerSettings } from './integrations-BMNtARU_.js';
+import { P as Prerequisite, T as TextEvidence, U as UrlEvidence, a as TextOptions, b as UrlOptions } from './submission-input-DjXg0o-r.js';
+export { c as balanceAtLeast, d as completed, i as inGroup } from './submission-input-DjXg0o-r.js';
+import { I as ImageReader } from './images-DwNmzqWv.js';
 import { X as XReader } from './capability-error-oTd3eYFH.js';
 export { C as CapabilityError, a as CapabilityErrorCode, c as capabilityErrorCodes } from './capability-error-oTd3eYFH.js';
 import { h as WalletReader } from './wallet-CDyo-U4n.js';
@@ -257,8 +258,8 @@ declare function defineLeaderboard(input: Omit<LeaderboardInput, "key" | "id" |
         kind: "earned";
     }> | ReturnType<typeof earned>;
 }): {
-    title: string;
     balance: string;
+    title: string;
     access: "participants" | "public";
     score: {
         kind: "balance";
@@ -427,6 +428,41 @@ declare const discord: {
         types?: ChannelTypes;
     }): ResourceSource;
 };
+/**
+ * Telegram, through Domino's bot in the chats a project connects in Console.
+ *
+ * - `telegram.reactions()`: a tracker source of the reactions members add to messages in those
+ *   groups and supergroups. Each record is one added reaction: its `author` is the reactor and
+ *   its `messageAuthor` account is the message's author, both Telegram accounts. `data` is
+ *   `TelegramReactionData`, so a trigger can select an emoji or an administrator's reactions.
+ *   Pay the message's author with `automatic({ tracker, beneficiary: "messageAuthor" })`.
+ * - Quests read membership with `ctx.telegram.member({ chat })`, naming the chat with
+ *   `settings.telegramChat()`.
+ *
+ * In SDK 1.x the reactions source is a custom source whose namespace Relay reserves: only Relay
+ * writes its records, and the accounts on them are Telegram accounts whatever `identities` says.
+ */
+declare const telegram: {
+    reactions(): {
+        kind: "custom";
+        namespace: string;
+        identities?: ("discord" | "wallet" | "x" | "member" | `app:${string}`)[] | undefined;
+        accounts?: string[] | undefined;
+        data?: TrackerDataSchema | undefined;
+        content?: {
+            metrics: string[];
+        } | undefined;
+    } & WithRecordData<{
+        chatId: string;
+        chatType: string;
+        messageId: number;
+        reactionType: string;
+        emoji: string | null;
+        customEmojiId: string | null;
+        reactorStatus: string;
+        reactorIsAdmin: boolean;
+    }> & WithAccountRoles<"author" | "messageAuthor">;
+};
 declare const pointLedgers: () => ResourceSource;
 type Label = {
     label: string;
@@ -460,6 +496,13 @@ declare const settings: {
         maxLength?: number;
         multiline?: boolean;
     }): Setting<"text", z.ZodDefault<z.ZodString>>;
+    /**
+     * A Telegram chat the project connected, by its numeric ID: Console lists the connected chats
+     * to choose from. Pass it to `ctx.telegram.member({ chat })`.
+     */
+    telegramChat(options: Label & {
+        default?: string;
+    }): Setting<"text", z.ZodDefault<z.ZodString>>;
     integer(options: Label & {
         default: number;
         min: number;
@@ -930,6 +973,12 @@ type EvaluationContext<T, I = {
         }): Promise<PhotoResult>;
     };
     wallet: WalletReader;
+    /**
+     * Telegram membership in the chats the project connected. It needs no `integrations` entry;
+     * Relay provides it to every quest from SDK 1.22.0 on, and it is absent from older runtimes and
+     * test contexts that do not supply it.
+     */
+    telegram?: TelegramReader;
 } & IntegrationReaders<D>;
 type Evaluator<T, I = {
     photo: string;
@@ -1048,15 +1097,15 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
             badge?: string | undefined;
         };
         tier: string;
+    } | {
+        kind: "points";
+        balance: string;
+        amount: number;
     } | {
         kind: "integration";
         provider: "discord";
         action: "grant-role";
         roleId: string;
-    } | {
-        kind: "points";
-        balance: string;
-        amount: number;
     })[] | ((ctx: {
         settings: z.core.$InferObjectOutput<T, {}>;
     }) => Reward[]);
@@ -1131,6 +1180,9 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
             kind: "resource";
             default: string;
             source: {
+                provider: "domino";
+                resource: "point-ledger";
+            } | {
                 provider: "discord";
                 resource: "channel";
                 types: ("text" | "announcement")[];
@@ -1138,9 +1190,6 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
                 provider: "discord";
                 resource: "role";
                 assignable: boolean;
-            } | {
-                provider: "domino";
-                resource: "point-ledger";
             };
             label: string;
             description?: string | undefined;
@@ -1164,6 +1213,7 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
             maxLength: number;
             multiline: boolean;
             label: string;
+            picker?: string | undefined;
             description?: string | undefined;
         } | {
             kind: "integer";
@@ -1213,15 +1263,15 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
                 badge?: string | undefined;
             };
             tier: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
         } | {
             kind: "integration";
             provider: "discord";
             action: "grant-role";
             roleId: string;
-        } | {
-            kind: "points";
-            balance: string;
-            amount: number;
         })[];
         humanReview: boolean;
         trigger: {
@@ -1243,7 +1293,7 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
             actor?: "staff" | "member" | undefined;
         } | {
             kind: "manual";
-            input: "none" | "quiz" | "photo";
+            input: "photo" | "quiz" | "none";
             actor?: "staff" | "member" | undefined;
         } | {
             kind: "automatic";
@@ -1287,9 +1337,9 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
                     path: string;
                     equals: string | number | boolean;
                 })[] | undefined;
-                enrollment?: "none" | "required" | undefined;
+                enrollment?: "required" | "none" | undefined;
                 since?: "activation" | "window" | "enrollment" | undefined;
-                historical?: "staff" | "claim" | "automatic" | undefined;
+                historical?: "automatic" | "staff" | "claim" | undefined;
                 content?: true | undefined;
             } | undefined;
         };
@@ -1312,6 +1362,9 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
             title: string;
         })[];
         completion: {
+            kind: "streak";
+            days: number;
+        } | {
             kind: "progress";
             goal: {
                 kind: "count";
@@ -1328,9 +1381,6 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
                 durationMs: number;
             };
             repeat: "repeat" | "once";
-        } | {
-            kind: "streak";
-            days: number;
         } | {
             kind: "once";
         } | {
@@ -1356,7 +1406,7 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
         campaign?: {
             key: string;
             title: string;
-            enrollment: "none" | "required";
+            enrollment: "required" | "none";
             window?: {
                 from: number;
                 until: number;
@@ -1406,6 +1456,12 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
             }): Promise<PhotoResult>;
         };
         wallet: WalletReader;
+        /**
+         * Telegram membership in the chats the project connected. It needs no `integrations` entry;
+         * Relay provides it to every quest from SDK 1.22.0 on, and it is absent from older runtimes and
+         * test contexts that do not supply it.
+         */
+        telegram?: TelegramReader;
     } & IntegrationReaders<readonly IntegrationModule[]> & {
         rewards: Reward[];
         humanReview: boolean;
@@ -1465,15 +1521,15 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
             badge?: string | undefined;
         };
         tier: string;
+    } | {
+        kind: "points";
+        balance: string;
+        amount: number;
     } | {
         kind: "integration";
         provider: "discord";
         action: "grant-role";
         roleId: string;
-    } | {
-        kind: "points";
-        balance: string;
-        amount: number;
     })[] | ((ctx: {
         settings: z.core.$InferObjectOutput<T, {}>;
     }) => Reward[]);
@@ -1548,6 +1604,9 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
             kind: "resource";
             default: string;
             source: {
+                provider: "domino";
+                resource: "point-ledger";
+            } | {
                 provider: "discord";
                 resource: "channel";
                 types: ("text" | "announcement")[];
@@ -1555,9 +1614,6 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
                 provider: "discord";
                 resource: "role";
                 assignable: boolean;
-            } | {
-                provider: "domino";
-                resource: "point-ledger";
             };
             label: string;
             description?: string | undefined;
@@ -1581,6 +1637,7 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
             maxLength: number;
             multiline: boolean;
             label: string;
+            picker?: string | undefined;
             description?: string | undefined;
         } | {
             kind: "integer";
@@ -1630,15 +1687,15 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
                 badge?: string | undefined;
             };
             tier: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
         } | {
             kind: "integration";
             provider: "discord";
             action: "grant-role";
             roleId: string;
-        } | {
-            kind: "points";
-            balance: string;
-            amount: number;
         })[];
         humanReview: boolean;
         trigger: {
@@ -1660,7 +1717,7 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
             actor?: "staff" | "member" | undefined;
         } | {
             kind: "manual";
-            input: "none" | "quiz" | "photo";
+            input: "photo" | "quiz" | "none";
             actor?: "staff" | "member" | undefined;
         } | {
             kind: "automatic";
@@ -1704,9 +1761,9 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
                     path: string;
                     equals: string | number | boolean;
                 })[] | undefined;
-                enrollment?: "none" | "required" | undefined;
+                enrollment?: "required" | "none" | undefined;
                 since?: "activation" | "window" | "enrollment" | undefined;
-                historical?: "staff" | "claim" | "automatic" | undefined;
+                historical?: "automatic" | "staff" | "claim" | undefined;
                 content?: true | undefined;
             } | undefined;
         };
@@ -1729,6 +1786,9 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
             title: string;
         })[];
         completion: {
+            kind: "streak";
+            days: number;
+        } | {
             kind: "progress";
             goal: {
                 kind: "count";
@@ -1745,9 +1805,6 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
                 durationMs: number;
             };
             repeat: "repeat" | "once";
-        } | {
-            kind: "streak";
-            days: number;
         } | {
             kind: "once";
         } | {
@@ -1773,7 +1830,7 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
         campaign?: {
             key: string;
             title: string;
-            enrollment: "none" | "required";
+            enrollment: "required" | "none";
             window?: {
                 from: number;
                 until: number;
@@ -1823,6 +1880,12 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
             }): Promise<PhotoResult>;
         };
         wallet: WalletReader;
+        /**
+         * Telegram membership in the chats the project connected. It needs no `integrations` entry;
+         * Relay provides it to every quest from SDK 1.22.0 on, and it is absent from older runtimes and
+         * test contexts that do not supply it.
+         */
+        telegram?: TelegramReader;
     } & IntegrationReaders<readonly IntegrationModule[]> & {
         rewards: Reward[];
         humanReview: boolean;
@@ -1830,4 +1893,4 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
     }): Promise<Decision>;
 } & ResourceHandle<"quest">;
 
-export { ContentBody, type ContentData, ContentMetricName, type ContentTrigger, type ContentTriggerInput, DiscordMessageData, DiscordMessageTextData, DiscordReactionData, DiscordReader, type EvaluationCalendar, type EvaluationCalendarDay, type EvaluationContext, type EvaluationMember, GroupHandle, IdentityKind, ImageReader, IntegrationModule, type KeyedContext, LedgerHandle, LedgerReference, MemberIdentity, type Outcome, type PerformanceContext, type PerformanceOutcome, QuestHandle, RoleOf, Setting, Tracker, TrackerData, TrackerReader, type TrackerTrigger, TrackerTriggerContext, type TrackerTriggerInput, type TriggerAdmission, WalletReader, Where, type XContentBody, XReader, automatic, automaticFulfillment, badge, budget, calendar, content, count, customSource, decision, defineBadge, defineEngagementReward, defineLeaderboard, defineLedger, defineQuest, defineQuestType, defineReferral, defineTieredReward, defineTracker, discord, earned, evaluators, evidence, keyed, manual, once, pointLedgers, points, progress, questCompleted, rolling, settings, staffHandover, streak, untracked, x };
+export { ContentBody, type ContentData, ContentMetricName, type ContentTrigger, type ContentTriggerInput, DiscordMessageData, DiscordMessageTextData, DiscordReactionData, DiscordReader, type EvaluationCalendar, type EvaluationCalendarDay, type EvaluationContext, type EvaluationMember, GroupHandle, IdentityKind, ImageReader, IntegrationModule, type KeyedContext, LedgerHandle, LedgerReference, MemberIdentity, type Outcome, type PerformanceContext, type PerformanceOutcome, QuestHandle, RoleOf, Setting, TelegramReader, Tracker, TrackerData, TrackerDataSchema, TrackerReader, type TrackerTrigger, TrackerTriggerContext, type TrackerTriggerInput, type TriggerAdmission, WalletReader, Where, type XContentBody, XReader, automatic, automaticFulfillment, badge, budget, calendar, content, count, customSource, decision, defineBadge, defineEngagementReward, defineLeaderboard, defineLedger, defineQuest, defineQuestType, defineReferral, defineTieredReward, defineTracker, discord, earned, evaluators, evidence, keyed, manual, once, pointLedgers, points, progress, questCompleted, rolling, settings, staffHandover, streak, telegram, untracked, x };