@domino-sdk/relay 1.54.0 → 1.56.0

package/dist/chunk-VSHV7FEA.js

@@ -0,0 +1,344 @@
+import {
+  accountConnectionSchema,
+  identifier,
+  pageCursorSchema
+} from "./chunk-BHHUSBSD.js";
+
+// src/point-ledgers.ts
+import * as z from "zod";
+var pointLedgerPropertiesSchema = z.object({
+  name: z.string().trim().min(1).max(120),
+  description: z.string().trim().max(1e3).default("")
+}).strict();
+var createPointLedgerSchema = pointLedgerPropertiesSchema.extend({ actionId: identifier, key: identifier.optional() }).strict();
+var pointLedgerSchema = pointLedgerPropertiesSchema.extend({
+  id: identifier
+});
+var managedPointLedgerSchema = pointLedgerSchema.extend({
+  archivedAt: z.number().int().nonnegative().nullable()
+});
+var pointLedgerDeclarationSchema = pointLedgerPropertiesSchema.extend({ key: identifier }).strict();
+var pointLedgerArtifactSchema = z.union([
+  pointLedgerDeclarationSchema,
+  z.object({ code: z.string().min(1).max(2e6) }).strict()
+]);
+var pointLedgerReferenceSchema = z.object({
+  id: identifier,
+  key: identifier.nullable(),
+  name: z.string()
+});
+var points = z.number().int().safe();
+var pointBalanceSchema = z.object({
+  ledger: pointLedgerReferenceSchema,
+  balance: points,
+  available: points
+});
+var pointBalancesSchema = z.object({
+  items: z.array(pointBalanceSchema)
+});
+var PointEntryKind = {
+  /** Points a quest completion, an engagement settlement or an operator awarded. */
+  Award: "award",
+  /** Points the member spent. */
+  Spend: "spend",
+  /** A correction in either direction, by an operator or a referral payout. */
+  Adjust: "adjust",
+  /** Undoes part or all of an award or a positive adjustment (`reverses`). */
+  Reverse: "reverse"
+};
+var pointEntryKindSchema = z.string().min(1).max(64);
+var pointEntrySchema = z.object({
+  id: identifier,
+  amount: points,
+  kind: pointEntryKindSchema,
+  /** When the entry took effect, in epoch milliseconds. A reversal keeps its source's. */
+  at: points.nonnegative(),
+  quest: identifier.nullable(),
+  reverses: identifier.nullable(),
+  /**
+   * True for an opening balance a member import recorded (an `adjust`). Absent from Relay
+   * versions without imports.
+   */
+  imported: z.boolean().optional()
+});
+var pointHistoryQuerySchema = z.strictObject({
+  ledger: identifier,
+  cursor: pageCursorSchema.optional()
+});
+var pointHistoryPageSchema = z.object({
+  items: z.array(pointEntrySchema),
+  nextCursor: pageCursorSchema.nullable()
+});
+
+// src/telegram.ts
+import * as z2 from "zod";
+var telegramSignInMethodsSchema = z2.object({
+  /** Telegram Login, the OpenID Connect sign-in Domino configures for the platform. */
+  login: z2.boolean(),
+  /** Mini App sign-in, which the project enables in Console with its bot's ID. */
+  miniApp: z2.boolean()
+});
+var telegramAccountConnectionSchema = accountConnectionSchema.extend({
+  provider: z2.literal("telegram")
+});
+var telegramInitDataSchema = z2.string().min(1, "Pass the Mini App's Telegram.WebApp.initData").max(8192);
+var telegramMiniAppSignInSchema = z2.object({
+  initData: telegramInitDataSchema,
+  mode: z2.enum(["sign-in", "connect"])
+}).strict();
+var telegramChatIdSchema = z2.string().regex(
+  /^-?[1-9][0-9]{0,19}$/,
+  "Use the chat's numeric ID, such as -1001234567890"
+);
+var telegramChatSchema = z2.object({
+  /** The numeric chat ID, as a string. */
+  id: telegramChatIdSchema,
+  /** `group`, `supergroup` or `channel`; a later Telegram may add others. */
+  type: z2.string(),
+  title: z2.string(),
+  /** The public @username, without the @, or null for a private chat. */
+  username: z2.string().nullable(),
+  status: z2.string(),
+  issue: z2.string().nullable(),
+  connectedAt: z2.number()
+});
+var telegramChatsSchema = z2.object({
+  configured: z2.boolean(),
+  /** Domino's bot, the one operators add to their chats. */
+  bot: z2.object({ username: z2.string() }).nullable(),
+  chats: z2.array(telegramChatSchema)
+});
+var telegramChatConnectionSchema = z2.object({
+  url: z2.string(),
+  expiresAt: z2.number()
+});
+var telegramMemberInputSchema = z2.object({
+  chat: z2.string().regex(
+    /^(-?[1-9][0-9]{0,19}|@[A-Za-z][A-Za-z0-9_]{3,31})$/,
+    "Name a chat the project connected, by its numeric ID or @username"
+  )
+}).strict();
+var telegramChatMemberSchema = z2.object({
+  /** The numeric Telegram user ID. */
+  userId: z2.string(),
+  username: z2.string().nullable(),
+  status: z2.custom(
+    (value) => typeof value === "string"
+  ),
+  /** Whether they are in the chat now: a creator, administrator, member, or restricted member. */
+  isMember: z2.boolean(),
+  /** Whether they are its creator or an administrator. */
+  isAdmin: z2.boolean(),
+  /** When a paid subscription or a restriction ends, epoch milliseconds; null when it does not. */
+  untilDate: z2.number().nullable()
+});
+var telegramReactionsNamespace = "telegram-reactions";
+var telegramReactionDataSchema = z2.object({
+  /** The chat's numeric ID, as a string. */
+  chatId: z2.string(),
+  /** `group` or `supergroup`: channel reactions are anonymous and never recorded. */
+  chatType: z2.string(),
+  messageId: z2.number(),
+  /** `emoji`, `custom_emoji` or `paid`. */
+  reactionType: z2.string(),
+  /** The emoji, such as "❤", for an `emoji` reaction; null otherwise. */
+  emoji: z2.string().nullable(),
+  /** The custom emoji's ID for a `custom_emoji` reaction; null otherwise. */
+  customEmojiId: z2.string().nullable(),
+  /**
+   * `creator` or `administrator` for one of the chat's administrators, read at most ten minutes
+   * before Relay recorded the reaction; `member` for anyone else.
+   */
+  reactorStatus: z2.string(),
+  /** Whether the reactor was the chat's creator or an administrator then. */
+  reactorIsAdmin: z2.boolean()
+});
+
+// src/profiles.ts
+import * as z3 from "zod";
+var count = z3.number().int().nonnegative().safe();
+var profileVisibilitySchema = z3.enum([
+  "private",
+  "participants",
+  "public"
+]);
+var avatarProviderSchema = z3.enum(["x", "discord", "google"]);
+var profileDefaultProviderSchema = z3.enum(["x", "discord"]);
+var profileDefaultsSchema = z3.array(profileDefaultProviderSchema).max(profileDefaultProviderSchema.options.length).refine(
+  (providers) => new Set(providers).size === providers.length,
+  "List each provider once"
+);
+var avatarSeedSchema = z3.string().min(1).max(100);
+var profileAvatarSchema = z3.discriminatedUnion("source", [
+  z3.object({
+    source: z3.literal("upload"),
+    url: z3.string().url(),
+    seed: avatarSeedSchema
+  }),
+  z3.object({
+    source: z3.literal("account"),
+    provider: avatarProviderSchema,
+    url: z3.string().url(),
+    seed: avatarSeedSchema
+  }),
+  z3.object({ source: z3.literal("generated"), seed: avatarSeedSchema })
+]);
+var profileSummarySchema = z3.object({
+  id: identifier,
+  name: z3.string(),
+  avatar: profileAvatarSchema
+});
+var invisible = /[\p{Cc}؜᠎​-‏‪-‮⁠-⁤⁦-⁩]/u;
+var displayNameSchema = z3.string().max(200).transform((value) => value.normalize("NFC").replace(/\s+/g, " ").trim()).pipe(
+  z3.string().min(1, "Enter a name").max(40, "Use at most 40 characters").refine((value) => !invisible.test(value), "Use visible characters only")
+);
+var profileUpdateSchema = z3.object({
+  displayName: displayNameSchema.nullable().optional(),
+  avatar: z3.discriminatedUnion("source", [
+    z3.object({
+      source: z3.literal("account"),
+      provider: avatarProviderSchema
+    }).strict(),
+    z3.object({ source: z3.literal("generated") }).strict()
+  ]).nullable().optional(),
+  hidden: z3.boolean().optional()
+}).strict().refine(
+  (value) => Object.values(value).some((field) => field !== void 0),
+  "Change at least one field"
+);
+var ownProfileSchema = profileSummarySchema.extend({
+  /** The name the member chose, or null for the default. */
+  displayName: z3.string().nullable(),
+  /** The avatar the member chose: `default` follows the project's defaults. */
+  avatarChoice: z3.enum(["default", "upload", "account", "generated"]),
+  /** The account of an `account` choice. */
+  avatarProvider: avatarProviderSchema.nullable(),
+  hidden: z3.boolean(),
+  /** An operator locked the name and avatar; the member can still hide the profile. */
+  locked: z3.boolean(),
+  /** Who can see profiles in this project, so the app can explain it. */
+  visibility: profileVisibilitySchema,
+  /** The member's connected accounts a picture or name can come from. */
+  options: z3.array(
+    z3.object({
+      provider: avatarProviderSchema,
+      name: z3.string().nullable(),
+      /**
+       * The account's first name, where the provider sends one (Google does; X and Discord don't).
+       * Only the member's own profile carries it.
+       */
+      givenName: z3.string().nullable().default(null),
+      imageUrl: z3.string().url().nullable()
+    })
+  )
+});
+var cursor = z3.string().min(1).max(512);
+var profileCompletionQuerySchema = z3.object({
+  limit: z3.coerce.number().int().min(1).max(100).default(20),
+  cursor: cursor.optional()
+}).strict();
+var profileCompletionSchema = z3.object({
+  quest: identifier,
+  key: identifier.optional(),
+  title: z3.string(),
+  completions: count.positive(),
+  /** Null for completions recorded before completion times were. */
+  lastCompletedAt: count.nullable()
+});
+var profileCompletionPageSchema = z3.object({
+  items: z3.array(profileCompletionSchema),
+  nextCursor: cursor.nullable()
+});
+var profileReferralSchema = z3.object({
+  program: identifier,
+  key: identifier.optional(),
+  title: z3.string(),
+  /** Members this member invited. Invitations are shared by every program. */
+  invited: count,
+  /** Invited members who qualified in this program. */
+  qualified: count,
+  milestones: z3.array(
+    z3.object({ id: identifier, count, reached: z3.boolean() })
+  )
+});
+var profileSettingsSchema = z3.object({
+  visibility: profileVisibilitySchema,
+  defaults: profileDefaultsSchema,
+  revision: count,
+  actor: z3.string().nullable(),
+  updatedAt: count.nullable()
+});
+var profileSettingsInputSchema = profileSettingsSchema.omit({ revision: true, actor: true, updatedAt: true }).extend({
+  actionId: identifier,
+  /** The revision the change was made against; a newer one is a 409. */
+  expectedRevision: count,
+  reason: z3.string().trim().min(1).max(500)
+}).strict();
+var profileModerationSchema = z3.object({
+  actionId: identifier,
+  resetName: z3.boolean().default(false),
+  removeAvatar: z3.boolean().default(false),
+  /** True locks the name and avatar, false unlocks them. */
+  lock: z3.boolean().optional(),
+  reason: z3.string().trim().min(1).max(1e3)
+}).strict().refine(
+  (value) => value.resetName || value.removeAvatar || value.lock !== void 0,
+  "Choose an action"
+);
+var managedProfileSchema = ownProfileSchema.omit({ options: true }).extend({
+  member: identifier,
+  lockedAt: count.nullable(),
+  lockedBy: z3.string().nullable(),
+  lockedReason: z3.string().nullable(),
+  updatedAt: count
+});
+var AVATAR_UPLOAD_LIMIT = 5 * 1024 * 1024;
+var avatarUploadTypes = ["image/jpeg", "image/png", "image/webp"];
+
+export {
+  pointLedgerPropertiesSchema,
+  createPointLedgerSchema,
+  pointLedgerSchema,
+  managedPointLedgerSchema,
+  pointLedgerDeclarationSchema,
+  pointLedgerArtifactSchema,
+  pointLedgerReferenceSchema,
+  pointBalanceSchema,
+  pointBalancesSchema,
+  PointEntryKind,
+  pointEntrySchema,
+  pointHistoryQuerySchema,
+  pointHistoryPageSchema,
+  telegramSignInMethodsSchema,
+  telegramAccountConnectionSchema,
+  telegramInitDataSchema,
+  telegramMiniAppSignInSchema,
+  telegramChatIdSchema,
+  telegramChatSchema,
+  telegramChatsSchema,
+  telegramChatConnectionSchema,
+  telegramMemberInputSchema,
+  telegramChatMemberSchema,
+  telegramReactionsNamespace,
+  telegramReactionDataSchema,
+  profileVisibilitySchema,
+  avatarProviderSchema,
+  profileDefaultProviderSchema,
+  profileDefaultsSchema,
+  avatarSeedSchema,
+  profileAvatarSchema,
+  profileSummarySchema,
+  displayNameSchema,
+  profileUpdateSchema,
+  ownProfileSchema,
+  profileCompletionQuerySchema,
+  profileCompletionSchema,
+  profileCompletionPageSchema,
+  profileReferralSchema,
+  profileSettingsSchema,
+  profileSettingsInputSchema,
+  profileModerationSchema,
+  managedProfileSchema,
+  AVATAR_UPLOAD_LIMIT,
+  avatarUploadTypes
+};

package/dist/{chunk-LPHXTZDA.js → chunk-W5U2WXG3.js}

@@ -4,10 +4,10 @@ import {
   imageFieldsSchema,
   imageInspectionSchema,
   imageSightingsSchema
-} from "./chunk-K6TVMNU4.js";
+} from "./chunk-CK7HO32Z.js";
 import {
   photoResultSchema
-} from "./chunk-IELNFM3V.js";
+} from "./chunk-BHHUSBSD.js";
 
 // src/image-results.ts
 import * as z from "zod";

package/dist/{client-CzNtl8UO.d.ts → client-bX3oTpRu.d.ts}

@@ -1,12 +1,12 @@
-import { y as referralAcceptSchema, i as LeaderboardQuery, b as CampaignEnrollmentInput, d as CampaignWithdrawalInput, o as PointHistoryQuery, m as PointEntryKind, f as LeaderboardHistoryQuery, z as engagementPageQuerySchema } from './groups-B5R1RCsl.js';
-import { j as QuestView, k as ResponseSchema, a as PageQuery, c as QuestEnrollmentInput, Q as QuestClaimInput, g as QuestOutcomeQuery, q as questExperienceSchema, l as RewardDeliveryQuery, m as RewardDeliveryAction, n as contentQualificationQuerySchema } from './pages-BTlOg8sl.js';
-import { M as MissingPrerequisite, V as ValueEvidence } from './submission-input-BNah53go.js';
+import { m as QuizEvidence, A as Attempt, M as MemberProgress, a as AttemptStatus, o as TrackerSkipCode, i as PointHistoryQuery, g as PointEntryKind, ao as submitSchema, ap as contentPerformanceQuerySchema } from './schema-C4m9RhCR.js';
+import { l as QuestView, m as ResponseSchema, c as PageQuery, e as QuestEnrollmentInput, Q as QuestClaimInput, i as QuestOutcomeQuery, q as questExperienceSchema, a as CreatorAccountProvider, n as RewardDeliveryQuery, o as RewardDeliveryAction, r as contentQualificationQuerySchema } from './pages-BlLqB8ZQ.js';
+import { M as MissingPrerequisite, V as ValueEvidence } from './submission-input-wTiYGdgA.js';
 import { a as RequestError, b as RequestErrorDetails, c as RequestErrorKind, e as createRelayAction, O as OptionalActionId } from './action-DBzILFx9.js';
-import { f as QuizEvidence, A as Attempt, M as MemberProgress, a as AttemptStatus, h as TrackerSkipCode, ae as submitSchema, af as contentPerformanceQuerySchema } from './schema-BJ9bOgpN.js';
 import { b as ParticipantSession, e as exchangeSchema, R as RelayEvent, P as ParticipantActivity } from './participant-activity-iciCEs_8.js';
 import * as z from 'zod';
 import { a as AuthProvider } from './accounts-DRPENuZe.js';
-import { p as profileUpdateSchema, c as ProfileCompletionQuery } from './profiles-Cdv4BSd_.js';
+import { p as referralAcceptSchema, i as LeaderboardQuery, b as CampaignEnrollmentInput, d as CampaignWithdrawalInput, f as LeaderboardHistoryQuery, q as engagementPageQuerySchema } from './groups-DPE004_V.js';
+import { p as profileUpdateSchema, c as ProfileCompletionQuery } from './profiles-BoOK03cR.js';
 import { w as walletAddressInputSchema, o as walletSignatureSchema, L as LinkedWallet, f as WalletSigner } from './wallet-Ac7OFpOr.js';
 
 /** What happened, as in every Domino client error (see `RequestError`). */
@@ -59,6 +59,11 @@ declare const RelayErrorCode: {
      * says when they may submit again.
      */
     readonly RetryCooldown: "retry-cooldown";
+    /**
+     * The member's last accepted completion of the quest is more recent than its completion
+     * cooldown; `retryAt` says when they may submit again.
+     */
+    readonly CompletionCooldown: "completion-cooldown";
     /** The quiz changed since the member answered it. */
     readonly StaleQuiz: "stale-quiz";
     /** Relay refused the submitted evidence. */
@@ -89,7 +94,7 @@ declare const RelayErrorCode: {
     readonly Credential: "credential";
     /** A wallet signer failed or the member refused to sign; `cause` is the wallet's own error. */
     readonly WalletSigner: "wallet-signer";
-    /** The member has not met the quest's prerequisites; `missing` lists them. */
+    /** The member has not met the quest's or offer's prerequisites; `missing` lists them. */
     readonly PrerequisitesIncomplete: "prerequisites-incomplete";
     /** The quest is archived or retired: it takes no new participation. */
     readonly QuestClosed: "quest-closed";
@@ -115,7 +120,10 @@ type RelayErrorDetails = RequestErrorDetails & {
     /** Which window refused admission when `code` is `outside-window`. */
     window?: "tracker" | "quest";
     missing?: MissingPrerequisite[];
-    /** Unix milliseconds when the member may submit again, when `code` is `retry-cooldown`. */
+    /**
+     * Unix milliseconds when the member may submit again, when `code` is `retry-cooldown` or
+     * `completion-cooldown`.
+     */
     retryAt?: number;
 };
 declare const relayErrorBrand: unique symbol;
@@ -134,7 +142,10 @@ declare class RelayError extends RequestError {
     readonly window: "tracker" | "quest" | undefined;
     /** Prerequisites the member does not currently meet, when Relay refused for that reason. */
     readonly missing: MissingPrerequisite[];
-    /** Unix milliseconds when the member may submit again, when `code` is `retry-cooldown`. */
+    /**
+     * Unix milliseconds when the member may submit again, when `code` is `retry-cooldown` or
+     * `completion-cooldown`.
+     */
     readonly retryAt: number | undefined;
     constructor(message: string, details: RelayErrorDetails);
 }
@@ -412,7 +423,48 @@ declare function relayClient(options: RelayClientOptions): {
             } | {
                 kind: "paused";
             };
+            missing: ({
+                kind: "completion";
+                quest: string;
+                title: string;
+                scope: "ever";
+            } | {
+                kind: "completion";
+                quest: string;
+                title: string;
+                scope: "period";
+                period: "day" | "week" | "month";
+                resetsAt: number;
+            } | {
+                kind: "balance";
+                balance: string;
+                title: string;
+                minimum: number;
+                current: number;
+            } | {
+                kind: "group";
+                group: string;
+                title: string;
+            })[];
             key?: string | undefined;
+            requires?: ({
+                kind: "completion";
+                quest: string;
+                scope: "ever";
+            } | {
+                kind: "completion";
+                quest: string;
+                scope: "period";
+                period: "day" | "week" | "month";
+            } | {
+                kind: "balance";
+                balance: string;
+                minimum: number;
+            } | {
+                kind: "group";
+                group: string;
+                title: string;
+            })[] | undefined;
         }[]>;
         /** Redeems one offer. Persist `actionId` to retry after an uncertain result. */
         redeem: (offer: string, value?: {
@@ -1217,6 +1269,15 @@ declare function relayClient(options: RelayClientOptions): {
                         amount: number;
                     })[];
                 }[];
+                pool?: {
+                    amount: string;
+                    unit: "points" | {
+                        code: string;
+                        decimals: number;
+                    };
+                    ledger?: string | undefined;
+                    minScore?: number | undefined;
+                } | undefined;
             } | undefined;
         }[]>;
         standings: (board: string, query?: LeaderboardQuery, requestOptions?: RelayRequestOptions) => Promise<{
@@ -1364,6 +1425,7 @@ declare function relayClient(options: RelayClientOptions): {
             options: {
                 provider: "discord" | "google" | "x";
                 name: string | null;
+                givenName: string | null;
                 imageUrl: string | null;
             }[];
         }>;
@@ -1398,6 +1460,7 @@ declare function relayClient(options: RelayClientOptions): {
             options: {
                 provider: "discord" | "google" | "x";
                 name: string | null;
+                givenName: string | null;
                 imageUrl: string | null;
             }[];
         }>;
@@ -1434,6 +1497,7 @@ declare function relayClient(options: RelayClientOptions): {
             options: {
                 provider: "discord" | "google" | "x";
                 name: string | null;
+                givenName: string | null;
                 imageUrl: string | null;
             }[];
         }>;
@@ -1899,6 +1963,7 @@ declare function relayClient(options: RelayClientOptions): {
                 } | null;
             } | null | undefined;
             retryAt?: number | undefined;
+            nextAvailableAt?: number | undefined;
         }>;
         /**
          * Enrolls the signed-in member in a quest whose tracker trigger requires enrollment. Activity
@@ -2586,6 +2651,7 @@ declare function relayClient(options: RelayClientOptions): {
                     } | null;
                 } | null | undefined;
                 retryAt?: number | undefined;
+                nextAvailableAt?: number | undefined;
             }[];
             collections: {
                 id: string;
@@ -2999,6 +3065,7 @@ declare function relayClient(options: RelayClientOptions): {
                         } | null;
                     } | null | undefined;
                     retryAt?: number | undefined;
+                    nextAvailableAt?: number | undefined;
                 }[];
                 key?: string | undefined;
                 description?: string | undefined;
@@ -3418,6 +3485,7 @@ declare function relayClient(options: RelayClientOptions): {
                     } | null;
                 } | null | undefined;
                 retryAt?: number | undefined;
+                nextAvailableAt?: number | undefined;
             }[];
             key?: string | undefined;
             description?: string | undefined;
@@ -3640,6 +3708,40 @@ declare function relayClient(options: RelayClientOptions): {
                 }>;
             };
         };
+        /**
+         * The member's creator accounts: the platform accounts they publish from, such as a YouTube
+         * channel, which managed tracker sources read. A creator account is linked only to a
+         * signed-in member, never used to sign in, and linking another one on the same platform
+         * replaces it.
+         */
+        creatorAccounts: {
+            /** One entry per creator-account provider the platform configured. */
+            list: (requestOptions?: RelayRequestOptions) => Promise<{
+                accounts: {
+                    provider: CreatorAccountProvider;
+                    configured: boolean;
+                    status: "disconnected" | "connected" | "reconnect";
+                    subject: string | null;
+                    revision: number;
+                    profile: {
+                        name?: string | undefined;
+                        username?: string | undefined;
+                        imageUrl?: string | undefined;
+                    } | null;
+                }[];
+            }>;
+            /**
+             * Leaves for the provider's consent screen to link an account to the signed-in member.
+             * Answers the URL to open; the browser comes back to the app linked.
+             */
+            connect: (provider: CreatorAccountProvider, requestOptions?: RelayRequestOptions) => Promise<{
+                url: string;
+            }>;
+            /** Unlinks the member's account on `provider`. Records it authored stay. */
+            disconnect: (provider: CreatorAccountProvider, requestOptions?: RelayRequestOptions) => Promise<{
+                ok: boolean;
+            }>;
+        };
         /** The member's connected sign-in accounts, one per provider. */
         accounts: (requestOptions?: RelayRequestOptions) => Promise<{
             provider: "discord" | "google" | "apple" | "x";
@@ -4224,6 +4326,7 @@ declare function relayClient(options: RelayClientOptions): {
                     } | null;
                 } | null | undefined;
                 retryAt?: number | undefined;
+                nextAvailableAt?: number | undefined;
             }[];
             entitlements: ({
                 [x: string]: unknown;