@dubsdotapp/expo 0.5.17 → 0.5.19

package/dist/index.d.mts

@@ -0,0 +1,2090 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React$1 from 'react';
+import { PublicKey, Transaction, Connection } from '@solana/web3.js';
+import { ViewStyle } from 'react-native';
+
+interface DeviceInfo {
+    platform: string;
+    modelName: string | null;
+    brand: string | null;
+    manufacturer: string | null;
+    osName: string | null;
+    osVersion: string | null;
+    deviceType: number | null;
+    deviceName: string | null;
+    totalMemory: number | null;
+    modelId: string | null;
+    designName: string | null;
+    productName: string | null;
+    isDevice: boolean | null;
+}
+/**
+ * Detect Solana Seeker device (synchronous — safe to call during render).
+ * Checks brand from expo-device; returns false if expo-device isn't installed.
+ */
+declare function isSolanaSeeker(): boolean;
+declare function getDeviceInfo(): Promise<DeviceInfo>;
+
+interface Opponent {
+    name: string | null;
+    imageUrl: string | null;
+    score: number | null;
+}
+interface EventMedia {
+    poster: string | null;
+    thumbnail: string | null;
+    streams: EventStream[];
+}
+interface EventStream {
+    url: string | null;
+    language: string | null;
+}
+interface EventMeta {
+    matchType: string | null;
+    numberOfGames: number | null;
+    tournament: string | null;
+    country: string | null;
+}
+interface UnifiedEvent {
+    id: string;
+    type: 'sports' | 'esports';
+    title: string;
+    league: string | null;
+    game: string | null;
+    startTime: string | null;
+    status: 'upcoming' | 'live' | 'finished' | 'canceled';
+    tier: string | null;
+    venue: string | null;
+    opponents: Opponent[];
+    media: EventMedia;
+    meta: EventMeta;
+}
+interface Pagination {
+    page: number;
+    perPage: number;
+    total: number;
+    totalPages: number;
+}
+interface EsportsMatchOpponent {
+    id: number;
+    name: string;
+    acronym: string | null;
+    imageUrl: string | null;
+}
+interface EsportsMatchResult {
+    teamId: number;
+    score: number;
+}
+interface EsportsMatchDetail {
+    matchId: number;
+    title: string;
+    status: string;
+    videogame: string | null;
+    league: string | null;
+    serie: string | null;
+    tournament: string | null;
+    tier: string | null;
+    startTime: string | null;
+    endTime: string | null;
+    matchType: string | null;
+    numberOfGames: number | null;
+    opponents: EsportsMatchOpponent[];
+    results: EsportsMatchResult[];
+    winnerId: number | null;
+}
+interface ValidateEventResult {
+    bettable: boolean;
+    gameMode: number;
+    lockTimestamp: number;
+    startTime: string | null;
+    status: string;
+}
+interface CreateGameParams {
+    id: string;
+    playerWallet: string;
+    teamChoice: 'home' | 'away' | 'draw';
+    wagerAmount: number;
+}
+interface CreateGameResult {
+    gameId: string;
+    gameAddress: string;
+    transaction: string;
+    lockTimestamp: number;
+    event: UnifiedEvent;
+}
+interface CreateCustomGameParams {
+    playerWallet: string;
+    teamChoice: 'home' | 'away';
+    wagerAmount: number;
+    title?: string;
+    maxPlayers?: number;
+    metadata?: Record<string, unknown>;
+}
+interface CreateCustomGameResult {
+    gameId: string;
+    gameAddress: string;
+    transaction: string;
+    lockTimestamp: number;
+}
+interface JoinGameParams {
+    playerWallet: string;
+    gameId: string;
+    teamChoice: 'home' | 'away' | 'draw';
+    amount: number;
+}
+interface JoinGameResult {
+    gameId: string;
+    transaction: string;
+    gameAddress: string;
+}
+interface ConfirmGameParams {
+    gameId: string;
+    playerWallet: string;
+    signature: string;
+    teamChoice?: 'home' | 'away' | 'draw';
+    wagerAmount?: number;
+    role?: 'creator' | 'joiner';
+    gameAddress?: string;
+}
+interface ConfirmGameResult {
+    gameId: string;
+    signature: string;
+    explorerUrl: string;
+    message: string;
+}
+interface BuildClaimParams {
+    playerWallet: string;
+    gameId: string;
+}
+interface BuildClaimResult {
+    transaction: string;
+    gameAddress: string;
+    message: string;
+}
+interface ConfirmClaimParams {
+    playerWallet: string;
+    signature: string;
+    amountClaimed?: number;
+}
+interface ConfirmClaimResult {
+    gameId: string;
+    signature: string;
+    explorerUrl: string;
+    message: string;
+}
+interface GameMedia {
+    poster: string | null;
+    thumbnail: string | null;
+}
+interface Bettor {
+    wallet: string;
+    username: string | null;
+    avatar: string | null;
+    team: 'home' | 'away' | 'draw';
+    amount: number;
+    amountClaimed: number | null;
+    claimSignature: string | null;
+}
+interface GameDetail {
+    gameId: string;
+    gameAddress: string;
+    title: string;
+    buyIn: number;
+    gameMode: number;
+    isLocked: boolean;
+    isResolved: boolean;
+    status: string;
+    league: string | null;
+    lockTimestamp: number | null;
+    /** Winning side: 'home' | 'away' | 'draw' | null (null = refund) */
+    winnerSide: string | null;
+    opponents: GameListOpponent[];
+    bettors: Bettor[];
+    homePool: number;
+    awayPool: number;
+    drawPool: number;
+    totalPool: number;
+    media: GameMedia;
+    createdAt: string;
+    updatedAt: string;
+}
+interface GameListOpponent {
+    name: string | null;
+    imageUrl: string | null;
+}
+interface GameListItem {
+    gameId: string;
+    title: string;
+    buyIn: number;
+    gameMode: number;
+    isLocked: boolean;
+    isResolved: boolean;
+    status: string;
+    totalPool: number;
+    league: string | null;
+    lockTimestamp: number | null;
+    createdAt: string;
+    opponents: GameListOpponent[];
+    media: GameMedia;
+}
+interface GetGamesParams {
+    wallet?: string;
+    status?: 'open' | 'locked' | 'resolved';
+    limit?: number;
+    offset?: number;
+}
+interface GetNetworkGamesParams {
+    league?: string;
+    exclude_wallet?: string;
+    limit?: number;
+    offset?: number;
+}
+interface GetUpcomingEventsParams {
+    type?: 'sports' | 'esports';
+    game?: string;
+    page?: number;
+    per_page?: number;
+}
+interface ParsedError {
+    code: string;
+    message: string;
+}
+interface SolanaErrorCode {
+    code: string;
+    message: string;
+}
+interface DubsUser {
+    walletAddress: string;
+    username: string;
+    avatar: string | null;
+    myReferralCode: string | null;
+    onboardingComplete: boolean;
+    createdAt: string;
+}
+interface DubsPublicUser {
+    walletAddress: string;
+    username: string;
+    avatar: string | null;
+    createdAt: string;
+}
+interface DubsAppUser extends DubsPublicUser {
+    firstSeenAt: string;
+    lastSeenAt: string;
+}
+interface NonceResult {
+    nonce: string;
+    message: string;
+}
+
+interface AuthenticateParams {
+    walletAddress: string;
+    signature: string;
+    nonce: string;
+    deviceInfo?: DeviceInfo;
+}
+interface AuthenticateResult {
+    needsRegistration: boolean;
+    user?: DubsUser;
+    token?: string;
+}
+interface RegisterParams {
+    walletAddress: string;
+    signature: string;
+    nonce: string;
+    username: string;
+    referralCode?: string;
+    avatarUrl?: string;
+    deviceInfo?: DeviceInfo;
+}
+interface RegisterResult {
+    user: DubsUser;
+    token: string;
+}
+interface CheckUsernameResult {
+    available: boolean;
+    reason?: string;
+}
+type AuthStatus = 'idle' | 'authenticating' | 'signing' | 'verifying' | 'needsRegistration' | 'registering' | 'authenticated' | 'error';
+type MutationStatus = 'idle' | 'building' | 'signing' | 'confirming' | 'saving' | 'success' | 'error';
+interface QueryResult<T> {
+    data: T | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+interface MutationResult<TParams, TResult> {
+    execute: (params: TParams) => Promise<TResult>;
+    status: MutationStatus;
+    error: Error | null;
+    data: TResult | null;
+    reset: () => void;
+}
+interface LiveScoreCompetitor {
+    name: string;
+    homeAway: 'home' | 'away';
+    score: number;
+    logo: string | null;
+    abbreviation: string;
+}
+interface LiveScore {
+    status: string;
+    period: number | null;
+    displayClock: string | null;
+    detail: string | null;
+    shortDetail: string | null;
+    competitors: LiveScoreCompetitor[];
+    ufcData?: {
+        currentRound: number;
+        totalRounds: number;
+        clock: string;
+        fightState: string;
+        statusDetail: string;
+    };
+}
+interface UFCFighter {
+    name: string;
+    athleteId: string | null;
+    headshotUrl: string | null;
+    flagUrl: string | null;
+    country: string | null;
+    abbreviation: string;
+    record: string | null;
+    winner: boolean;
+}
+interface UFCFighterDetail {
+    athleteId: string;
+    firstName: string | null;
+    lastName: string | null;
+    fullName: string | null;
+    nickname: string | null;
+    shortName: string | null;
+    height: string | null;
+    heightInches: number | null;
+    weight: string | null;
+    weightLbs: number | null;
+    reach: string | null;
+    reachInches: number | null;
+    age: number | null;
+    dateOfBirth: string | null;
+    stance: string | null;
+    weightClass: string | null;
+    citizenship: string | null;
+    citizenshipAbbreviation: string | null;
+    gym: string | null;
+    gymCountry: string | null;
+    active: boolean;
+    headshotUrl: string | null;
+    flagUrl: string | null;
+    stanceImageUrl: string | null;
+    espnUrl: string | null;
+    slug: string | null;
+}
+interface UFCData {
+    currentRound: number;
+    totalRounds: number;
+    clock: string;
+    fightState: 'pre' | 'in' | 'post';
+    statusDetail: string;
+    statusShortDetail?: string;
+}
+interface UFCFight {
+    id: string | null;
+    home: UFCFighter;
+    away: UFCFighter;
+    weightClass: string | null;
+    status: string;
+    ufcData: UFCData | null;
+}
+interface UFCEvent {
+    eventName: string;
+    date: string | null;
+    fights: UFCFight[];
+}
+interface BuildArcadeEntryResult {
+    transaction: string;
+    poolId: string;
+    amount: string;
+    destination?: string;
+    gameId?: string;
+    gameAddress?: string;
+}
+interface EnterArcadePoolResult {
+    poolId: string;
+    signature: string;
+    entry: ArcadeEntry;
+}
+interface ArcadePool {
+    id: number;
+    app_id: number;
+    game_slug: string;
+    name: string;
+    buy_in_lamports: number;
+    max_lives: number;
+    period_start: string;
+    period_end: string;
+    schedule: 'weekly' | 'daily' | 'monthly';
+    status: 'open' | 'active' | 'resolving' | 'complete' | 'cancelled';
+    solana_game_id: string | null;
+    solana_game_address: string | null;
+    total_entries: number;
+    created_at: string;
+    next_resolution: string | null;
+}
+interface ArcadeEntry {
+    id: number;
+    pool_id: number;
+    wallet_address: string;
+    best_score: number;
+    lives_used: number;
+    rank: number | null;
+    created_at: string;
+    attempts: ArcadeAttempt[] | null;
+}
+interface ArcadeAttempt {
+    id: number;
+    attempt_number: number;
+    score: number | null;
+    status: 'active' | 'submitted' | 'expired';
+    started_at: string;
+    submitted_at: string | null;
+    duration_ms: number | null;
+}
+interface ArcadeLeaderboardEntry {
+    id: number;
+    wallet_address: string;
+    best_score: number;
+    lives_used: number;
+    username: string;
+    avatar: string | null;
+    rank: number;
+}
+interface ArcadePoolStats {
+    total_entries: number;
+    top_score: number;
+    avg_score: number;
+    active_players: number;
+}
+interface StartAttemptResult {
+    sessionToken: string;
+    attemptNumber: number;
+    livesRemaining: number;
+}
+interface SubmitScoreResult {
+    score: number;
+    bestScore: number;
+    livesUsed: number;
+    isNewBest: boolean;
+}
+interface ArcadePoolResult {
+    id: number;
+    pool_id: number;
+    entry_id: number;
+    wallet_address: string;
+    amount_lamports: string;
+    status: string;
+    username: string;
+    avatar: string | null;
+    best_score: number;
+}
+interface JackpotRound {
+    roundId: string;
+    status: 'Open' | 'Locked' | 'Resolved';
+    totalPotLamports: string;
+    totalPotSol: number;
+    entryCount: number;
+    totalWeight: string;
+    timeRemainingSlots: number;
+}
+interface JackpotLastWinner {
+    roundId: string;
+    winner: string;
+    winAmount: string;
+    winAmountSol: number;
+    totalPot: string;
+    entryCount: number;
+    timestamp: string | null;
+}
+interface JackpotEntry {
+    player: string;
+    weight: string;
+    weightSol: number;
+    oddsPercent: string;
+}
+interface JackpotRoundResult {
+    roundId: string;
+    winner: string;
+    winAmount: string;
+    winAmountSol: number;
+    totalPot: string;
+    totalPotSol: number;
+    entryCount: number;
+    timestamp: string;
+}
+interface JackpotConfig {
+    feeBasisPoints: number;
+    roundDurationSlots: string;
+    minEntryLamports: number;
+    minEntrySol: number;
+}
+interface BuildJackpotEnterResult {
+    transaction: string;
+    roundId: string;
+    amount: string;
+    amountSol: number;
+}
+interface ConfirmJackpotEnterResult {
+    attributed: boolean;
+    appId: number;
+    signature: string;
+}
+interface UiConfig {
+    accentColor?: string;
+    appIcon?: string;
+    appName?: string;
+    appUrl?: string;
+    tagline?: string;
+    environment?: 'sandbox' | 'production';
+    /**
+     * Whether the developer has uploaded push credentials in the dev portal.
+     * Consumers should gate their push opt-in UI on the relevant platform flag —
+     * e.g. only show the "Enable Notifications" screen if pushConfigured.android is true.
+     */
+    pushConfigured?: {
+        android: boolean;
+        ios: boolean;
+    };
+}
+
+interface DubsClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+declare class DubsClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private _token;
+    constructor(config: DubsClientConfig);
+    /** Set the user JWT token for authenticated requests */
+    setToken(token: string | null): void;
+    /** Get the current user JWT token */
+    getToken(): string | null;
+    private request;
+    getUpcomingEvents(params?: GetUpcomingEventsParams): Promise<{
+        events: UnifiedEvent[];
+        pagination: Pagination;
+    }>;
+    getSportsEvents(league: string): Promise<UnifiedEvent[]>;
+    getEsportsMatches(videogame?: string): Promise<UnifiedEvent[]>;
+    getEsportsMatchDetail(matchId: string | number): Promise<EsportsMatchDetail>;
+    getUFCFightCard(): Promise<UFCEvent[]>;
+    getUFCFighterDetail(athleteId: string): Promise<UFCFighterDetail>;
+    validateEvent(id: string): Promise<ValidateEventResult>;
+    createGame(params: CreateGameParams): Promise<CreateGameResult>;
+    joinGame(params: JoinGameParams): Promise<JoinGameResult>;
+    confirmGame(params: ConfirmGameParams): Promise<ConfirmGameResult>;
+    createCustomGame(params: CreateCustomGameParams): Promise<CreateCustomGameResult>;
+    confirmCustomGame(params: ConfirmGameParams): Promise<ConfirmGameResult>;
+    buildClaimTransaction(params: BuildClaimParams): Promise<BuildClaimResult>;
+    confirmClaim(gameId: string, params: ConfirmClaimParams): Promise<ConfirmClaimResult>;
+    getGame(gameId: string): Promise<GameDetail>;
+    getLiveScore(gameId: string): Promise<LiveScore | null>;
+    getGames(params?: GetGamesParams): Promise<GameListItem[]>;
+    getNetworkGames(params?: GetNetworkGamesParams): Promise<{
+        games: GameListItem[];
+        pagination: Pagination;
+    }>;
+    getNonce(walletAddress: string): Promise<NonceResult>;
+    authenticate(params: AuthenticateParams): Promise<AuthenticateResult>;
+    register(params: RegisterParams): Promise<RegisterResult>;
+    getMe(): Promise<DubsUser>;
+    getUser(walletAddress: string): Promise<DubsPublicUser | null>;
+    getAppUsers(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        users: DubsAppUser[];
+        pagination: {
+            total: number;
+            limit: number;
+            offset: number;
+        };
+    }>;
+    checkUsername(username: string): Promise<CheckUsernameResult>;
+    logout(): Promise<void>;
+    registerPushToken(params: {
+        token: string;
+        platform: string;
+        deviceName?: string;
+    }): Promise<void>;
+    unregisterPushToken(token: string): Promise<void>;
+    updateProfile(params: {
+        avatar?: string;
+    }): Promise<DubsUser>;
+    parseError(error: unknown): Promise<ParsedError>;
+    getErrorCodes(): Promise<Record<number, SolanaErrorCode>>;
+    /**
+     * Parse a Solana error locally without an API call.
+     * Useful for instant feedback in the UI.
+     */
+    parseErrorLocal(error: unknown): ParsedError;
+    /** Get the full local error code map */
+    getErrorCodesLocal(): Record<number, SolanaErrorCode>;
+    getArcadePools(params?: {
+        gameSlug?: string;
+        status?: string;
+    }): Promise<ArcadePool[]>;
+    getArcadePool(poolId: number): Promise<{
+        pool: ArcadePool;
+        stats: ArcadePoolStats;
+    }>;
+    /** Build unsigned entry transaction for an arcade pool */
+    buildArcadeEntry(poolId: number, walletAddress: string): Promise<BuildArcadeEntryResult>;
+    enterArcadePool(poolId: number, params: {
+        walletAddress: string;
+        txSignature: string;
+        gameId?: string;
+        gameAddress?: string;
+    }): Promise<ArcadeEntry>;
+    startArcadeAttempt(poolId: number, walletAddress: string): Promise<StartAttemptResult>;
+    submitArcadeScore(poolId: number, params: {
+        walletAddress: string;
+        sessionToken: string;
+        score: number;
+        durationMs?: number;
+    }): Promise<SubmitScoreResult>;
+    getArcadeLeaderboard(poolId: number, params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<ArcadeLeaderboardEntry[]>;
+    getArcadeResults(poolId: number): Promise<ArcadePoolResult[]>;
+    getArcadeEntry(poolId: number, walletAddress: string): Promise<ArcadeEntry>;
+    /** Get current jackpot round + last winner */
+    getJackpotCurrent(): Promise<{
+        round: JackpotRound | null;
+        lastWinner: JackpotLastWinner | null;
+    }>;
+    /** Get current round entries with odds */
+    getJackpotEntries(): Promise<{
+        roundId: string;
+        entries: JackpotEntry[];
+        totalEntries: number;
+    }>;
+    /** Get recent jackpot round results */
+    getJackpotHistory(limit?: number): Promise<JackpotRoundResult[]>;
+    /** Get jackpot protocol config */
+    getJackpotConfig(): Promise<JackpotConfig>;
+    /** Build unsigned jackpot enter transaction */
+    buildJackpotEnter(playerAddress: string, amount: number): Promise<BuildJackpotEnterResult>;
+    /** Confirm jackpot entry after wallet signs (creates developer attribution) */
+    confirmJackpotEnter(params: {
+        playerAddress: string;
+        roundId?: string;
+        amount?: number;
+        signature: string;
+    }): Promise<ConfirmJackpotEnterResult>;
+    /** Get recent global chat messages */
+    getChatMessages(params?: {
+        limit?: number;
+        before?: number;
+    }): Promise<{
+        messages: any[];
+        hasMore: boolean;
+    }>;
+    /** Send a message to global chat */
+    sendChatMessage(params: {
+        message: string;
+        replyToId?: number;
+    }): Promise<{
+        message: any;
+    }>;
+    /** Edit your own message */
+    editChatMessage(id: number, message: string): Promise<{
+        message: any;
+    }>;
+    /** Delete your own message */
+    deleteChatMessage(id: number): Promise<{
+        messageId: number;
+    }>;
+    /** Block a user */
+    blockUser(targetUserId: number): Promise<void>;
+    /** Unblock a user */
+    unblockUser(targetUserId: number): Promise<void>;
+    /** Get DM conversations inbox */
+    getConversations(limit?: number): Promise<{
+        conversations: any[];
+    }>;
+    /** Get conversation history with a specific user */
+    getConversation(walletAddress: string, params?: {
+        limit?: number;
+        beforeId?: number;
+    }): Promise<{
+        messages: any[];
+        otherUser: any;
+    }>;
+    /** Send a direct message */
+    sendDirectMessage(params: {
+        recipientWallet: string;
+        message: string;
+    }): Promise<{
+        message: any;
+    }>;
+    /** Mark all DMs from a user as read */
+    markDMRead(walletAddress: string): Promise<{
+        markedRead: number;
+    }>;
+    /** Get unread DM count */
+    getDMUnreadCount(): Promise<{
+        unreadCount: number;
+    }>;
+    /** Delete a DM conversation (soft delete) */
+    deleteConversation(walletAddress: string): Promise<void>;
+    /** Search users by username */
+    searchUsers(query: string): Promise<{
+        results: any[];
+    }>;
+    /** Send a friend request */
+    sendFriendRequest(targetUserId: number): Promise<{
+        requestId: number;
+    }>;
+    /** Get pending friend requests (received) */
+    getPendingFriendRequests(): Promise<{
+        requests: any[];
+    }>;
+    /** Accept a friend request */
+    acceptFriendRequest(requestId: number): Promise<void>;
+    /** Reject a friend request */
+    rejectFriendRequest(requestId: number): Promise<void>;
+    /** Get friends list */
+    getFriends(): Promise<{
+        friends: any[];
+    }>;
+    /** Remove a friend */
+    removeFriend(targetUserId: number): Promise<void>;
+    /** Get blocked users list */
+    getBlockedUsers(): Promise<{
+        blocked: any[];
+    }>;
+    /** Fetch the app's UI customization config (accent color, icon, tagline, environment) */
+    getAppConfig(): Promise<UiConfig>;
+}
+
+declare class DubsApiError extends Error {
+    readonly code: string;
+    readonly httpStatus: number;
+    constructor(code: string, message: string, httpStatus: number);
+}
+/** Custom error codes from dubs_solana_program (6000-6049) */
+declare const SOLANA_PROGRAM_ERRORS: Record<number, SolanaErrorCode>;
+/**
+ * Parse a raw Solana transaction error into a human-readable { code, message }.
+ * Handles: { InstructionError: [idx, { Custom: N }] }, string errors, etc.
+ */
+declare function parseSolanaError(err: unknown): ParsedError;
+
+declare const DEFAULT_BASE_URL = "https://dubs-server-prod-9c91d3f01199.herokuapp.com/api/developer/v1";
+declare const DEFAULT_RPC_URL = "https://api.mainnet-beta.solana.com";
+type DubsNetwork = 'devnet' | 'mainnet-beta';
+declare const NETWORK_CONFIG: Record<DubsNetwork, {
+    baseUrl: string;
+    rpcUrl: string;
+    cluster: string;
+}>;
+
+interface TokenStorage {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    deleteItem(key: string): Promise<void>;
+}
+declare const STORAGE_KEYS: {
+    readonly MWA_AUTH_TOKEN: "dubs_mwa_auth_token";
+    readonly MWA_WALLET_ADDRESS: "dubs_mwa_wallet_address";
+    readonly JWT_TOKEN: "dubs_jwt_token";
+    readonly PHANTOM_SESSION: "dubs_phantom_session";
+    readonly PHANTOM_CONNECT_IN_FLIGHT: "dubs_phantom_connect_in_flight";
+};
+/**
+ * Creates a TokenStorage backed by expo-secure-store.
+ * Lazy-imports the module so it's only required at runtime when actually used.
+ * Throws a clear error if expo-secure-store is not installed.
+ */
+declare function createSecureStoreStorage(): TokenStorage;
+
+/**
+ * Minimal wallet adapter interface.
+ * Two required methods: publicKey + signTransaction.
+ * signAndSendTransaction is optional — if not provided, the SDK signs then sends via RPC.
+ */
+interface WalletAdapter {
+    /** The connected wallet's public key, or null if not connected */
+    publicKey: PublicKey | null;
+    /** Whether the wallet is currently connected */
+    connected: boolean;
+    /** Sign a transaction without sending it */
+    signTransaction(transaction: Transaction): Promise<Transaction>;
+    /**
+     * Optional: Sign and send in one step.
+     * If provided, the SDK will prefer this over signTransaction + sendRawTransaction.
+     * Returns the transaction signature.
+     */
+    signAndSendTransaction?(transaction: Transaction): Promise<string>;
+    /**
+     * Optional: Sign an arbitrary message (for authentication).
+     * Returns the signature as a Uint8Array.
+     */
+    signMessage?(message: Uint8Array): Promise<Uint8Array>;
+    /** Optional: Connect the wallet */
+    connect?(): Promise<void>;
+    /** Optional: Disconnect the wallet */
+    disconnect?(): void | Promise<void>;
+}
+
+interface RegistrationScreenProps {
+    onRegister: (username: string, referralCode?: string, avatarUrl?: string) => void;
+    registering: boolean;
+    error: Error | null;
+    client: DubsClient;
+}
+interface ConnectWalletScreenProps$1 {
+    /** Call this to trigger the wallet connection flow */
+    onConnect: () => void;
+    /** True while the wallet is connecting/signing */
+    connecting: boolean;
+    /** Error from a failed connection attempt */
+    error: Error | null;
+}
+interface AuthGateProps {
+    children: React$1.ReactNode;
+    onSaveToken: (token: string | null) => void | Promise<void>;
+    onLoadToken: () => string | null | Promise<string | null>;
+    renderLoading?: (status: AuthStatus) => React$1.ReactNode;
+    renderError?: (error: Error, retry: () => void) => React$1.ReactNode;
+    renderRegistration?: (props: RegistrationScreenProps) => React$1.ReactNode;
+    /**
+     * Render your own connect-wallet screen.
+     * Receives { onConnect, connecting, error }.
+     * If omitted, the default ConnectWalletScreen is shown.
+     */
+    renderConnectWallet?: (props: ConnectWalletScreenProps$1) => React$1.ReactNode;
+    appName?: string;
+    /** Override accent color for registration screens (from developer UI config) */
+    accentColor?: string;
+}
+declare function AuthGate({ children, onSaveToken, onLoadToken, renderLoading, renderError, renderRegistration, renderConnectWallet, appName, accentColor, }: AuthGateProps): react_jsx_runtime.JSX.Element;
+
+interface ConnectWalletScreenProps {
+    /** Called when the user taps Connect Wallet */
+    onConnect: () => void | Promise<void>;
+    /** Show a loading spinner on the button while connecting */
+    connecting?: boolean;
+    /** Error message to display (e.g. "User rejected the request") */
+    error?: string | null;
+    /** App name shown in the header. Defaults to "Dubs" */
+    appName?: string;
+    /** Override accent color (e.g. from developer UI config) */
+    accentColor?: string;
+    /** URL to app icon — renders as Image instead of the default letter circle */
+    appIcon?: string;
+    /** Override subtitle text below app name */
+    tagline?: string;
+}
+declare function ConnectWalletScreen({ onConnect, connecting, error, appName, accentColor, appIcon, tagline, }: ConnectWalletScreenProps): react_jsx_runtime.JSX.Element;
+
+interface DubsContextValue {
+    client: DubsClient;
+    wallet: WalletAdapter;
+    connection: Connection;
+    appName: string;
+    network: DubsNetwork;
+    disconnect: () => Promise<void>;
+    uiConfig: UiConfig;
+    pushEnabled: boolean;
+}
+interface DubsProviderProps {
+    apiKey: string;
+    children: React$1.ReactNode;
+    appName?: string;
+    network?: DubsNetwork;
+    /** Escape hatch: bring your own wallet adapter. Disables managed MWA. */
+    wallet?: WalletAdapter;
+    /** Escape hatch: custom token persistence. Defaults to expo-secure-store. */
+    tokenStorage?: TokenStorage;
+    /** Escape hatch: override base URL (takes precedence over network). */
+    baseUrl?: string;
+    /** Escape hatch: override RPC URL (takes precedence over network). */
+    rpcUrl?: string;
+    /** Custom connect screen, or false to hide it entirely (headless mode). */
+    renderConnectScreen?: ((props: ConnectWalletScreenProps) => React$1.ReactNode) | false;
+    /** Custom loading screen shown during auth. */
+    renderLoading?: (status: AuthStatus) => React$1.ReactNode;
+    /** Custom error screen shown on auth failure. */
+    renderError?: (error: Error, retry: () => void) => React$1.ReactNode;
+    /** Custom registration screen. */
+    renderRegistration?: (props: RegistrationScreenProps) => React$1.ReactNode;
+    /** Set to false to skip AuthGate and connect screen (headless/BYOA mode). Default: true. */
+    managed?: boolean;
+    /** Deeplink redirect URI for Phantom wallet (required for iOS support). */
+    redirectUri?: string;
+    /** App URL shown in Phantom's connect screen. */
+    appUrl?: string;
+    /** Enable Dubs push notifications. Default: true. Set false if your app manages its own Firebase/push. */
+    pushEnabled?: boolean;
+}
+declare function DubsProvider({ apiKey, children, appName, network, wallet: externalWallet, tokenStorage, baseUrl: baseUrlOverride, rpcUrl: rpcUrlOverride, renderConnectScreen, renderLoading, renderError, renderRegistration, managed, redirectUri, appUrl, pushEnabled, }: DubsProviderProps): react_jsx_runtime.JSX.Element | null;
+declare function useDubs(): DubsContextValue;
+declare function useAppConfig(): UiConfig;
+
+/** The `transact` function signature from @solana-mobile/mobile-wallet-adapter-protocol-web3js */
+type MwaTransactFn = (callback: (wallet: any) => Promise<any>) => Promise<any>;
+interface MwaAdapterConfig {
+    /** The MWA `transact` function — import it from @solana-mobile/mobile-wallet-adapter-protocol-web3js */
+    transact: MwaTransactFn;
+    appIdentity: {
+        name: string;
+        uri?: string;
+        icon?: string;
+    };
+    cluster?: string;
+    onAuthTokenChange?: (token: string | null) => void;
+}
+/**
+ * Mobile Wallet Adapter implementation.
+ * Wraps @solana-mobile/mobile-wallet-adapter-protocol-web3js.
+ */
+declare class MwaWalletAdapter implements WalletAdapter {
+    private _publicKey;
+    private _connected;
+    private _authToken;
+    /** The raw base64-encoded address from MWA authorize — needed for signMessages */
+    private _mwaAddress;
+    private readonly config;
+    private readonly transact;
+    constructor(config: MwaAdapterConfig);
+    get publicKey(): PublicKey | null;
+    get connected(): boolean;
+    get authToken(): string | null;
+    setAuthToken(token: string | null): void;
+    /**
+     * Restore a previous session silently (no wallet interaction).
+     * Sets the public key and auth token so the adapter appears connected.
+     * The next signing operation will reauthorize with Phantom.
+     */
+    restoreSession(token: string, walletAddressBase58: string): void;
+    /**
+     * Connect to a mobile wallet. Call this before any signing.
+     * Tries reauthorize first (if we have a saved token), then falls back to
+     * a fresh authorize in a SEPARATE transact session.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect and clear auth token.
+     */
+    disconnect(): void;
+    signTransaction(transaction: Transaction): Promise<Transaction>;
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+    signAndSendTransaction(transaction: Transaction): Promise<string>;
+    private applyAuthResult;
+}
+
+/** Serializable session state — save this to restore without a deeplink round-trip. */
+interface PhantomSession {
+    /** Our x25519 public key (base58) */
+    dappPublicKey: string;
+    /** Our x25519 secret key (base58) */
+    dappSecretKey: string;
+    /** Phantom's x25519 public key (base58) */
+    phantomPublicKey: string;
+    /** Shared secret (base58) */
+    sharedSecret: string;
+    /** Phantom session token (opaque string) */
+    sessionToken: string;
+    /** User's wallet public key (base58) */
+    walletPublicKey: string;
+}
+interface PhantomDeeplinkAdapterConfig {
+    /** The deeplink redirect URI, e.g. "myapp://phantom-callback" */
+    redirectUri: string;
+    /** Shown in Phantom's connect screen */
+    appUrl?: string;
+    /** Solana cluster: 'devnet' | 'mainnet-beta' */
+    cluster?: string;
+    /** Deeplink round-trip timeout in ms (default 120000) */
+    timeout?: number;
+    /** Called when the Phantom session changes (save/clear for persistence) */
+    onSessionChange?: (session: PhantomSession | null) => void;
+    /** Storage for persisting in-flight connect state (cold-start recovery on Android) */
+    storage?: TokenStorage;
+}
+/**
+ * Phantom wallet adapter using deeplinks (works on iOS and Android).
+ * Uses x25519 encrypted communication per Phantom's deeplink protocol.
+ */
+declare class PhantomDeeplinkAdapter implements WalletAdapter {
+    private _publicKey;
+    private _connected;
+    private _dappKeyPair;
+    private _sharedSecret;
+    private _sessionToken;
+    private _phantomPublicKey;
+    private readonly config;
+    private readonly handler;
+    private readonly timeout;
+    constructor(config: PhantomDeeplinkAdapterConfig);
+    get publicKey(): PublicKey | null;
+    get connected(): boolean;
+    /**
+     * Restore a previously saved session without opening Phantom.
+     * Call this before connect() if you have persisted session state.
+     */
+    restoreSession(saved: PhantomSession): void;
+    /** Serialize the current session for persistence. Returns null if not connected. */
+    getSession(): PhantomSession | null;
+    connect(): Promise<void>;
+    disconnect(): void;
+    /**
+     * Return and clear the stashed cold-start URL from the deeplink handler.
+     * Used by ManagedWalletProvider to detect an in-flight connect on cold start.
+     */
+    consumeColdStartUrl(): string | null;
+    /**
+     * Complete a connect flow that was interrupted by the OS killing the app (Android).
+     * Loads the saved in-flight keypair from storage, decrypts the Phantom response
+     * from the cold-start URL, and restores the session.
+     */
+    completeConnectFromColdStart(url: string): Promise<void>;
+    signTransaction(transaction: Transaction): Promise<Transaction>;
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+    /** Remove the Linking event listener. Call when the adapter is no longer needed. */
+    destroy(): void;
+    private assertConnected;
+}
+
+declare function useEvents(params?: GetUpcomingEventsParams): QueryResult<{
+    events: UnifiedEvent[];
+    pagination: Pagination;
+}>;
+
+declare function useGame(gameId: string | null): QueryResult<GameDetail>;
+
+declare function useGames(params?: GetGamesParams): QueryResult<GameListItem[]>;
+
+declare function useNetworkGames(params?: GetNetworkGamesParams): QueryResult<{
+    games: GameListItem[];
+    pagination: Pagination;
+}>;
+
+interface CreateGameMutationResult {
+    gameId: string;
+    gameAddress: string;
+    signature: string;
+    explorerUrl: string;
+}
+declare function useCreateGame(): {
+    execute: (params: CreateGameParams) => Promise<CreateGameMutationResult>;
+    status: MutationStatus;
+    error: Error | null;
+    data: CreateGameMutationResult | null;
+    reset: () => void;
+};
+
+interface JoinGameMutationResult {
+    gameId: string;
+    gameAddress: string;
+    signature: string;
+    explorerUrl: string;
+}
+declare function useJoinGame(): {
+    execute: (params: JoinGameParams) => Promise<JoinGameMutationResult>;
+    status: MutationStatus;
+    error: Error | null;
+    data: JoinGameMutationResult | null;
+    reset: () => void;
+};
+
+interface ClaimMutationResult {
+    gameId: string;
+    signature: string;
+    explorerUrl: string;
+}
+declare function useClaim(): {
+    execute: (params: BuildClaimParams & {
+        amountClaimed?: number;
+    }) => Promise<ClaimMutationResult>;
+    status: MutationStatus;
+    error: Error | null;
+    data: ClaimMutationResult | null;
+    reset: () => void;
+};
+
+interface CreateCustomGameMutationResult {
+    gameId: string;
+    gameAddress: string;
+    signature: string;
+    explorerUrl: string;
+    buyIn: number;
+}
+declare function useCreateCustomGame(): {
+    execute: (params: CreateCustomGameParams) => Promise<CreateCustomGameMutationResult>;
+    status: MutationStatus;
+    error: Error | null;
+    data: CreateCustomGameMutationResult | null;
+    reset: () => void;
+};
+
+interface ClaimStatus {
+    /** Whether the current wallet has claimed this game's prize */
+    hasClaimed: boolean;
+    /** Amount claimed (null if not claimed) */
+    amountClaimed: number | null;
+    /** Claim transaction signature (null if not claimed) */
+    claimSignature: string | null;
+    /** Whether the game has been resolved */
+    isResolved: boolean;
+    /** Loading state */
+    loading: boolean;
+    /** Error if fetch failed */
+    error: Error | null;
+    /** Re-fetch claim status */
+    refetch: () => void;
+}
+/**
+ * Check whether the current wallet has already claimed a prize for a game.
+ *
+ * Uses the game detail endpoint which includes per-bettor claim data.
+ */
+declare function useHasClaimed(gameId: string | null): ClaimStatus;
+
+interface UseAuthResult {
+    /** Current auth status */
+    status: AuthStatus;
+    /** Authenticated user profile, or null */
+    user: DubsUser | null;
+    /** JWT token, or null */
+    token: string | null;
+    /** Convenience boolean */
+    isAuthenticated: boolean;
+    /** Error from the last operation, or null */
+    error: Error | null;
+    /**
+     * Full nonce → sign → verify flow.
+     * If the wallet is already registered, resolves to authenticated state.
+     * If new wallet, resolves to needsRegistration state — call register() next.
+     */
+    authenticate: () => Promise<void>;
+    /**
+     * Register a new user after authenticate() returned needsRegistration.
+     * Reuses the nonce+signature from authenticate() — no second signing prompt.
+     */
+    register: (username: string, referralCode?: string, avatarUrl?: string) => Promise<void>;
+    /** Log out and clear state */
+    logout: () => Promise<void>;
+    /**
+     * Restore a session from a saved token (e.g. AsyncStorage on app restart).
+     * Calls GET /auth/me to validate. Returns true if valid, false otherwise.
+     */
+    restoreSession: (token: string) => Promise<boolean>;
+    /** Re-fetch user profile from the server (e.g. after avatar change) */
+    refreshUser: () => Promise<void>;
+    /** Reset to idle state, clearing errors and user */
+    reset: () => void;
+}
+declare function useAuth(): UseAuthResult;
+
+declare function useUFCFightCard(): QueryResult<UFCEvent[]>;
+
+declare function useUFCFighterDetail(athleteId: string | null): QueryResult<UFCFighterDetail>;
+
+interface HighlightVideo {
+    videoId: string;
+    title: string;
+    channelTitle: string;
+    thumbnail: string;
+    publishedAt: string;
+}
+declare function useHighlights(league?: string, limit?: number): QueryResult<HighlightVideo[]>;
+
+interface ShortVideo {
+    videoId: string;
+    title: string;
+    channelTitle: string;
+    thumbnail: string;
+    publishedAt: string;
+}
+declare function useShorts(league?: string, limit?: number): QueryResult<ShortVideo[]>;
+
+interface PushNotificationStatus {
+    /** Whether push notifications are enabled in the SDK configuration */
+    enabled: boolean;
+    /** Whether notification permission has been granted */
+    hasPermission: boolean;
+    /** The push token (native FCM/APNs), if registered */
+    pushToken: string | null;
+    /**
+     * @deprecated Use pushToken instead. Kept for backwards compatibility.
+     */
+    expoPushToken: string | null;
+    /** Whether a registration operation is in progress */
+    loading: boolean;
+    /** The last error encountered */
+    error: Error | null;
+    /**
+     * Request notification permission and register the push token.
+     * Does NOT auto-prompt — must be called explicitly (e.g. from an onboarding screen).
+     */
+    register: () => Promise<boolean>;
+    /** Unregister the current push token */
+    unregister: () => Promise<void>;
+    /**
+     * Silently re-register if permission was already granted (no prompt).
+     * Safe to call on app startup for returning users.
+     */
+    restoreIfGranted: () => Promise<void>;
+}
+declare function usePushNotifications(): PushNotificationStatus;
+
+interface UseArcadePoolsResult {
+    pools: ArcadePool[];
+    loading: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+declare function useArcadePools(gameSlug?: string): UseArcadePoolsResult;
+
+interface UseArcadePoolResult {
+    pool: ArcadePool | null;
+    stats: ArcadePoolStats | null;
+    leaderboard: ArcadeLeaderboardEntry[];
+    loading: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+declare function useArcadePool(poolId: number | null): UseArcadePoolResult;
+
+interface UseArcadeGameResult {
+    entry: ArcadeEntry | null;
+    livesRemaining: number;
+    bestScore: number;
+    loading: boolean;
+    error: Error | null;
+    /** Fetch/refresh the user's entry for this pool */
+    refreshEntry: () => Promise<void>;
+    /** Start a new life — returns session token to pass to the game */
+    startAttempt: () => Promise<StartAttemptResult>;
+    /** Submit score after game over */
+    submitScore: (sessionToken: string, score: number, durationMs?: number) => Promise<SubmitScoreResult>;
+}
+declare function useArcadeGame(poolId: number | null, maxLives?: number): UseArcadeGameResult;
+
+interface EnterArcadePoolMutationResult {
+    poolId: number;
+    signature: string;
+    entry: ArcadeEntry;
+}
+declare function useEnterArcadePool(): {
+    execute: (poolId: number) => Promise<EnterArcadePoolMutationResult>;
+    status: MutationStatus;
+    error: Error | null;
+    data: EnterArcadePoolMutationResult | null;
+    reset: () => void;
+};
+
+interface ArcadeCountdown {
+    /** Total milliseconds remaining */
+    totalMs: number;
+    /** Days remaining */
+    days: number;
+    /** Hours remaining (0-23) */
+    hours: number;
+    /** Minutes remaining (0-59) */
+    minutes: number;
+    /** Seconds remaining (0-59) */
+    seconds: number;
+    /** Formatted string e.g. "2d 5h 30m" or "5m 12s" */
+    formatted: string;
+    /** True when countdown has reached zero */
+    isExpired: boolean;
+}
+/**
+ * Countdown hook for arcade pool resolution time.
+ * Pass the `next_resolution` ISO string from the pool object.
+ * Ticks every second automatically.
+ */
+declare function useArcadeCountdown(nextResolution: string | null | undefined): ArcadeCountdown;
+
+/**
+ * useArcadeBridge
+ *
+ * Owns the full RN ↔ WebView bridge for Dubs Arcade pool integration.
+ * Replaces the manual sessionToken / gameStartTime / handleMessage / injectJavaScript
+ * wiring that previously lived inline in each game's index.tsx.
+ *
+ * PROTOCOL VERSION: dubsArcade 1.0
+ *
+ * Usage:
+ *
+ *   const { webviewRef, handleMessage, triggerPlay, lastResult } = useArcadeBridge({
+ *     poolId,
+ *     startAttempt,
+ *     submitScore,
+ *     canPlay,
+ *     onScoreSubmitted: (result) => { refetchPool(); },
+ *     onError:          (err)    => { console.warn(err); },
+ *   });
+ *
+ *   <WebView ref={webviewRef} onMessage={handleMessage} ... />
+ *   <TouchableOpacity onPress={triggerPlay}>Play</TouchableOpacity>
+ */
+
+type WebView = any;
+interface UseArcadeBridgeOptions {
+    /** Whether the player currently has an entry with lives remaining */
+    canPlay: boolean;
+    /** From useArcadeGame — starts a new life on the server */
+    startAttempt: () => Promise<StartAttemptResult>;
+    /** From useArcadeGame — submits a score for a completed life */
+    submitScore: (sessionToken: string, score: number, durationMs?: number) => Promise<SubmitScoreResult>;
+    /** Called when a new life starts (after startAttempt succeeds and session is injected) */
+    onPlayStarted?: () => void;
+    /** Called after a score is successfully submitted */
+    onScoreSubmitted?: (result: SubmitScoreResult) => void;
+    /** Called on any bridge error (network, invalid message, etc.) */
+    onError?: (err: Error) => void;
+}
+interface UseArcadeBridgeResult {
+    /** Attach to <WebView ref={webviewRef}> */
+    webviewRef: React.RefObject<WebView>;
+    /** Pass to <WebView onMessage={handleMessage}> */
+    handleMessage: (event: any) => void;
+    /**
+     * Call when the player taps PLAY in your UI.
+     * Calls startAttempt() then injects the session token + ARCADE_START into the WebView.
+     */
+    triggerPlay: () => Promise<void>;
+    /** The result of the most recent submitted score, or null */
+    lastResult: SubmitScoreResult | null;
+    /** True while a startAttempt or submitScore request is in flight */
+    bridgeLoading: boolean;
+}
+declare function useArcadeBridge({ canPlay, startAttempt, submitScore, onPlayStarted, onScoreSubmitted, onError, }: UseArcadeBridgeOptions): UseArcadeBridgeResult;
+
+interface UseJackpotResult {
+    round: JackpotRound | null;
+    lastWinner: JackpotLastWinner | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+declare function useJackpot(): UseJackpotResult;
+
+interface UseJackpotHistoryResult {
+    rounds: JackpotRoundResult[];
+    loading: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+declare function useJackpotHistory(limit?: number): UseJackpotHistoryResult;
+
+interface EnterJackpotMutationResult {
+    roundId: string;
+    amount: string;
+    amountSol: number;
+    signature: string;
+}
+declare function useEnterJackpot(): {
+    execute: (amountLamports: number) => Promise<EnterJackpotMutationResult>;
+    status: MutationStatus;
+    error: Error | null;
+    data: EnterJackpotMutationResult | null;
+    reset: () => void;
+};
+
+interface ConnectWalletButtonProps {
+    /** Button label. Defaults to "Connect Wallet" */
+    label?: string;
+    /** Override accent/background color */
+    accentColor?: string;
+    /** Override text color. Defaults to #000 */
+    textColor?: string;
+    /** Override border radius */
+    borderRadius?: number;
+    /** Override padding vertical */
+    paddingVertical?: number;
+    /** Override font size */
+    fontSize?: number;
+    /** Full width. Defaults to true */
+    fullWidth?: boolean;
+    /** Called after authenticate() is triggered (not after it completes) */
+    onPress?: () => void;
+}
+/**
+ * ConnectWalletButton
+ *
+ * A minimal, customisable button that fires useAuth().authenticate().
+ * Use this when you want to own the connect-wallet screen UI (e.g. inside
+ * your own onboarding) but still hand off the wallet picker, signing, and
+ * registration flow to the SDK.
+ *
+ * The SDK will handle everything after this tap:
+ *   wallet picker → sign message → (registration/avatar if new user) → authenticated
+ *
+ * Example:
+ *   <ConnectWalletButton
+ *     label="Let's go"
+ *     accentColor="#22C55E"
+ *     textColor="#000"
+ *   />
+ */
+declare function ConnectWalletButton({ label, accentColor, textColor, borderRadius, paddingVertical, fontSize, fullWidth, onPress, }: ConnectWalletButtonProps): react_jsx_runtime.JSX.Element;
+
+interface UserProfileCardProps {
+    walletAddress: string;
+    username?: string;
+    avatarUrl?: string | null;
+    memberSince?: string | null;
+}
+declare function UserProfileCard({ walletAddress, username, avatarUrl, memberSince, }: UserProfileCardProps): react_jsx_runtime.JSX.Element;
+
+interface SettingsSheetProps {
+    walletAddress: string;
+    username?: string;
+    avatarUrl?: string | null;
+    memberSince?: string | null;
+    appVersion?: string;
+    onCopyAddress?: () => void;
+    onSupport?: () => void;
+    onLogout: () => void | Promise<void>;
+    loggingOut?: boolean;
+}
+declare function SettingsSheet({ walletAddress, username, avatarUrl, memberSince, appVersion, onCopyAddress, onSupport, onLogout, loggingOut, }: SettingsSheetProps): react_jsx_runtime.JSX.Element;
+
+interface UserProfileSheetProps {
+    visible: boolean;
+    onDismiss: () => void;
+    user: {
+        walletAddress: string;
+        username?: string;
+        avatar?: string | null;
+        createdAt?: string;
+    };
+    onAvatarUpdated?: (newAvatarUrl: string) => void;
+    onDisconnect?: () => void;
+}
+declare function UserProfileSheet({ visible, onDismiss, user, onAvatarUpdated, onDisconnect, }: UserProfileSheetProps): react_jsx_runtime.JSX.Element;
+
+interface DubsTheme {
+    background: string;
+    surface: string;
+    surfaceActive: string;
+    border: string;
+    text: string;
+    textSecondary: string;
+    textMuted: string;
+    textDim: string;
+    accent: string;
+    success: string;
+    live: string;
+    errorText: string;
+    errorBg: string;
+    errorBorder: string;
+}
+declare function useDubsTheme(): DubsTheme;
+/** Merge overrides into a base theme (e.g. custom accent color from developer config) */
+declare function mergeTheme(base: DubsTheme, overrides: Partial<DubsTheme>): DubsTheme;
+
+interface GamePosterProps {
+    game: GameDetail;
+    /** Optional Image component — pass expo-image or RN Image. Defaults to RN Image. */
+    ImageComponent?: React.ComponentType<any>;
+}
+/**
+ * Matchup poster hero widget.
+ * Shows the game poster image (or team logo fallback), countdown pill, and pool total.
+ */
+declare function GamePoster({ game, ImageComponent }: GamePosterProps): react_jsx_runtime.JSX.Element;
+
+interface LivePoolsCardProps {
+    game: GameDetail;
+    /** Custom short-name function for team labels. Defaults to full name. */
+    shortName?: (name: string | null) => string;
+    /** Override bar colors. Defaults to blue/red. */
+    homeColor?: string;
+    awayColor?: string;
+}
+/**
+ * Pool breakdown card showing each side's SOL amount, bar chart, and implied odds.
+ */
+declare function LivePoolsCard({ game, shortName, homeColor, awayColor, }: LivePoolsCardProps): react_jsx_runtime.JSX.Element;
+
+interface PickWinnerCardProps {
+    game: GameDetail;
+    selectedTeam: 'home' | 'away' | null;
+    onSelect: (team: 'home' | 'away') => void;
+    /** Custom short-name function for team labels. Defaults to full name. */
+    shortName?: (name: string | null) => string;
+    /** Override colors. Defaults to blue/red. */
+    homeColor?: string;
+    awayColor?: string;
+    /** Optional Image component (expo-image, etc.). */
+    ImageComponent?: React.ComponentType<any>;
+}
+/**
+ * Team selection card for picking which side to bet on.
+ */
+declare function PickWinnerCard({ game, selectedTeam, onSelect, shortName, homeColor, awayColor, ImageComponent, }: PickWinnerCardProps): react_jsx_runtime.JSX.Element;
+
+interface PlayersCardProps {
+    game: GameDetail;
+    /** How many chars to show on each side of a truncated wallet. Default 4. */
+    truncateChars?: number;
+    /** Override team dot colors. */
+    homeColor?: string;
+    awayColor?: string;
+    drawColor?: string;
+    /** Optional Image component (expo-image, etc.). */
+    ImageComponent?: React.ComponentType<any>;
+}
+/**
+ * Card showing all bettors in a game with their avatar, username, team, and wager amount.
+ */
+declare function PlayersCard({ game, truncateChars, homeColor, awayColor, drawColor, ImageComponent, }: PlayersCardProps): react_jsx_runtime.JSX.Element;
+
+interface JoinGameButtonProps {
+    game: GameDetail;
+    walletAddress: string;
+    selectedTeam: 'home' | 'away' | null;
+    status: MutationStatus;
+    onJoin: () => void;
+}
+/**
+ * Fixed bottom bar with buy-in info and join button.
+ * Renders nothing if the user already joined, or the game is locked/resolved.
+ */
+declare function JoinGameButton({ game, walletAddress, selectedTeam, status, onJoin }: JoinGameButtonProps): react_jsx_runtime.JSX.Element | null;
+
+interface CreateCustomGameSheetProps {
+    visible: boolean;
+    onDismiss: () => void;
+    title?: string;
+    maxPlayers?: number;
+    fee?: number;
+    presetAmounts?: number[];
+    defaultAmount?: number;
+    metadata?: Record<string, unknown>;
+    onAmountChange?: (amount: number | null) => void;
+    onSuccess?: (result: CreateCustomGameMutationResult) => void;
+    onError?: (error: Error) => void;
+    /** Pool mode: hides buy-in selection, uses defaultAmount, auto-assigns team, shows "Create Pool" labels */
+    isPoolModeEnabled?: boolean;
+}
+declare function CreateCustomGameSheet({ visible, onDismiss, title, maxPlayers, fee, presetAmounts, defaultAmount, metadata, onAmountChange, onSuccess, onError, isPoolModeEnabled, }: CreateCustomGameSheetProps): react_jsx_runtime.JSX.Element;
+
+interface JoinGameSheetProps {
+    visible: boolean;
+    onDismiss: () => void;
+    game: GameDetail;
+    /** Optional Image component (expo-image, etc.) for team logos */
+    ImageComponent?: React$1.ComponentType<any>;
+    /** Custom short-name function for team labels */
+    shortName?: (name: string | null) => string;
+    /** Override team colors (default blue/red/green) */
+    homeColor?: string;
+    awayColor?: string;
+    drawColor?: string;
+    /** Callbacks */
+    onSuccess?: (result: JoinGameMutationResult) => void;
+    onError?: (error: Error) => void;
+    /** Called when the user taps a team card (useful for sound/haptics) */
+    onTeamSelect?: (team: 'home' | 'away') => void;
+    /** Called when the join succeeds (useful for success sound/animation) */
+    onJoinSuccess?: (result: JoinGameMutationResult) => void;
+    /** Called on each slider tick (useful for haptics/sound) */
+    onSliderTick?: (value: number) => void;
+    /** Max wager in SOL (default 5) */
+    maxWager?: number;
+    /** Pool mode: hides team selection, auto-assigns team, shows "Join Pool" labels */
+    isPoolModeEnabled?: boolean;
+}
+declare function JoinGameSheet({ visible, onDismiss, game, ImageComponent, shortName, homeColor, awayColor, drawColor, onSuccess, onError, onTeamSelect, onJoinSuccess, onSliderTick, maxWager, isPoolModeEnabled, }: JoinGameSheetProps): react_jsx_runtime.JSX.Element;
+
+interface ClaimPrizeSheetProps {
+    visible: boolean;
+    onDismiss: () => void;
+    gameId: string;
+    /** Prize amount in SOL */
+    prizeAmount: number;
+    /** When true, shows refund language instead of prize language */
+    isRefund?: boolean;
+    /** Callbacks */
+    onSuccess?: (result: ClaimMutationResult) => void;
+    onError?: (error: Error) => void;
+}
+declare function ClaimPrizeSheet({ visible, onDismiss, gameId, prizeAmount, isRefund, onSuccess, onError, }: ClaimPrizeSheetProps): react_jsx_runtime.JSX.Element;
+
+interface ClaimButtonProps {
+    gameId: string;
+    style?: ViewStyle;
+    onSuccess?: (result: ClaimMutationResult) => void;
+    onError?: (error: Error) => void;
+}
+/**
+ * Drop-in claim button that handles eligibility checks, prize/refund display,
+ * and the claim sheet lifecycle internally.
+ *
+ * Renders nothing when the user is ineligible (lost, not resolved, not a bettor, etc.).
+ */
+declare function ClaimButton({ gameId, style, onSuccess, onError }: ClaimButtonProps): react_jsx_runtime.JSX.Element | null;
+
+interface EnterArcadePoolSheetProps {
+    visible: boolean;
+    onDismiss: () => void;
+    pool: ArcadePool;
+    stats?: ArcadePoolStats | null;
+    mode?: 'join' | 'rejoin';
+    onSuccess?: (result: EnterArcadePoolMutationResult) => void;
+    onError?: (error: Error) => void;
+}
+declare function EnterArcadePoolSheet({ visible, onDismiss, pool, stats, mode, onSuccess, onError, }: EnterArcadePoolSheetProps): react_jsx_runtime.JSX.Element;
+
+interface ArcadeLeaderboardSheetProps {
+    visible: boolean;
+    onDismiss: () => void;
+    poolId: number;
+    /** Highlighted wallet address (e.g. current user) */
+    highlightWallet?: string;
+}
+declare function ArcadeLeaderboardSheet({ visible, onDismiss, poolId, highlightWallet, }: ArcadeLeaderboardSheetProps): react_jsx_runtime.JSX.Element;
+
+interface SolSliderProps {
+    /** Current value in SOL */
+    value: number;
+    /** Min SOL (default 0.01) */
+    min?: number;
+    /** Max SOL (default 5) */
+    max?: number;
+    /** Step size in SOL (default 0.01) */
+    step?: number;
+    /** Accent color for filled track + thumb glow */
+    accentColor?: string;
+    /** Called on every drag frame */
+    onValueChange: (value: number) => void;
+    /** Called when user lifts finger */
+    onSlidingComplete?: (value: number) => void;
+    /** Called on each tick for haptics/sound */
+    onTick?: (value: number) => void;
+    /** Disabled state */
+    disabled?: boolean;
+}
+declare function SolSlider({ value, min, max, step, accentColor, onValueChange, onSlidingComplete, onTick, disabled, }: SolSliderProps): react_jsx_runtime.JSX.Element;
+
+interface CreateGameSheetProps {
+    visible: boolean;
+    onDismiss: () => void;
+    event: UnifiedEvent;
+    /** Override team colors */
+    homeColor?: string;
+    awayColor?: string;
+    /** Callbacks */
+    onSuccess?: (result: CreateGameMutationResult) => void;
+    onError?: (error: Error) => void;
+    /** Called when the user taps a team card */
+    onTeamSelect?: (team: 'home' | 'away') => void;
+    /** Called on success (for sound/animation) */
+    onCreateSuccess?: (result: CreateGameMutationResult) => void;
+    /** Called on each slider tick */
+    onSliderTick?: (value: number) => void;
+    /** Max wager in SOL */
+    maxWager?: number;
+    /** Custom short-name function for team labels */
+    shortName?: (name: string | null) => string;
+}
+declare function CreateGameSheet({ visible, onDismiss, event, homeColor, awayColor, onSuccess, onError, onTeamSelect, onCreateSuccess, onSliderTick, maxWager, shortName, }: CreateGameSheetProps): react_jsx_runtime.JSX.Element;
+
+interface JackpotCardProps {
+    round: JackpotRound | null;
+    lastWinner?: JackpotLastWinner | null;
+    entries?: JackpotEntry[];
+    onPress?: () => void;
+    style?: ViewStyle;
+}
+declare function JackpotCard({ round, lastWinner, entries, onPress, style }: JackpotCardProps): react_jsx_runtime.JSX.Element;
+
+interface JackpotSheetProps {
+    visible: boolean;
+    onDismiss: () => void;
+    onSuccess?: (result: EnterJackpotMutationResult) => void;
+    onError?: (error: Error) => void;
+    minEntry?: number;
+    maxEntry?: number;
+}
+declare function JackpotSheet({ visible, onDismiss, onSuccess, onError, minEntry, maxEntry, }: JackpotSheetProps): react_jsx_runtime.JSX.Element;
+
+interface JackpotWidgetProps {
+    /** Style applied to the card */
+    style?: ViewStyle;
+    /** Minimum entry in SOL (default: 0.01) */
+    minEntry?: number;
+    /** Maximum entry in SOL (default: 10) */
+    maxEntry?: number;
+    /** Callback when a jackpot entry succeeds */
+    onEntry?: (result: EnterJackpotMutationResult) => void;
+    /** Callback on entry error */
+    onError?: (error: Error) => void;
+}
+/**
+ * Self-contained Jackpot widget — the first "crypto ad".
+ *
+ * Drop `<JackpotWidget />` anywhere in your app. Shows a live jackpot card
+ * matching the web lobby design with pot amount, player carousel, and
+ * Place Bet button. Tapping opens a scrollable sheet with full entry flow.
+ */
+declare function JackpotWidget({ style, minEntry, maxEntry, onEntry, onError, }: JackpotWidgetProps): react_jsx_runtime.JSX.Element;
+
+interface ChatMessage {
+    id: number;
+    userId: number;
+    walletAddress: string;
+    username: string;
+    avatar: string | null;
+    message: string;
+    replyTo: {
+        id: number;
+        message: string;
+        username: string;
+        walletAddress: string;
+    } | null;
+    timestamp: string;
+    edited: boolean;
+    editedAt: string | null;
+    isWinnerAnnouncement: boolean;
+    winAmount?: number;
+    roundId?: number;
+    gameInvite: Record<string, unknown> | null;
+    pnlShare: Record<string, unknown> | null;
+    gifUrl: string | null;
+    reactions: Record<string, {
+        count: number;
+        reactors: string[];
+    }>;
+    mentions: ChatMention[];
+    payment: ChatPayment | null;
+}
+interface ChatMention {
+    userId: number;
+    username: string;
+    walletAddress: string;
+}
+interface ChatPayment {
+    id: number;
+    senderUsername: string;
+    recipientUsername: string;
+    amount: number;
+    signature: string;
+    status: string;
+    errorMessage: string | null;
+    createdAt: string;
+    confirmedAt: string | null;
+}
+interface DirectMessage {
+    id: number;
+    senderId: number;
+    recipientId?: number;
+    senderUsername: string;
+    senderAvatar: string | null;
+    senderWallet: string;
+    message: string;
+    read: boolean;
+    createdAt: string;
+    isOwn: boolean;
+    gameInvite: Record<string, unknown> | null;
+}
+interface Conversation {
+    otherUserId: number;
+    otherUsername: string;
+    otherAvatar: string | null;
+    otherWallet: string;
+    lastMessage: string;
+    lastMessageAt: string;
+    unreadCount: number;
+}
+interface FriendUser {
+    userId: number;
+    username: string;
+    avatar: string | null;
+    walletAddress: string;
+    friendsSince?: string;
+    isFriend?: boolean;
+    isBlocked?: boolean;
+    friendRequestSent?: boolean;
+    friendRequestReceived?: boolean;
+    friendRequestId?: number;
+}
+interface FriendRequest {
+    id: number;
+    fromUserId: number;
+    fromUsername: string;
+    fromAvatar: string | null;
+    fromWallet: string;
+    createdAt: string;
+}
+interface OnlineUser {
+    walletAddress: string;
+    username: string;
+    avatar: string | null;
+}
+interface TypingEvent {
+    userId: number;
+    username: string;
+    walletAddress: string;
+    isTyping: boolean;
+}
+interface ChatNotification {
+    id: number;
+    type: string;
+    read: boolean;
+    message: string;
+    messageId?: number;
+    senderUsername: string;
+    senderWallet: string;
+    senderAvatar: string | null;
+    createdAt: string;
+    [key: string]: unknown;
+}
+type ChatConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+interface SendMessageParams {
+    message: string;
+    replyToId?: number;
+    mentions?: number[];
+    gifUrl?: string;
+    gameInvite?: Record<string, unknown>;
+    pnlShare?: Record<string, unknown>;
+}
+interface SendDMParams {
+    recipientWallet: string;
+    message: string;
+    gameInvite?: Record<string, unknown>;
+    animation?: string;
+}
+
+interface ChatSocketConfig {
+    /** Server origin, e.g. "https://dubs-server-prod-xxx.herokuapp.com" */
+    host: string;
+    /** JWT token for authentication */
+    token: string;
+}
+interface ChatSocketListeners {
+    onConnectionChange?: (status: ChatConnectionStatus) => void;
+    onNewMessage?: (message: ChatMessage) => void;
+    onOnlineUsers?: (users: OnlineUser[]) => void;
+    onOnlineCount?: (count: number) => void;
+    onTyping?: (data: {
+        userId: number;
+        username: string;
+        walletAddress: string;
+        isTyping: boolean;
+    }) => void;
+    onReactionAdded?: (data: {
+        messageId: number;
+        userId: number;
+        reaction: string;
+        walletAddress: string;
+    }) => void;
+    onReactionRemoved?: (data: {
+        messageId: number;
+        userId: number;
+        reaction: string;
+    }) => void;
+    onNotification?: (notification: ChatNotification) => void;
+    onUnreadCount?: (count: number) => void;
+    onDMNewMessage?: (message: DirectMessage) => void;
+    onDMMessageSent?: (message: DirectMessage) => void;
+    onDMNotification?: (data: {
+        senderId: number;
+        senderUsername: string;
+        senderAvatar: string | null;
+        senderWallet: string;
+        preview: string;
+        createdAt: string;
+    }) => void;
+    onDMMessagesRead?: (data: {
+        readBy: number;
+        readByWallet: string;
+    }) => void;
+    onFriendRequestAccepted?: (data: {
+        requestId: number;
+        acceptedBy: number;
+        acceptedByUsername: string;
+    }) => void;
+    onFriendRequestDeclined?: (data: {
+        requestId: number;
+        declinedBy: number;
+    }) => void;
+    onFriendRemoved?: (data: {
+        removedBy: number;
+    }) => void;
+    onError?: (error: {
+        message: string;
+    }) => void;
+}
+/**
+ * Manages the Socket.IO connection to the Dubs chat namespace.
+ */
+declare class ChatSocket {
+    private socket;
+    private listeners;
+    /** Set event listeners. Call before or after connect. */
+    setListeners(listeners: ChatSocketListeners): void;
+    /** Connect to the /chat namespace */
+    connect(config: ChatSocketConfig): void;
+    /** Disconnect from the chat namespace */
+    disconnect(): void;
+    /** Whether the socket is currently connected */
+    isConnected(): boolean;
+    /** Send a message to global chat */
+    sendMessage(params: SendMessageParams): void;
+    /** Emit typing indicator */
+    sendTyping(isTyping: boolean): void;
+    /** Add an emoji reaction to a message */
+    addReaction(messageId: number, reaction: string): void;
+    /** Remove an emoji reaction from a message */
+    removeReaction(messageId: number, reaction: string): void;
+    /** Join a DM room to receive messages in real-time */
+    joinDM(recipientWallet: string): void;
+    /** Leave a DM room */
+    leaveDM(recipientWallet: string): void;
+    /** Send a direct message via socket */
+    sendDM(params: SendDMParams): void;
+    /** Mark DMs from a sender as read */
+    markDMRead(senderWallet: string): void;
+}
+
+interface ChatContextValue {
+    /** The underlying socket manager */
+    socket: ChatSocket;
+    /** Connection status */
+    status: ChatConnectionStatus;
+    /** Global chat messages (newest last) */
+    messages: ChatMessage[];
+    /** Currently online users */
+    onlineUsers: OnlineUser[];
+    /** Online user count */
+    onlineCount: number;
+    /** Unread notification count */
+    unreadCount: number;
+    /** DM conversations */
+    conversations: Conversation[];
+    /** Friends list */
+    friends: FriendUser[];
+    /** Pending friend requests */
+    pendingRequests: FriendRequest[];
+    /** Reload messages from REST */
+    refreshMessages: () => Promise<void>;
+    /** Reload conversations from REST */
+    refreshConversations: () => Promise<void>;
+    /** Reload friends from REST */
+    refreshFriends: () => Promise<void>;
+    /** Reload pending friend requests from REST */
+    refreshPendingRequests: () => Promise<void>;
+}
+interface ChatProviderProps {
+    children: React$1.ReactNode;
+    /** Set to false to disable auto-connect on mount. Default: true */
+    autoConnect?: boolean;
+}
+/**
+ * Provides chat, DM, and social context to child components.
+ * Must be rendered inside a <DubsProvider>.
+ */
+declare function ChatProvider({ children, autoConnect }: ChatProviderProps): react_jsx_runtime.JSX.Element;
+/** Access the chat context. Must be used inside <ChatProvider>. */
+declare function useChatContext(): ChatContextValue;
+
+/** Get the current chat connection status */
+declare function useChatStatus(): ChatConnectionStatus;
+/** Get global chat messages with refetch */
+declare function useChatMessages(): {
+    messages: ChatMessage[];
+    loading: boolean;
+    refetch: () => Promise<void>;
+};
+/** Send a message to global chat (via socket for real-time, falls back to REST) */
+declare function useSendMessage(): {
+    send: (params: SendMessageParams) => void;
+    sendViaREST: (params: {
+        message: string;
+        replyToId?: number;
+    }) => Promise<void>;
+};
+/** Get online users and count */
+declare function useOnlineUsers(): {
+    users: OnlineUser[];
+    count: number;
+};
+/** Get unread notification count */
+declare function useUnreadCount(): number;
+/** Get DM conversations inbox */
+declare function useConversations(): {
+    conversations: Conversation[];
+    loading: boolean;
+    refetch: () => Promise<void>;
+};
+/** Get DM thread with a specific user by wallet address */
+declare function useDirectMessages(recipientWallet: string): {
+    messages: DirectMessage[];
+    loading: boolean;
+    otherUser: {
+        id: number;
+        username: string;
+        avatar: string | null;
+        walletAddress: string;
+    } | null;
+    send: (message: string) => void;
+    sendViaREST: (message: string) => Promise<void>;
+    markRead: () => void;
+    refetch: () => Promise<void>;
+};
+/** Get friends list */
+declare function useFriends(): {
+    friends: FriendUser[];
+    loading: boolean;
+    refetch: () => Promise<void>;
+};
+/** Get pending friend requests */
+declare function useFriendRequests(): {
+    requests: FriendRequest[];
+    loading: boolean;
+    refetch: () => Promise<void>;
+};
+/** Search for users by username */
+declare function useSearchUsers(): {
+    results: FriendUser[];
+    loading: boolean;
+    search: (query: string) => Promise<void>;
+    clear: () => void;
+};
+/** Send a friend request */
+declare function useSendFriendRequest(): {
+    send: (targetUserId: number) => Promise<void>;
+    loading: boolean;
+};
+/** Accept or reject a friend request */
+declare function useRespondToFriendRequest(): {
+    accept: (requestId: number) => Promise<void>;
+    reject: (requestId: number) => Promise<void>;
+    loading: boolean;
+};
+
+/**
+ * Deserialize a base64-encoded transaction, sign via wallet adapter, send to Solana.
+ * Prefers signAndSendTransaction if available (MWA), otherwise falls back to
+ * signTransaction + sendRawTransaction via RPC (Phantom deeplinks).
+ * Returns the transaction signature.
+ */
+declare function signAndSendBase64Transaction(base64Tx: string, wallet: WalletAdapter, connection: Connection): Promise<string>;
+
+/**
+ * Ensure a DiceBear avatar URL uses PNG format for React Native compatibility.
+ * React Native's Image component cannot render SVGs.
+ * This converts at render time only — the stored URL in the DB is never modified.
+ */
+declare function ensurePngAvatar(url: string | null | undefined): string | undefined;
+
+export { type ArcadeAttempt, type ArcadeCountdown, type ArcadeEntry, type ArcadeLeaderboardEntry, ArcadeLeaderboardSheet, type ArcadeLeaderboardSheetProps, type ArcadePool, type ArcadePoolResult, type ArcadePoolStats, AuthGate, type ConnectWalletScreenProps$1 as AuthGateConnectWalletProps, type AuthGateProps, type AuthStatus, type AuthenticateParams, type AuthenticateResult, type Bettor, type BuildArcadeEntryResult, type BuildClaimParams, type BuildClaimResult, type BuildJackpotEnterResult, type ChatConnectionStatus, type ChatContextValue, type ChatMention, type ChatMessage, type ChatNotification, type ChatPayment, ChatProvider, type ChatProviderProps, ChatSocket, type ChatSocketConfig, type ChatSocketListeners, type CheckUsernameResult, ClaimButton, type ClaimButtonProps, type ClaimMutationResult, ClaimPrizeSheet, type ClaimPrizeSheetProps, type ClaimStatus, type ConfirmClaimParams, type ConfirmClaimResult, type ConfirmGameParams, type ConfirmGameResult, type ConfirmJackpotEnterResult, ConnectWalletButton, type ConnectWalletButtonProps, ConnectWalletScreen, type ConnectWalletScreenProps, type Conversation, type CreateCustomGameMutationResult, type CreateCustomGameParams, type CreateCustomGameResult, CreateCustomGameSheet, type CreateCustomGameSheetProps, type CreateGameMutationResult, type CreateGameParams, type CreateGameResult, CreateGameSheet, type CreateGameSheetProps, DEFAULT_BASE_URL, DEFAULT_RPC_URL, type DeviceInfo, type DirectMessage, DubsApiError, type DubsAppUser, DubsClient, type DubsClientConfig, type DubsContextValue, type DubsNetwork, DubsProvider, type DubsProviderProps, type DubsPublicUser, type DubsTheme, type DubsUser, type EnterArcadePoolMutationResult, type EnterArcadePoolResult, EnterArcadePoolSheet, type EnterArcadePoolSheetProps, type EnterJackpotMutationResult, type EsportsMatchDetail, type EsportsMatchOpponent, type EsportsMatchResult, type EventMedia, type EventMeta, type EventStream, type FriendRequest, type FriendUser, type GameDetail, type GameListItem, type GameListOpponent, type GameMedia, GamePoster, type GamePosterProps, type GetGamesParams, type GetNetworkGamesParams, type GetUpcomingEventsParams, type HighlightVideo, JackpotCard, type JackpotCardProps, type JackpotConfig, type JackpotEntry, type JackpotLastWinner, type JackpotRound, type JackpotRoundResult, JackpotSheet, type JackpotSheetProps, JackpotWidget, type JackpotWidgetProps, JoinGameButton, type JoinGameButtonProps, type JoinGameMutationResult, type JoinGameParams, type JoinGameResult, JoinGameSheet, type JoinGameSheetProps, LivePoolsCard, type LivePoolsCardProps, type LiveScore, type LiveScoreCompetitor, type MutationResult, type MutationStatus, type MwaAdapterConfig, type MwaTransactFn, MwaWalletAdapter, NETWORK_CONFIG, type NonceResult, type OnlineUser, type Opponent, type Pagination, type ParsedError, PhantomDeeplinkAdapter, type PhantomDeeplinkAdapterConfig, type PhantomSession, PickWinnerCard, type PickWinnerCardProps, PlayersCard, type PlayersCardProps, type PushNotificationStatus, type QueryResult, type RegisterParams, type RegisterResult, type RegistrationScreenProps, SOLANA_PROGRAM_ERRORS, STORAGE_KEYS, type SendDMParams, type SendMessageParams, SettingsSheet, type SettingsSheetProps, type ShortVideo, SolSlider, type SolSliderProps, type SolanaErrorCode, type StartAttemptResult, type SubmitScoreResult, type TokenStorage, type TypingEvent, type UFCData, type UFCEvent, type UFCFight, type UFCFighter, type UFCFighterDetail, type UiConfig, type UnifiedEvent, type UseArcadeBridgeOptions, type UseArcadeBridgeResult, type UseArcadeGameResult, type UseArcadePoolResult, type UseArcadePoolsResult, type UseAuthResult, type UseJackpotHistoryResult, type UseJackpotResult, UserProfileCard, type UserProfileCardProps, UserProfileSheet, type UserProfileSheetProps, type ValidateEventResult, type WalletAdapter, createSecureStoreStorage, ensurePngAvatar, getDeviceInfo, isSolanaSeeker, mergeTheme, parseSolanaError, signAndSendBase64Transaction, useAppConfig, useArcadeBridge, useArcadeCountdown, useArcadeGame, useArcadePool, useArcadePools, useAuth, useChatContext, useChatMessages, useChatStatus, useClaim, useConversations, useCreateCustomGame, useCreateGame, useDirectMessages, useDubs, useDubsTheme, useEnterArcadePool, useEnterJackpot, useEvents, useFriendRequests, useFriends, useGame, useGames, useHasClaimed, useHighlights, useJackpot, useJackpotHistory, useJoinGame, useNetworkGames, useOnlineUsers, usePushNotifications, useRespondToFriendRequest, useSearchUsers, useSendFriendRequest, useSendMessage, useShorts, useUFCFightCard, useUFCFighterDetail, useUnreadCount };