@domino-sdk/relay 1.60.0 → 1.62.0

package/dist/sign-in-providers-BkjcDsFF.d.ts

@@ -0,0 +1,39 @@
+import { J as SignInProvider } from './accounts-CCqCKCVx.js';
+import * as z from 'zod';
+import { a as TelegramSignInMethods } from './submission-input-DHGKhXfp.js';
+
+declare const authProvidersSchema: z.ZodObject<{
+    providers: z.ZodArray<z.ZodObject<{
+        provider: z.ZodEnum<{
+            discord: "discord";
+            google: "google";
+            apple: "apple";
+            x: "x";
+        }>;
+        configured: z.ZodBoolean;
+    }, z.core.$strip>>;
+    email: z.ZodBoolean;
+    wallets: z.ZodPipe<z.ZodArray<z.ZodEnum<{
+        solana: "solana";
+        eip155: "eip155";
+        cosmos: "cosmos";
+    }>>, z.ZodTransform<("solana" | "eip155" | "cosmos")[], ("solana" | "eip155" | "cosmos")[]>>;
+    demo: z.ZodBoolean;
+    telegram: z.ZodOptional<z.ZodObject<{
+        login: z.ZodBoolean;
+        miniApp: z.ZodBoolean;
+    }, z.core.$strip>>;
+    signInProviders: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        provider: z.ZodType<SignInProvider, unknown, z.core.$ZodTypeInternals<SignInProvider, unknown>>;
+        configured: z.ZodBoolean;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * What `relay.auth.providers()` answers: `authProvidersSchema`'s shape, with `telegram` typed as
+ * `TelegramSignInMethods` so the deprecation on `telegram.login` reaches apps.
+ */
+type AuthProviders = Omit<z.infer<typeof authProvidersSchema>, "telegram"> & {
+    telegram?: TelegramSignInMethods;
+};
+
+export { type AuthProviders as A, authProvidersSchema as a };

package/dist/submission-input-DHGKhXfp.d.ts

@@ -0,0 +1,342 @@
+import * as z from 'zod';
+import { L as LedgerReference, Q as QuestHandle } from './tracker-data-Hb1uQnk5.js';
+import { B as ProjectGroupReference } from './accounts-CCqCKCVx.js';
+
+declare const completionPrerequisiteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"completion">;
+    quest: z.ZodString;
+    scope: z.ZodLiteral<"ever">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"completion">;
+    quest: z.ZodString;
+    scope: z.ZodLiteral<"period">;
+    period: z.ZodEnum<{
+        day: "day";
+        week: "week";
+        month: "month";
+    }>;
+}, z.core.$strict>], "scope">;
+declare const balancePrerequisiteSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"balance">;
+    balance: z.ZodString;
+    minimum: z.ZodNumber;
+}, z.core.$strict>;
+declare const groupPrerequisiteSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"group">;
+    group: z.ZodString;
+    title: z.ZodString;
+}, z.core.$strict>;
+declare const prerequisiteSchema: z.ZodDiscriminatedUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"completion">;
+    quest: z.ZodString;
+    scope: z.ZodLiteral<"ever">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"completion">;
+    quest: z.ZodString;
+    scope: z.ZodLiteral<"period">;
+    period: z.ZodEnum<{
+        day: "day";
+        week: "week";
+        month: "month";
+    }>;
+}, z.core.$strict>], "scope">, z.ZodObject<{
+    kind: z.ZodLiteral<"balance">;
+    balance: z.ZodString;
+    minimum: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"group">;
+    group: z.ZodString;
+    title: z.ZodString;
+}, z.core.$strict>], "kind">;
+type Prerequisite = z.infer<typeof prerequisiteSchema>;
+declare const missingPrerequisiteSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"completion">;
+    quest: z.ZodString;
+    title: z.ZodString;
+    scope: z.ZodLiteral<"ever">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"completion">;
+    quest: z.ZodString;
+    title: z.ZodString;
+    scope: z.ZodLiteral<"period">;
+    period: z.ZodEnum<{
+        day: "day";
+        week: "week";
+        month: "month";
+    }>;
+    resetsAt: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"balance">;
+    balance: z.ZodString;
+    title: z.ZodString;
+    minimum: z.ZodNumber;
+    current: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"group">;
+    group: z.ZodString;
+    title: z.ZodString;
+}, z.core.$strip>]>;
+type MissingPrerequisite = z.infer<typeof missingPrerequisiteSchema>;
+declare function completed(quest: QuestHandle, options?: {
+    scope?: "ever";
+} | {
+    scope: "period";
+    period: "day" | "week" | "month";
+}): {
+    kind: "completion";
+    quest: string;
+    scope: "ever";
+} | {
+    kind: "completion";
+    quest: string;
+    scope: "period";
+    period: "day" | "week" | "month";
+};
+declare function balanceAtLeast(balance: LedgerReference, minimum: number): {
+    kind: "balance";
+    balance: string;
+    minimum: number;
+};
+declare function inGroup(group: ProjectGroupReference): {
+    kind: "group";
+    group: string;
+    title: string;
+};
+
+/**
+ * The Telegram sign-in a project offers, beside `providers` in `relay.auth.providers()`. Written
+ * out rather than inferred from `telegramSignInMethodsSchema`, because the built declarations drop
+ * a schema field's comments, and with them the deprecation on `login`.
+ */
+type TelegramSignInMethods = {
+    /**
+     * Telegram Login, the OpenID Connect sign-in Domino configures for the platform.
+     *
+     * @deprecated Read the `"telegram"` entry of `relay.auth.providers().signInProviders`, whose
+     * `configured` is the same. Removed in 2.0.0.
+     */
+    login: boolean;
+    /** Mini App sign-in, which the project enables in Console with its bot's ID. */
+    miniApp: boolean;
+};
+/**
+ * `TelegramSignInMethods` as Relay sends it. `satisfies` catches a field the type has and the
+ * schema lacks, not the reverse: add a field to both.
+ *
+ * @compat output
+ */
+declare const telegramSignInMethodsSchema: z.ZodObject<{
+    login: z.ZodBoolean;
+    miniApp: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * 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>;
+    canPost: z.ZodOptional<z.ZodBoolean>;
+    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>;
+        canPost: z.ZodOptional<z.ZodBoolean>;
+        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>;
+/** `ctx.telegram.connection()`: the member's linked account, as the attempt pinned it. */
+declare const telegramConnectionInputSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"connection">;
+}, z.core.$strict>;
+/**
+ * The member's linked Telegram account, as `ctx.telegram.connection()` reads it. A vouched or
+ * imported account counts like one the member proved.
+ *
+ * @compat output
+ */
+declare const telegramConnectionSchema: z.ZodObject<{
+    userId: z.ZodString;
+}, z.core.$strip>;
+type TelegramConnection = z.infer<typeof telegramConnectionSchema>;
+/** 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 the member's linked Telegram account, and a chat the project connected for it. The account
+ * is pinned at the attempt's first Telegram call, so later links and unlinks do not change the
+ * attempt; each `member()` 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's linked Telegram account; null when they have not linked one. It asks neither
+     * Telegram nor Domino's bot, so it needs no connected chat and no configured bot. Relay supplies
+     * it to every evaluation; it is optional only so that test doubles written before it keep
+     * compiling.
+     */
+    connection?(): Promise<TelegramConnection | null>;
+    /** The member in `chat`; null when they are not in it or have not linked Telegram. */
+    member(input: {
+        chat: string;
+    }): Promise<TelegramChatMember | null>;
+}
+
+/**
+ * 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>;
+
+/**
+ * One message a Telegram user posted in a connected group, as a `telegram.messages()` record's
+ * `data`. It names the message and never holds its text. Every field is a scalar, so a trigger's
+ * `where` can select on it.
+ *
+ * @compat output
+ */
+declare const telegramMessageDataSchema: z.ZodObject<{
+    chatId: z.ZodString;
+    chatType: z.ZodString;
+    messageId: z.ZodNumber;
+    replyToMessageId: z.ZodNullable<z.ZodNumber>;
+    threadId: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+type TelegramMessageData = z.infer<typeof telegramMessageDataSchema>;
+
+declare const textOptionsSchema: z.ZodObject<{
+    required: z.ZodDefault<z.ZodBoolean>;
+    minLength: z.ZodDefault<z.ZodNumber>;
+    maxLength: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+declare const urlOptionsSchema: z.ZodObject<{
+    required: z.ZodDefault<z.ZodBoolean>;
+    allowedHosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+type TextOptions = z.input<typeof textOptionsSchema>;
+type UrlOptions = z.input<typeof urlOptionsSchema>;
+declare const textEvidenceSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"text">;
+    value: z.ZodString;
+}, z.core.$strict>;
+declare const urlEvidenceSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"url">;
+    value: z.ZodString;
+}, z.core.$strict>;
+declare const valueEvidenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"text">;
+    value: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"url">;
+    value: z.ZodString;
+}, z.core.$strict>], "kind">;
+type TextEvidence = z.infer<typeof textEvidenceSchema>;
+type UrlEvidence = z.infer<typeof urlEvidenceSchema>;
+type ValueEvidence = z.infer<typeof valueEvidenceSchema>;
+/** Validates a claim without fetching it or changing the captured value. */
+declare function validateSubmissionValue(input: ValueEvidence, contract: {
+    input: "text";
+    constraints: z.output<typeof textOptionsSchema>;
+} | {
+    input: "url";
+    constraints: z.output<typeof urlOptionsSchema>;
+}): string | null;
+/** Extract an ID only. The URL and its author name are untrusted claims. */
+declare function xPostId(value: string): string | null;
+
+export { telegramChatsSchema as A, telegramConnectionInputSchema as B, telegramConnectionSchema as C, telegramInitDataSchema as D, telegramMemberInputSchema as E, telegramMessageDataSchema as F, telegramMiniAppSignInSchema as G, telegramReactionDataSchema as H, telegramSignInMethodsSchema as I, textEvidenceSchema as J, textOptionsSchema as K, urlEvidenceSchema as L, type MissingPrerequisite as M, urlOptionsSchema as N, validateSubmissionValue as O, type Prerequisite as P, valueEvidenceSchema as Q, xPostId as R, type TelegramAccountConnection as T, type UrlEvidence as U, type ValueEvidence as V, type TelegramSignInMethods as a, type TextEvidence as b, type TextOptions as c, type UrlOptions as d, type TelegramReader as e, type TelegramChatMember as f, type TelegramChatMemberStatus as g, type TelegramConnection as h, type TelegramMessageData as i, type TelegramReactionData as j, balanceAtLeast as k, completed as l, inGroup as m, type TelegramChat as n, type TelegramChatConnection as o, type TelegramChats as p, balancePrerequisiteSchema as q, completionPrerequisiteSchema as r, groupPrerequisiteSchema as s, missingPrerequisiteSchema as t, prerequisiteSchema as u, telegramAccountConnectionSchema as v, telegramChatConnectionSchema as w, telegramChatIdSchema as x, telegramChatMemberSchema as y, telegramChatSchema as z };

package/dist/{telegram-browser-CTJh4Ro_.d.ts → telegram-browser-BCE7zdOb.d.ts}

@@ -1,7 +1,8 @@
-import { a as AuthProvider, b as TelegramSignInMethods } from './accounts-DoabriBX.js';
-import { p as createRelayClient, k as RelayRequestOptions, g as RelayError } from './client-Cw1pB5sv.js';
-import { b as ParticipantSession } from './participant-activity-DHL8QYks.js';
-import { C as CosmosChain, a as CosmosNetwork, m as WalletSigner, k as WalletSignInNetwork } from './wallet-DZWL7lJH.js';
+import { c as AuthProvider, J as SignInProvider } from './accounts-CCqCKCVx.js';
+import { p as createRelayClient, k as RelayRequestOptions, g as RelayError } from './client-B-hbHX30.js';
+import { a as TelegramSignInMethods } from './submission-input-DHGKhXfp.js';
+import { b as ParticipantSession } from './participant-activity-D-Drp24G.js';
+import { C as CosmosChain, a as CosmosNetwork, m as WalletSigner, k as WalletSignInNetwork } from './wallet-DTO7SXj7.js';
 
 /** An EIP-1193 provider, such as `window.ethereum` or an EIP-6963 announcement's provider. */
 type Eip1193Provider = {
@@ -9,6 +10,9 @@ type Eip1193Provider = {
         method: string;
         params?: unknown[] | object;
     }): Promise<unknown>;
+    /** Subscribes to a provider event such as `accountsChanged`; wallets without events leave it out. */
+    on?(event: string, listener: (...args: unknown[]) => void): unknown;
+    removeListener?(event: string, listener: (...args: unknown[]) => void): unknown;
 };
 /** The legacy injected Solana shape Phantom, Solflare and Backpack expose. */
 type SolanaInjectedProvider = {
@@ -115,7 +119,10 @@ type SignInClient = {
         }>;
         emailVerify: (challenge: string, code: string, requestOptions?: RelayRequestOptions) => Promise<ParticipantSession>;
         wallet: Pick<Auth["wallet"], "signIn">;
-        /** Telegram Login; without it, `signInOptions()` offers no Telegram option. */
+        /**
+         * Telegram Login; without it, `signInOptions()` offers no `telegram` option. Its
+         * `signInProviders` start every provider, Telegram included, with `start`.
+         */
         telegram?: {
             start: (mode: "sign-in" | "connect", requestOptions?: RelayRequestOptions) => Promise<{
                 url: string;
@@ -126,6 +133,13 @@ type SignInClient = {
 /** The sign-in methods a project takes: the platform's OAuth providers and email, and its wallet families. */
 type SignInMethods = {
     providers: AuthProvider[];
+    /**
+     * Every sign-in provider Domino configured for the platform, Telegram included: the open
+     * sibling of `providers`. A newer Relay may name providers this SDK does not know. Absent when
+     * the methods could not be read or Relay predates the list; `signInOptionsFrom` then reads
+     * `providers` and `telegram`.
+     */
+    signInProviders?: SignInProvider[];
     email: boolean;
     /** The wallet families this project enabled for sign-in in Console. */
     wallets: WalletSignInNetwork[];
@@ -178,9 +192,27 @@ type WalletSignInOption = {
     /** Asks the wallet to sign a message, then signs in, or signs up. See `SignInOption` for failures. */
     start(): Promise<void>;
 };
+/**
+ * One sign-in provider the platform configured, Telegram included: the open sibling of
+ * `OAuthSignInOption`, whose `id` SDK 1.x keeps to `AuthProvider`. A newer Relay may name a
+ * provider this SDK does not know; its `label` is then the provider's name as Relay sends it.
+ */
+type ProviderSignInOption = {
+    kind: "provider";
+    /** The provider, such as `"google"` or `"telegram"`. */
+    id: SignInProvider;
+    /** The provider's name, such as "Google" or "Telegram". */
+    label: string;
+    icon: SignInProvider;
+    /** Leaves the page for the provider's consent screen. See `SignInOption` for failures. */
+    start(): Promise<void>;
+};
 /**
  * Telegram Login. It is not one of `options` in SDK 1.x, whose `OAuthSignInOption` names only
  * `AuthProvider`s: `SignInOptions.telegram` carries it, so render it beside them.
+ *
+ * @deprecated Use the `"telegram"` entry of `signInProviders`, a `ProviderSignInOption`. Removed
+ * in 2.0.0.
  */
 type TelegramSignInOption = {
     kind: "telegram";
@@ -214,10 +246,18 @@ type SignInUnavailable = {
 type SignInOptions = {
     /** OAuth providers first, then installed wallets, then email. */
     options: SignInOption[];
+    /**
+     * Every sign-in provider the platform configured, Telegram included, in Relay's order: render
+     * these in place of the `oauth` entries of `options`, which SDK 1.x keeps to `AuthProvider`.
+     * Absent when the actions offer no `provider` action.
+     */
+    signInProviders?: ProviderSignInOption[];
     unavailable: SignInUnavailable[];
     /**
      * Telegram Login when the platform configured it, to render beside `options`. Mini App sign-in
      * needs no button: call `relay.auth.telegram.miniApp.signIn()` inside the Mini App.
+     *
+     * @deprecated Use the `"telegram"` entry of `signInProviders`. Removed in 2.0.0.
      */
     telegram?: TelegramSignInOption;
     /** Why the project's methods could not be read; the options are then email alone. */
@@ -240,7 +280,10 @@ declare function signInOptions(relay: SignInClient, input?: {
  * `Telegram.WebApp.initData` when the app loaded telegram-web-app.js, else the `tgWebAppData`
  * launch parameter Telegram puts in the page's URL fragment. Pass it to
  * `relay.auth.telegram.miniApp.signIn()`. Safe to call during server rendering, where it is null.
+ *
+ * @deprecated Import `telegramMiniAppInitData` from `@domino-sdk/relay/telegram`, and sign in with
+ * `withTelegram(relay).telegram.miniApp.signIn()`. Removed in 2.0.0.
  */
 declare function telegramMiniAppInitData(): string | null;
 
-export { type CosmosChains as C, type DiscoveredWallet as D, type Eip1193Provider as E, type KeplrLike as K, type OAuthSignInOption as O, type SignInClient as S, type TelegramSignInOption as T, type WalletSignInOption as W, type EmailSignInOption as a, type SignInIcon as b, type SignInMethods as c, type SignInOption as d, type SignInOptions as e, type SignInUnavailable as f, type SignInWallet as g, type SolanaInjectedProvider as h, type StandardWallet as i, type StandardWalletAccount as j, cosmosChainList as k, cosmosSigner as l, discoverCosmosWallets as m, discoverEvmWallets as n, discoverSignInWallets as o, discoverSolanaWallets as p, evmSigner as q, solanaSigner as r, signInOptions as s, telegramMiniAppInitData as t, walletStandardSolanaSigner as w };
+export { type CosmosChains as C, type DiscoveredWallet as D, type Eip1193Provider as E, type KeplrLike as K, type OAuthSignInOption as O, type ProviderSignInOption as P, type SignInClient as S, type TelegramSignInOption as T, type WalletSignInOption as W, type EmailSignInOption as a, type SignInIcon as b, type SignInMethods as c, type SignInOption as d, type SignInOptions as e, type SignInUnavailable as f, type SignInWallet as g, type SolanaInjectedProvider as h, type StandardWallet as i, type StandardWalletAccount as j, cosmosChainList as k, cosmosSigner as l, discoverCosmosWallets as m, discoverEvmWallets as n, discoverSignInWallets as o, discoverSolanaWallets as p, evmSigner as q, solanaSigner as r, signInOptions as s, telegramMiniAppInitData as t, walletStandardSolanaSigner as w };

package/dist/telegram.d.ts

@@ -0,0 +1,64 @@
+import { k as RelayRequestOptions, R as RelayClient } from './client-B-hbHX30.js';
+import { b as ParticipantSession } from './participant-activity-D-Drp24G.js';
+import './accounts-CCqCKCVx.js';
+import 'zod';
+import './tracker-data-Hb1uQnk5.js';
+import './wallet-DTO7SXj7.js';
+import './pages-B8q8Y_dQ.js';
+import './submission-input-DHGKhXfp.js';
+import './request-error-D_dUPLwo.js';
+import './catalog--ZIlskAo.js';
+import './action-9Xl0StBg.js';
+import './sign-in-providers-BkjcDsFF.js';
+
+/**
+ * A plugin's own sign-in method, such as Telegram's Mini App sign-in: the app passes the vendor's
+ * signed proof.
+ *
+ * @experimental
+ */
+type PluginSignInMethod = {
+    /** Signs in, or signs up, as the account the proof names. */
+    signIn(proof: string, requestOptions?: RelayRequestOptions): Promise<ParticipantSession>;
+    /** Links the account the proof names to the signed-in member. */
+    connect(proof: string, requestOptions?: RelayRequestOptions): Promise<{
+        ok: boolean;
+    }>;
+};
+
+/**
+ * What only the Telegram plugin does, as `relay.telegram` (docs/adr/0024-plugins.md). What every
+ * sign-in provider does, Telegram's included, is on `relay.auth`.
+ *
+ * @experimental
+ */
+type TelegramClient = {
+    /**
+     * Sign-in inside a Telegram Mini App, where the project named its bot in Console
+     * (`relay.auth.providers().telegram.miniApp`). Pass the Mini App's signed launch data,
+     * `telegramMiniAppInitData()`. Relay checks Telegram's signature for the project's bot and
+     * accepts launch data at most five minutes old, once.
+     */
+    readonly miniApp: PluginSignInMethod;
+};
+/**
+ * Adds `relay.telegram` to a client that `createRelayClient` or `createBrowserRelayClient` made,
+ * and answers the same client.
+ *
+ * @experimental
+ */
+declare function withTelegram<Client extends RelayClient>(relay: Client): Client & {
+    readonly telegram: TelegramClient;
+};
+
+/**
+ * The signed launch data of the Telegram Mini App this page runs in, or null outside one: Telegram's
+ * `Telegram.WebApp.initData` when the app loaded telegram-web-app.js, else the `tgWebAppData`
+ * launch parameter Telegram puts in the page's URL fragment. Pass it to
+ * `relay.telegram.miniApp.signIn()`. Safe to call during server rendering, where it is null.
+ *
+ * @experimental
+ */
+declare function telegramMiniAppInitData(): string | null;
+
+export { type PluginSignInMethod, type TelegramClient, telegramMiniAppInitData, withTelegram };

package/dist/telegram.js

@@ -0,0 +1,23 @@
+import {
+  miniAppInitData
+} from "./chunk-FWLQ5XCS.js";
+import {
+  withPluginNamespace
+} from "./chunk-6WCIWXUV.js";
+import "./chunk-K2KS3JLY.js";
+
+// src/plugins/telegram.generated.ts
+function withTelegram(relay) {
+  return withPluginNamespace(relay, "telegram", (transport) => ({
+    miniApp: transport.signInMethod("/v1/auth/telegram/mini-app", "initData")
+  }));
+}
+
+// src/plugins/telegram.ts
+function telegramMiniAppInitData() {
+  return miniAppInitData();
+}
+export {
+  telegramMiniAppInitData,
+  withTelegram
+};