@domino-sdk/relay 1.0.0-next.2 → 1.0.0-next.34

package/dist/streaks-CWyq8Px5.d.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+
+declare const quizChoiceSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+}, z.core.$strict>;
+declare const quizQuestionSchema: z.ZodObject<{
+    id: z.ZodString;
+    prompt: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const quizQuestionsSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    prompt: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+declare const quizContentSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    prompt: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strict>>;
+    correct: z.ZodString;
+}, z.core.$strict>>;
+type QuizContent = z.infer<typeof quizContentSchema>;
+
+declare const streakPolicySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"streak">;
+    days: z.ZodNumber;
+}, z.core.$strip>;
+type StreakPolicy = z.infer<typeof streakPolicySchema>;
+declare const streakProgressSchema: z.ZodObject<{
+    goal: z.ZodNumber;
+    current: z.ZodNumber;
+    best: z.ZodNumber;
+    today: z.ZodString;
+    todayQualified: z.ZodBoolean;
+    timeZone: z.ZodString;
+    nextBoundary: z.ZodNumber;
+    pendingTimeZone: z.ZodNullable<z.ZodObject<{
+        timeZone: z.ZodString;
+        effectiveAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    days: z.ZodArray<z.ZodObject<{
+        day: z.ZodNumber;
+        date: z.ZodString;
+        timeZone: z.ZodString;
+        occurredAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    milestone: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"pending">;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"awarded">;
+        completion: z.ZodString;
+        achievedAt: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"budget-exhausted">;
+        budget: z.ZodString;
+        achievedAt: z.ZodNumber;
+    }, z.core.$strip>], "status">;
+}, z.core.$strip>;
+type StreakProgress = z.infer<typeof streakProgressSchema>;
+
+export { type QuizContent as Q, type StreakProgress as S, type StreakPolicy as a, quizContentSchema as b, quizQuestionSchema as c, quizQuestionsSchema as d, streakProgressSchema as e, quizChoiceSchema as q, streakPolicySchema as s };

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

@@ -0,0 +1,290 @@
+import { z } from 'zod';
+import { cH as LedgerReference, cG as QuestHandle } from './schema-DfJzH2ci.js';
+import { p as ProjectGroupReference } from './groups-Ck-OxzjD.js';
+
+/** 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>]>;
+
+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;
+};
+
+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>;
+}
+
+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 { type AccountConnection as A, inGroup as B, missingPrerequisiteSchema as C, type DiscordMember as D, prerequisiteSchema as E, textEvidenceSchema as F, textOptionsSchema as G, urlEvidenceSchema as H, urlOptionsSchema as I, validateSubmissionValue as J, valueEvidenceSchema as K, xPostId as L, type MissingPrerequisite as M, type Prerequisite as P, type TextEvidence as T, type UrlEvidence as U, type ValueEvidence as V, type AuthProvider as a, type TextOptions as b, type UrlOptions as c, type DiscordMessage as d, type DiscordMessageData as e, type DiscordMessageTextData as f, type DiscordReactionData as g, type DiscordReader as h, accountConnectionSchema as i, authProviderSchema as j, balanceAtLeast as k, balancePrerequisiteSchema as l, completed as m, completionPrerequisiteSchema as n, discordMemberInputSchema as o, discordMemberSchema as p, discordMessageDataSchema as q, discordMessageInputSchema as r, discordMessageSchema as s, discordMessageTextDataSchema as t, discordMessagesSourceSchema as u, discordReactionDataSchema as v, discordReactionsSourceSchema as w, discordResourceSourceSchema as x, discordRewardSchema as y, groupPrerequisiteSchema as z };

package/dist/units-CwgsPB_r.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A decimal amount in whole tokens as raw integer units: `parseUnits("1.5", 6)` is `1500000n`.
+ * Rejects negative amounts, exponents and more fraction digits than the token has.
+ */
+declare function parseUnits(value: string, decimals: number): bigint;
+/** Raw integer units as a decimal amount in whole tokens: `formatUnits("1500000", 6)` is `"1.5"`. */
+declare function formatUnits(amount: string | bigint, decimals: number): string;
+
+export { formatUnits as f, parseUnits as p };

package/dist/vite.d.ts

@@ -10,7 +10,7 @@ type ResolveContext = {
 };
 /**
  * Fails the build when browser code imports server-only code: the management
- * client (`@domino-sdk/relay-cli`), the participant proxy, or anything under
+ * client (`@domino-sdk/relay/server`), the CLI, the participant proxy, or anything under
  * the app's `server/` directory. Management credentials and app secrets live
  * in the Worker; this keeps them from ever reaching a browser bundle.
  *

package/dist/vite.js

@@ -1,5 +1,6 @@
 // src/vite.ts
 var SERVER_ONLY = [
+  /^@domino-sdk\/relay\/server$/,
   /^@domino-sdk\/relay-cli(?:\/|$)/,
   /^@domino-sdk\/relay\/portal-proxy$/
 ];

package/dist/wallet-YssWxGg8.d.ts

@@ -0,0 +1,228 @@
+import { z } from 'zod';
+
+declare const solanaAddressSchema: z.ZodString;
+/** A wallet's chain family: its CAIP-2 namespace. */
+declare const walletChainSchema: z.ZodEnum<{
+    solana: "solana";
+    eip155: "eip155";
+    cosmos: "cosmos";
+}>;
+type WalletChain = z.infer<typeof walletChainSchema>;
+/**
+ * A Cosmos SDK chain's CAIP-2 ID: `cosmos:` and the chain ID, such as `cosmos:cosmoshub-4`. Relay
+ * accepts any chain ID in CAIP-2 reference syntax; the app decides which chains it works with.
+ */
+type CosmosNetwork = `cosmos:${string}`;
+declare const cosmosNetworkSchema: z.ZodCustom<`cosmos:${string}`, `cosmos:${string}`>;
+/** A Cosmos SDK bank denomination: 3–128 characters in the SDK's canonical denom syntax. */
+type CosmosDenom = string;
+declare const cosmosDenomSchema: z.ZodString;
+/**
+ * A Cosmos SDK chain an app works with. Pass `chainInfo` (Keplr's `ChainInfo` shape) for a chain
+ * wallets may not know: the adapters suggest it to the wallet (`experimentalSuggestChain`).
+ */
+type CosmosChain = {
+    /** The chain ID, such as `"cosmoshub-4"`. */
+    chainId: string;
+    chainInfo?: {
+        chainId: string;
+    } & Record<string, unknown>;
+};
+/** Reads the chain an app passes, a `CosmosChain` or its CAIP-2 ID, and adds the CAIP-2 ID. */
+declare function cosmosChain(chain: CosmosChain | CosmosNetwork): CosmosChain & {
+    network: CosmosNetwork;
+};
+/** The CAIP-2 ID of Solana mainnet (its genesis hash, truncated to 32 characters). */
+declare const solanaMainnet = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+declare const evmAddressSchema: z.ZodString;
+/** Bech32 with any prefix, in one case. The server checks the checksum and stores lowercase. */
+declare const cosmosAddressSchema: z.ZodString;
+/** What the wallet says its address is. The server checks the format and canonicalises it (EIP-55, lowercase bech32). */
+declare const walletAddressInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    chain: z.ZodLiteral<"solana">;
+    address: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    chain: z.ZodLiteral<"eip155">;
+    address: z.ZodString;
+    chainId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    chain: z.ZodLiteral<"cosmos">;
+    network: z.ZodCustom<`cosmos:${string}`, `cosmos:${string}`>;
+    address: z.ZodString;
+}, z.core.$strict>], "chain">;
+type WalletAddressInput = z.input<typeof walletAddressInputSchema>;
+/** Not strict: newer servers may add fields. */
+declare const walletMessageChallengeSchema: z.ZodObject<{
+    id: z.ZodString;
+    purpose: z.ZodEnum<{
+        link: "link";
+        "sign-in": "sign-in";
+    }>;
+    chain: z.ZodEnum<{
+        solana: "solana";
+        eip155: "eip155";
+        cosmos: "cosmos";
+    }>;
+    network: z.ZodNullable<z.ZodCustom<`cosmos:${string}`, `cosmos:${string}`>>;
+    address: z.ZodString;
+    message: z.ZodString;
+    expiresAt: z.ZodNumber;
+}, z.core.$strip>;
+type WalletMessageChallenge = z.infer<typeof walletMessageChallengeSchema>;
+declare const walletSignatureSchema: z.ZodObject<{
+    challenge: z.ZodString;
+    signature: z.ZodString;
+    publicKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type WalletSignature = z.infer<typeof walletSignatureSchema>;
+declare const linkedWalletSchema: z.ZodObject<{
+    chain: z.ZodEnum<{
+        solana: "solana";
+        eip155: "eip155";
+        cosmos: "cosmos";
+    }>;
+    network: z.ZodNullable<z.ZodCustom<`cosmos:${string}`, `cosmos:${string}`>>;
+    address: z.ZodString;
+    verifiedAt: z.ZodNumber;
+    revision: z.ZodNumber;
+    signIn: z.ZodBoolean;
+}, z.core.$strip>;
+type LinkedWallet = z.infer<typeof linkedWalletSchema>;
+declare const walletUnlinkInputSchema: z.ZodObject<{
+    chain: z.ZodEnum<{
+        solana: "solana";
+        eip155: "eip155";
+        cosmos: "cosmos";
+    }>;
+    address: z.ZodString;
+}, z.core.$strict>;
+type WalletUnlinkInput = z.infer<typeof walletUnlinkInputSchema>;
+/**
+ * A wallet that can prove control of an address. `@domino-sdk/relay/browser` has adapters for
+ * injected EVM, Solana and Keplr-style wallets; tests and servers can implement it directly.
+ */
+type WalletSigner = {
+    readonly chain: WalletChain;
+    /** Required when `chain` is `"cosmos"`: the app's chain, `cosmos:<chain ID>`. */
+    readonly network?: CosmosNetwork;
+    /** For UI, such as "Phantom". */
+    readonly name?: string;
+    /** Connect if needed and return the address to challenge. */
+    address(): Promise<string>;
+    /** EVM only: the wallet's current chain, shown in the message's Chain ID line. */
+    chainId?(): Promise<number>;
+    /** Sign the exact UTF-8 message and return the encoding `walletSignatureSchema` documents. */
+    sign(message: string, address: string): Promise<{
+        signature: string;
+        publicKey?: string;
+    }>;
+};
+/** Builds the challenge input for a signer's address. */
+declare function walletAddressInput(signer: WalletSigner): Promise<WalletAddressInput>;
+/**
+ * The most wallets of one chain family a member can have linked to one project at a time. Sign-in
+ * wallets do not count: signing in always links the wallet.
+ */
+declare const WALLETS_PER_CHAIN = 5;
+/** The wallet families a project can enable for sign-in, in their stored order. */
+declare const walletSignInFamilies: readonly ["solana", "eip155", "cosmos"];
+/**
+ * What a project enables wallet sign-in for: a chain family. A Cosmos wallet signs in on any
+ * Cosmos SDK chain the app offers. Off unless the project enables it.
+ */
+declare const walletSignInNetworkSchema: z.ZodEnum<{
+    solana: "solana";
+    eip155: "eip155";
+    cosmos: "cosmos";
+}>;
+type WalletSignInNetwork = (typeof walletSignInFamilies)[number];
+/** Enabled wallet families, once each, in their stored order. */
+declare const walletSignInNetworksSchema: z.ZodPipe<z.ZodArray<z.ZodEnum<{
+    solana: "solana";
+    eip155: "eip155";
+    cosmos: "cosmos";
+}>>, z.ZodTransform<("solana" | "eip155" | "cosmos")[], ("solana" | "eip155" | "cosmos")[]>>;
+/** The sign-in setting a wallet account falls under: its chain family. */
+declare function walletSignInNetwork(wallet: Pick<LinkedWallet, "chain" | "network">): WalletSignInNetwork;
+/**
+ * The CAIP-10 account ID of a wallet on one network. Linked Solana and EVM wallets are
+ * chain-agnostic, so pass the network you mean; the defaults are Solana mainnet and Ethereum
+ * (`eip155:1`). A Cosmos wallet always uses the network it was linked on.
+ */
+declare function caip10(wallet: Pick<LinkedWallet, "chain" | "network" | "address">, network?: string): string;
+/** An EVM chain's CAIP-2 ID: `eip155:` and the chain ID in decimal, such as `"eip155:8453"` (Base). */
+type EvmChainId = `eip155:${number}`;
+/**
+ * Whether `value` is an EVM CAIP-2 ID in canonical form (no leading zeros, at most 16 digits).
+ * Syntax only: the chains Relay reads balances on are the platform's to list
+ * (`management.walletBalanceChains()`).
+ */
+declare function isEvmChainId(value: string): value is EvmChainId;
+/** {@link isEvmChainId} as a schema. */
+declare const evmChainIdSchema: z.ZodCustom<`eip155:${number}`, `eip155:${number}`>;
+/** What `ctx.wallet.balance()` reads. Omit `token` for a Solana or EVM native coin. */
+type WalletBalanceQuery = {
+    /** Solana mainnet: `"solana"` or its CAIP-2 ID. */
+    chain: "solana" | typeof solanaMainnet;
+    /** An SPL or Token-2022 mint address (base58). */
+    token?: string;
+    /** One of the member's linked Solana wallets; omit to read all of them. */
+    address?: string;
+} | {
+    /**
+     * An EVM chain's CAIP-2 ID, such as `"eip155:8453"` for Base. The platform reads the chains
+     * `management.walletBalanceChains()` lists, and fails the evaluation on any other.
+     */
+    chain: EvmChainId;
+    /** An ERC-20 contract address. */
+    token?: `0x${string}`;
+    /** One of the member's linked EVM wallets; omit to read all of them. */
+    address?: string;
+} | {
+    /** A Cosmos SDK chain's CAIP-2 ID. Relay reads the chains its management API lists. */
+    chain: CosmosNetwork;
+    /** The bank denomination to read, such as `uatom` or `uosmo`. */
+    token: CosmosDenom;
+    /** One of the member's wallets linked on this exact Cosmos network; omit to read all. */
+    address?: string;
+};
+/** A balance read for the member's pinned linked wallets, in raw integer units. */
+declare const walletBalanceSchema: z.ZodObject<{
+    chain: z.ZodString;
+    token: z.ZodNullable<z.ZodString>;
+    decimals: z.ZodNullable<z.ZodNumber>;
+    total: z.ZodString;
+    wallets: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        amount: z.ZodString;
+    }, z.core.$strict>>;
+    at: z.ZodObject<{
+        kind: z.ZodEnum<{
+            slot: "slot";
+            block: "block";
+        }>;
+        number: z.ZodString;
+    }, z.core.$strict>;
+    observedAt: z.ZodNumber;
+}, z.core.$strict>;
+type WalletBalance = z.infer<typeof walletBalanceSchema>;
+/**
+ * Reads the wallets the member has linked to this project. They are pinned once per attempt, at
+ * its first wallet read: later links and unlinks do not change the attempt. Every method resolves
+ * to `null` when the member has no linked wallet it can read, so a non-null list is never empty
+ * and a non-null balance covers at least one wallet. Provider failures throw `CapabilityError`
+ * with code `"provider-unavailable"`; they never read as a zero balance.
+ */
+interface WalletReader {
+    /** Every wallet the member has linked to this project, newest first within each chain. */
+    list(): Promise<LinkedWallet[] | null>;
+    /**
+     * The native or token balance of the member's linked wallets on one chain: all wallets of that
+     * family (or exact Cosmos network), or `address`. Null when the member has no linked wallet it
+     * can read. A chain Relay does not read, a malformed token, and an `address` the member never
+     * linked throw `CapabilityError` with code `"author-error"`.
+     */
+    balance(query: WalletBalanceQuery): Promise<WalletBalance | null>;
+}
+
+export { walletChainSchema as A, walletMessageChallengeSchema as B, type CosmosChain as C, walletSignInFamilies as D, type EvmChainId as E, walletSignInNetwork as F, walletSignInNetworkSchema as G, walletSignInNetworksSchema as H, walletSignatureSchema as I, walletUnlinkInputSchema as J, type LinkedWallet as L, type WalletAddressInput as W, type CosmosNetwork as a, type WalletChain as b, type WalletMessageChallenge as c, type WalletSignInNetwork as d, type WalletSignature as e, type WalletSigner as f, type WalletUnlinkInput as g, type CosmosDenom as h, WALLETS_PER_CHAIN as i, type WalletBalance as j, type WalletBalanceQuery as k, type WalletReader as l, caip10 as m, cosmosAddressSchema as n, cosmosChain as o, cosmosDenomSchema as p, cosmosNetworkSchema as q, evmAddressSchema as r, evmChainIdSchema as s, isEvmChainId as t, linkedWalletSchema as u, solanaAddressSchema as v, solanaMainnet as w, walletAddressInput as x, walletAddressInputSchema as y, walletBalanceSchema as z };