@domino-sdk/relay 1.0.0-next.13 → 1.0.0-next.14

package/dist/react/index.d.ts

@@ -1,19 +1,87 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { a6 as referralAcceptSchema, c as LeaderboardQuery, G as engagementPageQuerySchema, s as contentQualificationQuerySchema, i as contentAdmissionQuerySchema, k as contentEnrollmentInputSchema, u as contentReleaseInputSchema, af as referralSummarySchema, a as LeaderboardPage } from '../referrals-KQfP4pBf.js';
+import { a6 as referralAcceptSchema, c as LeaderboardQuery, G as engagementPageQuerySchema, s as contentQualificationQuerySchema, i as contentAdmissionQuerySchema, k as contentEnrollmentInputSchema, u as contentReleaseInputSchema, b as LeaderboardPlacement, af as referralSummarySchema, a as LeaderboardPage } from '../referrals-KQfP4pBf.js';
 import { ao as submitSchema, x as contentPerformanceQuerySchema, T as TieredRewardReference } from '../schema-BF_TQsmT.js';
-import { a as PageQuery, f as exchangeSchema } from '../pages-KYK1L60W.js';
+import { a as PageQuery, f as exchangeSchema, P as Page, c as ParticipantSession, M as MemberSummary } from '../pages-KYK1L60W.js';
 import { x as walletAddressInputSchema, M as walletSignatureSchema, L as LinkedWallet, f as WalletSigner, d as WalletSignInNetwork } from '../wallet-BtiG0Xhr.js';
-import { h as QuestView, J as questExperienceSchema, e as PointHistoryQuery, c as PointEntryKind, P as PointBalance, b as PointEntry, f as PointLedgerReference } from '../catalog-C85V1NgW.js';
-import { F as profileUpdateSchema, c as ProfileCompletionQuery, a as ProfileCompletion, e as ProfileSummary, f as ProfileUpdate } from '../profiles-BtOXMGcC.js';
+import { h as QuestView, J as questExperienceSchema, e as PointHistoryQuery, c as PointEntryKind, a as PointBalances, b as PointEntry, f as PointLedgerReference } from '../catalog-C85V1NgW.js';
+import { F as profileUpdateSchema, c as ProfileCompletionQuery, f as ProfileUpdate, e as ProfileSummary, a as ProfileCompletion, d as ProfileReferral } from '../profiles-BtOXMGcC.js';
 import * as zod from 'zod';
 import { z } from 'zod';
-import { k as RelayRequestOptions, c as QuestController, a as ProgressObservation, b as ProgressObserver, P as PhotoSubmission, e as QuizSubmission, C as ClaimSubmission, V as ValueSubmission, S as SubmissionDraft } from '../client-Bf9PNUIi.js';
+import { g as RelayError, k as RelayRequestOptions, c as QuestController, a as ProgressObservation, b as ProgressObserver, P as PhotoSubmission, e as QuizSubmission, C as ClaimSubmission, V as ValueSubmission, S as SubmissionDraft } from '../client-Bf9PNUIi.js';
 import { a as AuthProvider, A as AccountConnection } from '../submission-input-CccwAl5Z.js';
 import { createBrowserRelayClient, SignInMethods, CosmosChains, SignInOption, SignInUnavailable, SignInWallet, DiscoveredWallet } from '../browser.js';
 export { EmailSignInOption, OAuthSignInOption, SignInIcon, WalletSignInOption } from '../browser.js';
 import '../request-error-VnTiMXc3.js';
 
+/**
+ * A query's identity: plain JSON values, outermost group first, such as
+ * `["leaderboards", "weekly", 25]`. `invalidate(["leaderboards"])` matches every key that starts
+ * with those values.
+ */
+type QueryKey = readonly (string | number | boolean | null)[];
+/**
+ * What every read hook returns, besides `refresh`.
+ *
+ * - `loading`: nothing read yet for this participant.
+ * - `ready`: `data` is the last good value. `error` is set while the latest refresh failed and the
+ *   value on screen may be out of date; the next successful read clears it.
+ * - `error`: the first read failed, or the thing is gone (a 404).
+ * - `signed-out`: the hook needs a signed-in member and there is none.
+ */
+type QuerySnapshot<T> = {
+    status: "loading";
+    data: undefined;
+    error: null;
+} | {
+    status: "ready";
+    data: T;
+    error: RelayError | null;
+} | {
+    status: "error";
+    data: undefined;
+    error: RelayError;
+};
+type MemberSnapshot<T> = QuerySnapshot<T> | {
+    status: "signed-out";
+    data: undefined;
+    error: null;
+};
+/** What a query's read function receives: pass it on as the client method's last argument. */
+type QueryContext = {
+    /** Aborted when the read is superseded, invalidated, or the participant changes. */
+    signal: AbortSignal;
+    /** The session the cache belongs to. Relay refuses a read for another session (`stale-session`). */
+    session?: string;
+};
+type QueryRead<T> = (context: QueryContext) => Promise<T>;
+type QueryOptions = {
+    /** Read again this often while the page is visible. Polling pauses while the tab is hidden. */
+    intervalMs?: number;
+    /** Read again when the window regains focus. */
+    refetchOnFocus?: boolean;
+};
+
+type Collection = {
+    id: string;
+    /** The collection's authoring key, when it has one. */
+    key?: string;
+    title: string;
+    quests: QuestView[];
+};
+/** The participant's quests and collections, as `useExperience().data` holds them. */
+type ExperienceData = {
+    quests: QuestView[];
+    collections: Collection[];
+};
+/**
+ * Everything to list, in display order: collections as Console arranged them,
+ * then any quest nobody has placed yet, sorted by `order`: authoring keys
+ * (the `key` in quests/*.quest.ts), or quest IDs for quests without one.
+ * Archived quests are left out.
+ */
+declare function questGroups(experience: ExperienceData, order?: string[]): Collection[];
+
 type RelayClient = ReturnType<typeof createBrowserRelayClient>;
 /** The participant client, for calls no hook covers. */
 declare function useRelay(): {
@@ -2437,10 +2505,12 @@ declare function useRelay(): {
 };
 
 /**
- * One participant client and one quest observer for the whole app.
+ * One participant client, one quest observer and one query cache for the whole app.
  *
- * `baseUrl` defaults to `/relay`, the participant proxy that `domino dev` and
- * Domino hosting provide. Pass `client` to share a client created elsewhere.
+ * `baseUrl` defaults to `/relay`, the participant proxy that `domino dev` and Domino hosting
+ * provide. Pass `client` to share a client created elsewhere. A new `client` or `baseUrl` takes
+ * effect at once: the old observer stops, reads in flight are cancelled, and the hooks start again
+ * from an empty cache. Safe to render on the server; nothing is read until it mounts.
  */
 declare function RelayProvider({ client, baseUrl, children, }: {
     client?: RelayClient;
@@ -2448,90 +2518,139 @@ declare function RelayProvider({ client, baseUrl, children, }: {
     children: ReactNode;
 }): react.JSX.Element;
 
+/** What every read hook returns: `{ status, data, error, refresh }`. */
+type Query<T> = QuerySnapshot<T> & {
+    /** Reads again now, replacing a read in flight. Never rejects: a failure lands in `error`. */
+    refresh(): Promise<void>;
+};
+/** A read that needs a signed-in member: a `Query`, or `signed-out` while nobody is. */
+type MemberQuery<T> = MemberSnapshot<T> & {
+    refresh(): Promise<void>;
+};
+
+/** What a paged read adds to its query: the next page. */
+type PageLoader = {
+    /** Appends the next page; does nothing while one loads, or when there is none. */
+    loadMore(): Promise<void>;
+    /** True while `loadMore()` reads. */
+    loadingMore: boolean;
+    /** Why the last `loadMore()` failed, until the next one starts. */
+    loadMoreError: RelayError | null;
+};
+/** A paged read as one growing list: `data.items` and `data.nextCursor`, and `loadMore()`. */
+type PagedQuery<T> = Query<Page<T>> & PageLoader;
+/** A paged read that needs a signed-in member: a `PagedQuery`, or `signed-out` while nobody is. */
+type MemberPagedQuery<T> = MemberQuery<Page<T>> & PageLoader;
+/** A paged read: `read` receives `cursor` (absent for the first page) with `signal` and `session`. */
+type PageRead<T> = (context: QueryContext & {
+    cursor?: string;
+}) => Promise<Page<T>>;
 /**
- * All a participant sees of a reward Domino delivers elsewhere, such as a
- * Discord role. Attempts, errors, and role IDs stay out of the page.
+ * A cached read through the participant client, for calls no hook covers.
+ *
+ * Every component that asks for the same `key` shares one read and one value; `useInvalidate()`
+ * marks it out of date after a change. `read` receives `{ signal, session }`: pass them as the
+ * client method's last argument, so a superseded read is cancelled and Relay refuses one for
+ * another session. The value belongs to the participant signed in when it was read, and is
+ * dropped when they sign out or another member signs in.
+ *
+ * ```tsx
+ * const boards = useRelayQuery(["leaderboards", "list"], (options) =>
+ *   relay.leaderboards.list(options)
+ * )
+ * ```
  */
-type RoleDelivery = {
-    quest: string;
-    status: "pending" | "delivered" | "failed";
-};
-declare function sanitizeDeliveries(deliveries: RoleDelivery[]): RoleDelivery[];
+declare function useRelayQuery<T>(key: QueryKey, read: QueryRead<T>, options?: QueryOptions): Query<T>;
 /**
- * Changes whenever the participant completes something, which is the only time
- * a new delivery can appear. Empty until the first completion, so participants
- * with nothing to deliver never ask.
+ * `useRelayQuery` for reads that need a signed-in member. Nothing is read while nobody is signed
+ * in, and `status` is then `signed-out`.
  */
-declare function completionMark(quests: Pick<QuestView, "quest" | "completed" | "completionCount">[]): string;
-declare function hasPending(deliveries: RoleDelivery[]): boolean;
+declare function useMemberQuery<T>(key: QueryKey, read: QueryRead<T>, options?: QueryOptions): MemberQuery<T>;
 /**
- * The words for one quest, or null when it delivers nothing. This never
- * changes whether the quest is completed: the role follows the completion.
+ * A paged read (`{ cursor }` in, `{ items, nextCursor }` out) as one growing list, for pages a
+ * signed-out visitor can read too. `refresh()` and an invalidation start again from the first
+ * page; a page that arrives after that, or for another key or participant, is dropped rather than
+ * appended.
  */
-declare function roleDeliveryLabel(deliveries: RoleDelivery[], quest: string): "Role delivery pending" | "Role delivery failed" | "Role granted" | null;
-/** Waits between reads: while a role is pending, then after each failure. */
-declare const PENDING_POLL_MS = 5000;
-declare const RETRY_DELAYS_MS: number[];
-type Schedule = (run: () => void, ms: number) => () => void;
+declare function useRelayPages<T>(key: QueryKey, read: PageRead<T>, options?: QueryOptions): PagedQuery<T>;
+/** `useRelayPages` for pages that need a signed-in member: `signed-out` while nobody is. */
+declare function useMemberPages<T>(key: QueryKey, read: PageRead<T>, options?: QueryOptions): MemberPagedQuery<T>;
 /**
- * Follows one participant's role deliveries until there is nothing to wait for.
+ * Marks cached reads out of date after a change. Each key is a prefix: `[["leaderboards"]]`
+ * reads every leaderboard on screen again and forgets the rest. With no keys, everything.
  *
- * - A read that succeeds with nothing pending ends the watch: no empty polling.
- * - A pending role is read again every few seconds.
- * - A failed read, including the very first, is retried with a short backoff.
- *   After the last retry the watch rests until `wake()`, which the page calls
- *   when it becomes visible or focused again.
- * - Failures never report anything, so a pending role stays pending on screen.
+ * The SDK's own mutating hooks call it; call it after a change made with `useRelay()` directly.
+ * `["experience"]` reads the quest experience again.
  */
-declare function watchRoleDeliveries(options: {
-    read: () => Promise<RoleDelivery[]>;
-    onChange: (deliveries: RoleDelivery[]) => void;
-    schedule?: Schedule;
-}): {
-    wake(): void;
-    dispose(): void;
+declare function useInvalidate(): (keys?: QueryKey[]) => Promise<void>;
+/**
+ * Who is signed in: the session (`data`, null for a signed-out visitor) and its `member`.
+ * Independent of the quest experience: a failing experience read signs nobody out.
+ */
+declare function useSession(): Query<ParticipantSession | null> & {
+    /** The signed-in member's ID, or null. */
+    member: string | null;
 };
 
-type Collection = {
-    id: string;
-    title: string;
-    quests: QuestView[];
+/**
+ * The key prefixes the SDK's hooks cache under, for `useInvalidate()`: after a change made with
+ * `useRelay()` directly, `invalidate([relayKeys.leaderboards])` reads every leaderboard on screen
+ * again. Keys of your own `useRelayQuery` calls must not start with these.
+ */
+declare const relayKeys: {
+    /** `useExperience`: invalidating it reads the quest experience again. */
+    readonly experience: readonly ["experience"];
+    /** `useMe`. */
+    readonly me: readonly ["me"];
+    /** `useAccounts`. */
+    readonly accounts: readonly ["accounts"];
+    /** `useWallets`. */
+    readonly wallets: readonly ["wallets"];
+    /** `useMyProfile`, `useProfile`, `useProfileCompletions`, `useProfileReferral`. */
+    readonly profiles: readonly ["profiles"];
+    /** `useLeaderboard`, `useLeaderboardPlacement`. */
+    readonly leaderboards: readonly ["leaderboards"];
+    /** `useReferralSummary`. */
+    readonly referrals: readonly ["referrals"];
+    /** `usePointLedgers`. */
+    readonly pointLedgers: readonly ["point-ledgers"];
+    /** `useTieredRewards`. */
+    readonly tieredRewards: readonly ["tiered-rewards"];
+    /** `useSignInMethods`. */
+    readonly signInMethods: readonly ["sign-in-methods"];
+    /** `useBalances`, `usePointHistory`. */
+    readonly balances: readonly ["balances"];
 };
-type Experience = {
-    status: "loading";
-} | {
-    status: "signed-out";
-} | {
-    status: "error";
-    message: string;
-} | {
-    status: "ready";
-    quests: QuestView[];
-    collections: Collection[];
-    /** Set when a refresh failed; the last good data stays on screen. */
-    stale: string | null;
+
+/**
+ * All a participant sees of a reward Domino delivers elsewhere, such as a
+ * Discord role. Attempts, errors, and role IDs stay out of the page.
+ */
+type RoleDelivery = {
+    quest: string;
+    status: "pending" | "delivered" | "failed";
 };
+type KnownRoleDeliveryStatus = "pending" | "failed" | "granted";
+/** Where one quest's role deliveries stand, as a code an app can localize; open for new codes. */
+type RoleDeliveryStatus = KnownRoleDeliveryStatus | (string & {});
 /**
- * Everything to list, in display order: collections as Console arranged them,
- * then any quest nobody has placed yet, sorted by `order`: authoring keys
- * (the `key` in quests/*.quest.ts), or quest IDs for quests without one.
- * Archived quests are left out.
+ * Where one quest's roles stand, or null when it delivers nothing. This never
+ * changes whether the quest is completed: the role follows the completion.
+ * `failed` means Domino gave up; only the organizer can grant the role now.
  */
-declare function questGroups(experience: Extract<Experience, {
-    status: "ready";
-}>, order?: string[]): Collection[];
+declare function roleDeliveryStatus(deliveries: RoleDelivery[], quest: string): KnownRoleDeliveryStatus | null;
+/** `roleDeliveryStatus` in English, or null for null. */
+declare function roleDeliveryLabel(status: RoleDeliveryStatus | null): "Role delivery pending" | "Role delivery failed" | "Role granted" | null;
 
-type ExperienceContext = {
-    experience: Experience;
-    /** The signed-in participant's member ID, or null. */
-    member: string | null;
-    /** Discord roles earned from quests, and whether each has arrived yet. */
+/**
+ * The signed-in participant's quests and collections, polled for the whole app by one observer,
+ * which pauses while the tab is hidden. `data` holds `quests` and `collections`; `signed-out`
+ * means nobody is signed in. `deliveries` lists Discord roles earned from quests and whether each
+ * has arrived yet.
+ */
+declare function useExperience(): MemberQuery<ExperienceData> & {
     deliveries: RoleDelivery[];
-    /** Read again now instead of waiting for the next poll. */
-    refresh(): Promise<void>;
 };
-/** The participant's quests and collections, polled for the whole app. */
-declare function useExperience(): ExperienceContext;
 
 type QuestInput = {
     kind: "text" | "url";
@@ -2821,7 +2940,7 @@ declare function useQuest(observed: QuestView): {
     /** Input recovered after the quest changed. Prefill the form with it. */
     draft: SubmissionDraft | null;
     notice: QuestNotice;
-    error: string | null;
+    error: RelayError | null;
     busy: boolean;
     saved: SavedSubmission;
     /** The attempt the last "received" notice is about. */
@@ -2839,8 +2958,37 @@ declare function useQuest(observed: QuestView): {
 };
 
 type QuestTone = "open" | "done" | "waiting" | "attention" | "locked" | "off";
+/**
+ * Why a quest shows the way it does, as a stable code an app can localize. `questStatusText` turns
+ * it into English.
+ *
+ * - `completed`: nothing more to do.
+ * - `paused`, `closed`: the operator paused or archived the quest.
+ * - `streak`: a streak in progress; `view.streak` has the counts and when the next day starts.
+ * - `streak-budget-exhausted`: the streak reached a milestone whose reward budget ran out.
+ * - `automatic`: Domino counts this by itself whenever the participant qualifies.
+ * - `in-progress`: an automatic quest Domino is running.
+ * - `locked`: prerequisites first; `view.availability.missing` lists them.
+ * - `checking`, `in-review`: a submission is being verified, or reviewed by a person.
+ * - `retryable`: verification could not run; the participant can retry.
+ * - `staff-required`: a staff member confirms it.
+ * - `rejected`: the last submission was not accepted; the participant can try again.
+ * - `ready`: the participant can act now.
+ */
+type KnownQuestStatusCode = "completed" | "paused" | "closed" | "streak" | "streak-budget-exhausted" | "automatic" | "in-progress" | "locked" | "checking" | "in-review" | "retryable" | "staff-required" | "rejected" | "ready";
+/** A known code, or one a newer SDK adds: render unknown codes with a neutral fallback. */
+type QuestStatusCode = KnownQuestStatusCode | (string & {});
 type QuestStatus = {
     tone: QuestTone;
+    code: QuestStatusCode;
+    /**
+     * Set when the participant's last submission was rejected: the evaluator's reason, or an empty
+     * string when it gave none.
+     */
+    reason?: string;
+};
+/** `QuestStatus` in English: a short `label`, and a sentence of `detail` when there is more. */
+type QuestStatusText = QuestStatus & {
     label: string;
     detail?: string;
 };
@@ -2856,11 +3004,6 @@ declare function isFinished(view: QuestView): boolean;
  * status and nothing to press.
  */
 declare function isAutomatic(view: QuestView): boolean;
-/**
- * True for automatic quests driven by observed activity, possibly many times
- * and without telling the participant. They read "Automatic", not "In progress".
- */
-declare function runsSilently(view: QuestView): boolean;
 /** "Completed 3 times" for repeatable quests, otherwise nothing. */
 declare function completionCountLabel(view: QuestView): string | null;
 /**
@@ -2868,10 +3011,18 @@ declare function completionCountLabel(view: QuestView): string | null;
  * open again, so show the normal submit action rather than a finished state.
  */
 declare function canRepeat(view: QuestView): boolean;
-/** Hidden quests run in the background and are never listed. */
-declare function visibleQuests<T extends Pick<QuestView, "visibility">>(quests: T[]): T[];
-/** Turns a QuestView into words. Pure, so copy changes stay in one place. */
-declare function questStatus(view: QuestView): QuestStatus;
+/**
+ * What a QuestView means for the participant, as a tone and a code. Pure and free of copy: render
+ * the code in your own words, or call `questStatusText` for English.
+ */
+declare function questStatus(view: QuestView): QuestStatus & {
+    code: KnownQuestStatusCode;
+};
+/**
+ * `questStatus` in English, for apps that do not localize: a `label` such as "In review", and a
+ * `detail` sentence when there is more to say.
+ */
+declare function questStatusText(view: QuestView): QuestStatusText;
 /** True when the participant can submit something right now. */
 declare function canSubmit(view: QuestView): boolean;
 declare function progressOf(quests: QuestView[]): {
@@ -2882,25 +3033,24 @@ declare function progressOf(quests: QuestView[]): {
 type OAuthProvider = AuthProvider;
 /**
  * The sign-in methods participants can use here: the OAuth providers and email Domino configured
- * for the platform, and the wallet sign-in this project enabled in Console.
+ * for the platform, and the wallet sign-in this project enabled in Console, in `data`. When they
+ * cannot be read, `data` offers email alone and `data.error` says why; the server still has the
+ * final say.
  */
-declare function useSignInMethods(): SignInMethods | null;
+declare function useSignInMethods(): Query<SignInMethods>;
 /**
- * The signed-in member and the seed of their generated avatar, or null while signed out or
- * loading: `<img src={defaultAvatar(me.avatarSeed)} />`. The seed is derived from the member and
+ * The signed-in member and the seed of their generated avatar, in `data`:
+ * `<img src={defaultAvatar(me.data.avatarSeed)} />`. The seed is derived from the member and
  * reveals nothing about them; linking wallets or accounts does not change it.
  */
-declare function useMe(): {
-    member: string;
-    avatarSeed: string;
-} | null;
+declare function useMe(): MemberQuery<MemberSummary>;
 /**
  * Email codes, OAuth consent and wallet signatures always happen in the participant's browser.
  * The actions keep their identity across renders, and never reject: a failure lands in `error`.
  */
 declare function useSignIn(): {
     busy: boolean;
-    error: string | null;
+    error: RelayError | null;
     /** True once a code was sent and the form should ask for it. */
     codeSent: boolean;
     sendCode: (email: string) => Promise<void>;
@@ -2937,9 +3087,10 @@ declare function useSignInOptions(input?: {
     options: SignInOption[] | null;
     unavailable: SignInUnavailable[];
     /** Why the project's methods could not be read; the options are then email alone. */
-    methodsError: string | null;
+    methodsError: RelayError | null;
     busy: boolean;
-    error: string | null;
+    /** Why the last sign-in action failed. */
+    error: RelayError | null;
     /** True once an email code was sent and the form should ask for it. */
     codeSent: boolean;
     /** Forgets the email code sent, to use another address. */
@@ -2947,53 +3098,119 @@ declare function useSignInOptions(input?: {
 };
 
 /** True when the account can be used to verify quests right now. */
-declare function isConnected(accounts: AccountConnection[] | null, provider: AuthProvider): boolean;
+declare function isConnected(accounts: AccountConnection[] | null | undefined, provider: AuthProvider): boolean;
 /**
- * The signed-in participant's connected accounts (X, Discord, Google, Apple).
+ * The signed-in participant's connected accounts (X, Discord, Google, Apple) in `data`.
  *
  * Connecting leaves the page for the provider's consent screen and comes back
  * connected. The list is read again when the window regains focus and after
- * any disconnect in this tab, so every component using it stays in step.
+ * a disconnect, in every component that uses it. `connect` and `disconnect`
+ * never reject: they resolve whether they succeeded, and a failure lands in
+ * `actionError`.
  */
 declare function useAccounts(): {
-    /** Null until read, and while nobody is signed in. */
-    accounts: {
+    connect: (provider: AuthProvider) => Promise<boolean>;
+    disconnect: (provider: AuthProvider) => Promise<boolean>;
+    busy: boolean;
+    actionError: RelayError | null;
+    isConnected: (provider: AuthProvider) => boolean;
+    status: "loading";
+    data: undefined;
+    error: null;
+    refresh(): Promise<void>;
+} | {
+    connect: (provider: AuthProvider) => Promise<boolean>;
+    disconnect: (provider: AuthProvider) => Promise<boolean>;
+    busy: boolean;
+    actionError: RelayError | null;
+    isConnected: (provider: AuthProvider) => boolean;
+    status: "error";
+    data: undefined;
+    error: RelayError;
+    refresh(): Promise<void>;
+} | {
+    connect: (provider: AuthProvider) => Promise<boolean>;
+    disconnect: (provider: AuthProvider) => Promise<boolean>;
+    busy: boolean;
+    actionError: RelayError | null;
+    isConnected: (provider: AuthProvider) => boolean;
+    status: "signed-out";
+    data: undefined;
+    error: null;
+    refresh(): Promise<void>;
+} | {
+    connect: (provider: AuthProvider) => Promise<boolean>;
+    disconnect: (provider: AuthProvider) => Promise<boolean>;
+    busy: boolean;
+    actionError: RelayError | null;
+    isConnected: (provider: AuthProvider) => boolean;
+    status: "ready";
+    data: {
         provider: "google" | "apple" | "x" | "discord";
         configured: boolean;
         status: "disconnected" | "connected" | "reconnect";
         subject: string | null;
         revision: number;
-    }[] | null;
-    error: string | null;
-    busy: boolean;
-    refresh: () => Promise<void>;
-    isConnected: (provider: AuthProvider) => boolean;
-    connect: (provider: AuthProvider) => Promise<void>;
-    disconnect: (provider: AuthProvider) => Promise<void>;
+    }[];
+    error: RelayError | null;
+    refresh(): Promise<void>;
 };
 
 /**
- * The signed-in participant's linked Solana, EVM and Cosmos wallets.
+ * The signed-in participant's linked Solana, EVM and Cosmos wallets, in `data`.
  *
  * Linking asks the wallet to sign a one-time message. The list is read again
- * when the window regains focus and after any link or unlink in this tab, so
- * every component using it stays in step.
+ * when the window regains focus and after a link or unlink, in every component
+ * that uses it. `link` and `unlink` never reject: they resolve whether they
+ * succeeded, and a failure lands in `actionError`.
  */
 declare function useWallets(): {
-    /** Null until read, and while nobody is signed in. */
-    wallets: {
+    /** Links the wallet to the member the list was read for; another session is refused. */
+    link: (signer: WalletSigner) => Promise<boolean>;
+    unlink: (wallet: Pick<LinkedWallet, "chain" | "address">) => Promise<boolean>;
+    busy: boolean;
+    actionError: RelayError | null;
+    status: "loading";
+    data: undefined;
+    error: null;
+    refresh(): Promise<void>;
+} | {
+    /** Links the wallet to the member the list was read for; another session is refused. */
+    link: (signer: WalletSigner) => Promise<boolean>;
+    unlink: (wallet: Pick<LinkedWallet, "chain" | "address">) => Promise<boolean>;
+    busy: boolean;
+    actionError: RelayError | null;
+    status: "error";
+    data: undefined;
+    error: RelayError;
+    refresh(): Promise<void>;
+} | {
+    /** Links the wallet to the member the list was read for; another session is refused. */
+    link: (signer: WalletSigner) => Promise<boolean>;
+    unlink: (wallet: Pick<LinkedWallet, "chain" | "address">) => Promise<boolean>;
+    busy: boolean;
+    actionError: RelayError | null;
+    status: "signed-out";
+    data: undefined;
+    error: null;
+    refresh(): Promise<void>;
+} | {
+    /** Links the wallet to the member the list was read for; another session is refused. */
+    link: (signer: WalletSigner) => Promise<boolean>;
+    unlink: (wallet: Pick<LinkedWallet, "chain" | "address">) => Promise<boolean>;
+    busy: boolean;
+    actionError: RelayError | null;
+    status: "ready";
+    data: {
         chain: "solana" | "eip155" | "cosmos";
         network: `cosmos:${string}` | null;
         address: string;
         verifiedAt: number;
         revision: number;
         signIn: boolean;
-    }[] | null;
-    error: string | null;
-    busy: boolean;
-    refresh: () => Promise<void>;
-    link: (signer: WalletSigner) => Promise<void>;
-    unlink: (wallet: Pick<LinkedWallet, "chain" | "address">) => Promise<void>;
+    }[];
+    error: RelayError | null;
+    refresh(): Promise<void>;
 };
 /**
  * The EVM, Solana and Cosmos wallets installed in this browser. Empty during
@@ -3021,19 +3238,54 @@ declare function useSignInWallets(networks: readonly WalletSignInNetwork[] | nul
     cosmos?: CosmosChains;
 }): SignInWallet[] | null;
 
-/** Dispatched on `window` after the member changes their profile in this tab. */
-declare const PROFILE_CHANGED = "relay-profile-changed";
 /**
- * The signed-in member's own profile, and changes to it: the name, the avatar (an uploaded
- * picture, an account's picture or the generated one) and whether others see it.
+ * The signed-in member's own profile in `data`, and changes to it: the name, the avatar (an
+ * uploaded picture, an account's picture or the generated one) and whether others see it.
  *
- * Read again when the window regains focus and after any change in this tab, so every component
- * using it stays in step. Each change is bound to the session it was read with: a session that
- * changed in between is refused rather than applied to another member.
+ * Read again when the window regains focus and after a change, in every component that uses it,
+ * with the leaderboards that show the name. Each change is bound to the session the profile was
+ * read with: a session that changed in between is refused rather than applied to another member.
+ * `update` and `uploadAvatar` never reject: they resolve true once saved, and a failure lands in
+ * `actionError`.
  */
 declare function useMyProfile(): {
-    /** Null until read, and while nobody is signed in. */
-    profile: {
+    update: (input: ProfileUpdate) => Promise<boolean>;
+    /** Uploads a JPEG, PNG or WebP of at most 5 MB as the avatar. */
+    uploadAvatar: (file: Blob) => Promise<boolean>;
+    busy: boolean;
+    actionError: RelayError | null;
+    status: "loading";
+    data: undefined;
+    error: null;
+    refresh(): Promise<void>;
+} | {
+    update: (input: ProfileUpdate) => Promise<boolean>;
+    /** Uploads a JPEG, PNG or WebP of at most 5 MB as the avatar. */
+    uploadAvatar: (file: Blob) => Promise<boolean>;
+    busy: boolean;
+    actionError: RelayError | null;
+    status: "error";
+    data: undefined;
+    error: RelayError;
+    refresh(): Promise<void>;
+} | {
+    update: (input: ProfileUpdate) => Promise<boolean>;
+    /** Uploads a JPEG, PNG or WebP of at most 5 MB as the avatar. */
+    uploadAvatar: (file: Blob) => Promise<boolean>;
+    busy: boolean;
+    actionError: RelayError | null;
+    status: "signed-out";
+    data: undefined;
+    error: null;
+    refresh(): Promise<void>;
+} | {
+    update: (input: ProfileUpdate) => Promise<boolean>;
+    /** Uploads a JPEG, PNG or WebP of at most 5 MB as the avatar. */
+    uploadAvatar: (file: Blob) => Promise<boolean>;
+    busy: boolean;
+    actionError: RelayError | null;
+    status: "ready";
+    data: {
         id: string;
         name: string;
         avatar: {
@@ -3060,198 +3312,43 @@ declare function useMyProfile(): {
             name: string | null;
             imageUrl: string | null;
         }[];
-    } | null;
-    error: string | null;
-    busy: boolean;
-    refresh: () => Promise<void>;
-    /** Resolves true once saved; a failure sets `error`. */
-    update: (input: ProfileUpdate) => Promise<boolean>;
-    /** Uploads a JPEG, PNG or WebP of at most 5 MB as the avatar; resolves true once saved. */
-    uploadAvatar: (file: Blob) => Promise<boolean>;
-};
-/**
- * A read keyed by a profile. `missing` is the uniform 404: a profile (or board, or program) that
- * is missing, hidden by its member, or not visible to this viewer, on purpose indistinguishable.
- */
-type ProfileReadState<T> = {
-    status: "loading";
-} | {
-    status: "error";
-    message: string;
-} | {
-    status: "missing";
-} | {
-    status: "ready";
-    value: T;
-    stale: string | null;
-};
-type ProfileState = {
-    status: "loading";
-} | {
-    status: "error";
-    message: string;
-}
-/** Missing, hidden by its member, or not visible to this viewer: indistinguishable on purpose. */
- | {
-    status: "missing";
-} | {
-    status: "ready";
-    profile: ProfileSummary;
-    stale: string | null;
+    };
+    error: RelayError | null;
+    refresh(): Promise<void>;
 };
 /**
- * A profile's name and avatar by its public ID (`relay.profiles.get`), read again every
- * `intervalMs` (default 60 seconds) while the page is visible and when the participant signs in
- * or out.
+ * A profile's name and avatar by its public ID (`relay.profiles.get`), in `data`. Read again every
+ * `intervalMs` (default 60 seconds) while the page is visible. A profile that is missing, hidden by
+ * its member or not visible to this viewer is an `error` with `status` 404, indistinguishable on
+ * purpose.
  */
 declare function useProfile(id: string, options?: {
     intervalMs?: number;
-}): {
-    refresh: () => Promise<void>;
-    status: "loading";
-} | {
-    refresh: () => Promise<void>;
-    status: "error";
-    message: string;
-} | {
-    refresh: () => Promise<void>;
-    status: "missing";
-} | {
-    refresh: () => Promise<void>;
-    status: "ready";
-    profile: ProfileSummary;
-    stale: string | null;
-};
+}): Query<ProfileSummary>;
 /**
- * A profile's current rank and score on one board (`relay.leaderboards.placement`), read again
- * every `intervalMs` (default 30 seconds) while the page is visible. Signed-out visitors get an
- * error for boards without public access.
+ * A profile's current rank and score on one board (`relay.leaderboards.placement`), in `data`.
+ * Read again every `intervalMs` (default 30 seconds) while the page is visible. Signed-out
+ * visitors get an error for boards without public access.
  */
 declare function useLeaderboardPlacement(board: string, profile: string, options?: {
     intervalMs?: number;
-}): {
-    refresh: () => Promise<void>;
-    status: "loading";
-} | {
-    refresh: () => Promise<void>;
-    status: "error";
-    message: string;
-} | {
-    refresh: () => Promise<void>;
-    status: "missing";
-} | {
-    refresh: () => Promise<void>;
-    status: "ready";
-    value: {
-        leaderboard: string;
-        title: string;
-        profile: string;
-        rank: number | null;
-        score: number | null;
-        total: number;
-        key?: string | undefined;
-    };
-    stale: string | null;
-};
+}): Query<LeaderboardPlacement>;
 /**
- * A profile's progress in one referral program (`relay.profiles.referral`), read again every
- * `intervalMs` (default 60 seconds) while the page is visible. Needs a signed-in participant.
+ * A profile's progress in one referral program (`relay.profiles.referral`), in `data`. Read again
+ * every `intervalMs` (default 60 seconds) while the page is visible. Needs a signed-in participant.
  */
 declare function useProfileReferral(profile: string, program: string, options?: {
     intervalMs?: number;
-}): {
-    refresh: () => Promise<void>;
-    status: "loading";
-} | {
-    refresh: () => Promise<void>;
-    status: "error";
-    message: string;
-} | {
-    refresh: () => Promise<void>;
-    status: "missing";
-} | {
-    refresh: () => Promise<void>;
-    status: "ready";
-    value: {
-        program: string;
-        title: string;
-        invited: number;
-        qualified: number;
-        milestones: {
-            id: string;
-            count: number;
-            reached: boolean;
-        }[];
-        key?: string | undefined;
-    };
-    stale: string | null;
-};
-type ProfileCompletionsState = {
-    status: "loading";
-} | {
-    status: "error";
-    message: string;
-} | {
-    status: "missing";
-} | {
-    status: "ready";
-    items: ProfileCompletion[];
-    /** More completions to load with `loadMore()`. */
-    more: boolean;
-    /** Loading the next page. */
-    loading: boolean;
-    /** Why the last `loadMore()` failed, until the next succeeds. */
-    error: string | null;
-};
+}): MemberQuery<ProfileReferral>;
 /**
  * A profile's completions of quests that show on profiles (`relay.profiles.completions`), most
- * recently completed first, `limit` quests at a time. `loadMore()` appends the next page;
- * `refresh()` starts again from the first, as signing in or out and a profile change in this tab
- * do.
+ * recently completed first, `limit` quests at a time: `data.items`, and `data.nextCursor` while
+ * there are more. `loadMore()` appends the next page; `refresh()` starts again from the first, as a
+ * quest submission or a profile change does.
  */
 declare function useProfileCompletions(profile: string, options?: {
     limit?: number;
-}): {
-    refresh: () => Promise<void>;
-    /**
-     * Appends the next page; does nothing while one loads, while the first page reloads, or when
-     * there is none.
-     */
-    loadMore: () => Promise<void>;
-    status: "loading";
-} | {
-    refresh: () => Promise<void>;
-    /**
-     * Appends the next page; does nothing while one loads, while the first page reloads, or when
-     * there is none.
-     */
-    loadMore: () => Promise<void>;
-    status: "error";
-    message: string;
-} | {
-    refresh: () => Promise<void>;
-    /**
-     * Appends the next page; does nothing while one loads, while the first page reloads, or when
-     * there is none.
-     */
-    loadMore: () => Promise<void>;
-    status: "missing";
-} | {
-    refresh: () => Promise<void>;
-    /**
-     * Appends the next page; does nothing while one loads, while the first page reloads, or when
-     * there is none.
-     */
-    loadMore: () => Promise<void>;
-    status: "ready";
-    items: ProfileCompletion[];
-    /** More completions to load with `loadMore()`. */
-    more: boolean;
-    /** Loading the next page. */
-    loading: boolean;
-    /** Why the last `loadMore()` failed, until the next succeeds. */
-    error: string | null;
-};
+}): PagedQuery<ProfileCompletion>;
 
 type ReferralSummary = z.infer<typeof referralSummarySchema>;
 /**
@@ -3271,14 +3368,18 @@ type Invitation = {
 } | {
     status: "accepted";
     code: string;
-} | {
+}
+/** Domino refused the code, or it is malformed: `error` says why. Never retry it. */
+ | {
     status: "rejected";
     code: string;
-    reason: string;
-} | {
+    error: RelayError;
+}
+/** Offline, a server error or a cut-off answer: `error` says why. Retry with `accept(code)`. */
+ | {
     status: "failed";
     code: string;
-    reason: string;
+    error: RelayError;
 };
 /**
  * Accepts the invitation the participant arrived with, as soon as they are
@@ -3286,334 +3387,67 @@ type Invitation = {
  *
  * Domino rejects self-referrals, cycles, codes from another project, and
  * invitations accepted after the participant's first completion. Show the
- * reason; `accept(code)` also serves a manual "Have a code?" input.
+ * reason; `accept(code)` also serves a manual "Have a code?" input. Once
+ * accepted, the referral summary and referral progress are read again.
  */
 declare function useInvitation(param?: string): {
     invitation: Invitation;
     accept: (code: string) => Promise<void>;
 };
 /**
- * The signed-in participant's invitation code, share link, and progress:
- * attributed friends, qualified friends per program, milestones, and points.
+ * The signed-in participant's invitation code and progress in `data`: attributed friends,
+ * qualified friends per program, milestones, and points. `link` is the share link, null until the
+ * summary is read. Read again after an invitation is accepted and after a quest submission.
  */
 declare function useReferralSummary(options?: {
     path?: string;
     param?: string;
-}): {
-    summary: {
-        code: string;
-        attributed: number;
-        programs: {
-            definition: {
-                id: string;
-                title: string;
-                enabled: boolean;
-                qualification: {
-                    kind: "signup";
-                } | {
-                    kind: "quest";
-                    quest: string;
-                } | {
-                    kind: "external";
-                };
-                rewards: {
-                    inviter: ({
-                        kind: "tier";
-                        reward: {
-                            id: string;
-                            title: string;
-                            tiers: {
-                                id: string;
-                                title: string;
-                            }[];
-                            inventory: {
-                                kind: "untracked";
-                            };
-                            fulfillment: {
-                                kind: "staff-handover";
-                            };
-                        };
-                        tier: string;
-                    } | {
-                        kind: "points";
-                        balance: string;
-                        amount: number;
-                    })[];
-                    invitee: ({
-                        kind: "tier";
-                        reward: {
-                            id: string;
-                            title: string;
-                            tiers: {
-                                id: string;
-                                title: string;
-                            }[];
-                            inventory: {
-                                kind: "untracked";
-                            };
-                            fulfillment: {
-                                kind: "staff-handover";
-                            };
-                        };
-                        tier: string;
-                    } | {
-                        kind: "points";
-                        balance: string;
-                        amount: number;
-                    })[];
-                };
-                milestones: {
-                    id: string;
-                    count: number;
-                    rewards: ({
-                        kind: "tier";
-                        reward: {
-                            id: string;
-                            title: string;
-                            tiers: {
-                                id: string;
-                                title: string;
-                            }[];
-                            inventory: {
-                                kind: "untracked";
-                            };
-                            fulfillment: {
-                                kind: "staff-handover";
-                            };
-                        };
-                        tier: string;
-                    } | {
-                        kind: "points";
-                        balance: string;
-                        amount: number;
-                    })[];
-                }[];
-                bonuses: {
-                    id: string;
-                    balance: string;
-                    basisPoints: number;
-                    external: boolean;
-                    quests?: string[] | undefined;
-                    durationDays?: number | undefined;
-                    maxPoints?: number | undefined;
-                }[];
-                key?: string | undefined;
-                inviterGroup?: string | undefined;
-            };
-            qualified: number;
-            milestones: {
-                id: string;
-                count: number;
-                reached: boolean;
-            }[];
-        }[];
-        accounts: {
-            id: string;
-            program: string;
-            kind: "fixed" | "milestone" | "bonus";
-            balance: string;
-            earned: number;
-            settled: number;
-            outstanding: number;
-        }[];
-    } | null;
+}): MemberQuery<ReferralSummary> & {
     link: string | null;
-    error: string | null;
-    refresh: () => Promise<void>;
 };
 
-type LeaderboardState = {
-    status: "loading";
-} | {
-    status: "error";
-    message: string;
-} | {
-    status: "ready";
-    page: LeaderboardPage;
-    stale: string | null;
-};
 /**
- * One leaderboard's top rows plus the participant's own row and neighbours.
+ * One leaderboard's top rows plus the participant's own row and neighbours, in `data`.
  *
- * Read again every `intervalMs` while the page is visible, and when the
- * participant signs in or out. Boards default to participants-only access:
- * signed-out visitors see an error unless the board is published as public.
+ * Read again every `intervalMs` while the page is visible, after a quest submission, and for each
+ * participant who signs in. Boards default to participants-only access: signed-out visitors get
+ * an error unless the board is published as public.
  */
 declare function useLeaderboard(board: string, options?: {
     limit?: number;
     intervalMs?: number;
-}): {
-    refresh: () => Promise<void>;
-    status: "loading";
-} | {
-    refresh: () => Promise<void>;
-    status: "error";
-    message: string;
-} | {
-    refresh: () => Promise<void>;
-    status: "ready";
-    page: LeaderboardPage;
-    stale: string | null;
-};
+}): Query<LeaderboardPage>;
 
-type BalancesState = {
-    status: "loading";
-} | {
-    status: "signed-out";
-} | {
-    status: "error";
-    message: string;
-} | {
-    status: "ready";
-    items: PointBalance[];
-    stale: string | null;
-};
-type PointHistoryState = {
-    status: "loading";
-} | {
-    status: "signed-out";
-}
-/** No ledger has this key or ID in the project (`point-ledger-not-found`). */
- | {
-    status: "missing";
-}
-/** The member has not joined this project, so it has no points here (`not-joined`). */
- | {
-    status: "not-joined";
-} | {
-    status: "error";
-    message: string;
-} | {
-    status: "ready";
-    items: PointEntry[];
-    /** Whether `loadMore()` has another page to read. */
-    more: boolean;
-    /** A next page is loading. */
-    loading: boolean;
-    /** Why the last next page failed; the items read so far stay. */
-    error: string | null;
-};
 /**
- * The signed-in participant's balance in each of the project's point ledgers: `balance` counts
- * every entry, `available` leaves out points reservations hold. Read again when the participant
- * signs in or out and after a quest completes. Find a ledger by the key your app declared:
- * `items.find((b) => b.ledger.key === "points")`.
+ * The signed-in participant's balance in each of the project's point ledgers, as `data.items`:
+ * `balance` counts every entry, `available` leaves out points reservations hold. Read again
+ * whenever one of the participant's quests completes. Find a ledger by the key your app declared:
+ * `data.items.find((b) => b.ledger.key === "points")`.
  */
-declare function useBalances(): {
-    refresh: () => Promise<void>;
-    status: "loading";
-} | {
-    refresh: () => Promise<void>;
-    status: "signed-out";
-} | {
-    refresh: () => Promise<void>;
-    status: "error";
-    message: string;
-} | {
-    refresh: () => Promise<void>;
-    status: "ready";
-    items: PointBalance[];
-    stale: string | null;
-};
+declare function useBalances(): MemberQuery<PointBalances>;
 /**
- * The signed-in participant's own entries in one ledger, by key or ID, most recently recorded first, a page at a
- * time. Starts over when the participant signs in or out and after a quest completes.
+ * The signed-in participant's own entries in one ledger, by key or ID, most recently recorded
+ * first, a page at a time: `data.items`, and `loadMore()` while `data.nextCursor` is set. Starts
+ * over whenever one of the participant's quests completes. An unknown ledger is an `error` with
+ * code `point-ledger-not-found`; a member who has not joined the project, `not-joined`.
  */
-declare function usePointHistory(ledger: string): {
-    refresh: () => Promise<void>;
-    /** Appends the next page; does nothing while a page loads or when there is none. */
-    loadMore: () => Promise<void>;
-    status: "loading";
-} | {
-    refresh: () => Promise<void>;
-    /** Appends the next page; does nothing while a page loads or when there is none. */
-    loadMore: () => Promise<void>;
-    status: "signed-out";
-} | {
-    refresh: () => Promise<void>;
-    /** Appends the next page; does nothing while a page loads or when there is none. */
-    loadMore: () => Promise<void>;
-    status: "missing";
-} | {
-    refresh: () => Promise<void>;
-    /** Appends the next page; does nothing while a page loads or when there is none. */
-    loadMore: () => Promise<void>;
-    status: "not-joined";
-} | {
-    refresh: () => Promise<void>;
-    /** Appends the next page; does nothing while a page loads or when there is none. */
-    loadMore: () => Promise<void>;
-    status: "error";
-    message: string;
-} | {
-    refresh: () => Promise<void>;
-    /** Appends the next page; does nothing while a page loads or when there is none. */
-    loadMore: () => Promise<void>;
-    status: "ready";
-    items: PointEntry[];
-    /** Whether `loadMore()` has another page to read. */
-    more: boolean;
-    /** A next page is loading. */
-    loading: boolean;
-    /** Why the last next page failed; the items read so far stay. */
-    error: string | null;
-};
+declare function usePointHistory(ledger: string): MemberPagedQuery<PointEntry>;
 
-type ReferencesState<T> = {
-    status: "loading";
-} | {
-    status: "error";
-    message: string;
-} | {
-    status: "ready";
-    items: T[];
-};
-type PointLedgersState = ReferencesState<PointLedgerReference>;
-type TieredRewardsState = ReferencesState<TieredRewardReference>;
 /**
- * The project's point ledgers with their keys and names.
+ * The project's point ledgers with their keys and names, in `data`.
  *
  * Reads such as referral summaries and history name ledgers by ID. Find a
  * ledger by the key your app declared, then compare IDs:
- * `items.find((l) => l.key === "credits")?.id`.
+ * `data.find((l) => l.key === "credits")?.id`.
  */
-declare function usePointLedgers(): {
-    refresh: () => Promise<void>;
-    status: "loading";
-} | {
-    refresh: () => Promise<void>;
-    status: "error";
-    message: string;
-} | {
-    refresh: () => Promise<void>;
-    status: "ready";
-    items: {
-        id: string;
-        key: string | null;
-        name: string;
-    }[];
-};
+declare function usePointLedgers(): Query<PointLedgerReference[]>;
 /**
- * The project's tiered rewards with their keys.
+ * The project's tiered rewards with their keys, in `data`.
  *
  * Entitlements and reward definitions name tiered rewards by ID. Find a reward
  * by the key you gave defineTieredReward, then compare IDs:
- * `items.find((r) => r.key === "tote")?.id`.
+ * `data.find((r) => r.key === "tote")?.id`.
  */
-declare function useTieredRewards(): {
-    refresh: () => Promise<void>;
-    status: "loading";
-} | {
-    refresh: () => Promise<void>;
-    status: "error";
-    message: string;
-} | {
-    refresh: () => Promise<void>;
-    status: "ready";
-    items: {
-        id: string;
-        key: string | null;
-    }[];
-};
+declare function useTieredRewards(): Query<TieredRewardReference[]>;
 
-export { type BalancesState, type Collection, CosmosChains, DiscoveredWallet, type Experience, type Invitation, type LeaderboardState, type OAuthProvider, PENDING_POLL_MS, PROFILE_CHANGED, type PointHistoryState, type PointLedgersState, type ProfileCompletionsState, type ProfileReadState, type ProfileState, type QuestInput, type QuestNotice, type QuestStatus, type QuestTone, RETRY_DELAYS_MS, type ReferencesState, type ReferralSummary, type RelayClient, RelayProvider, type RoleDelivery, type SavedSubmission, SignInMethods, SignInOption, SignInUnavailable, SignInWallet, type TieredRewardsState, canRepeat, canSubmit, captureReferralCode, completionCountLabel, completionMark, hasPending, isAutomatic, isConnected, isFinished, progressOf, questGroups, questStatus, roleDeliveryLabel, runsSilently, sanitizeDeliveries, useAccounts, useBalances, useExperience, useInvitation, useLeaderboard, useLeaderboardPlacement, useMe, useMyProfile, usePointHistory, usePointLedgers, useProfile, useProfileCompletions, useProfileReferral, useQuest, useReferralSummary, useRelay, useSignIn, useSignInMethods, useSignInOptions, useSignInWallets, useSignOut, useTieredRewards, useWalletDiscovery, useWallets, visibleQuests, watchRoleDeliveries };
+export { type Collection, CosmosChains, DiscoveredWallet, type ExperienceData, type Invitation, type KnownQuestStatusCode, type KnownRoleDeliveryStatus, type MemberPagedQuery, type MemberQuery, type MemberSnapshot, type OAuthProvider, Page, type PageLoader, type PageRead, type PagedQuery, type Query, type QueryContext, type QueryKey, type QueryOptions, type QueryRead, type QuerySnapshot, type QuestInput, type QuestNotice, type QuestStatus, type QuestStatusCode, type QuestStatusText, type QuestTone, type ReferralSummary, type RelayClient, RelayProvider, type RoleDelivery, type RoleDeliveryStatus, type SavedSubmission, SignInMethods, SignInOption, SignInUnavailable, SignInWallet, canRepeat, canSubmit, captureReferralCode, completionCountLabel, isAutomatic, isConnected, isFinished, progressOf, questGroups, questStatus, questStatusText, relayKeys, roleDeliveryLabel, roleDeliveryStatus, useAccounts, useBalances, useExperience, useInvalidate, useInvitation, useLeaderboard, useLeaderboardPlacement, useMe, useMemberPages, useMemberQuery, useMyProfile, usePointHistory, usePointLedgers, useProfile, useProfileCompletions, useProfileReferral, useQuest, useReferralSummary, useRelay, useRelayPages, useRelayQuery, useSession, useSignIn, useSignInMethods, useSignInOptions, useSignInWallets, useSignOut, useTieredRewards, useWalletDiscovery, useWallets };