@dimcool/sdk 0.1.0-beta.1

package/dist/index.d.cts

@@ -0,0 +1,2629 @@
+import { Transaction } from '@solana/web3.js';
+import { RpsGameAction, RpsGameState, RpsAction } from '@dimcool/rps';
+import { ChessGameAction, ChessGameState, ChessMovePayload } from '@dimcool/chess';
+import { NimGameAction, NimGameState } from '@dimcool/nim';
+import { DotsAndBoxesGameAction, DotsAndBoxesGameState } from '@dimcool/dots-and-boxes';
+import { TicTacToeGameAction, TicTacToeGameState } from '@dimcool/tic-tac-toe';
+import { Connect4GameAction, Connect4GameState } from '@dimcool/connect-four';
+export { MICRO_UNITS, formatMoneyMinor, toMajor } from '@dimcool/utils';
+
+/**
+ * Interface for HTTP client implementations.
+ * Allows for dependency injection and testing with custom implementations.
+ */
+interface IHttpClient {
+    /**
+     * Make a generic HTTP request
+     */
+    request<T>(endpoint: string, options?: RequestInit): Promise<T>;
+    /**
+     * Make a GET request
+     */
+    get<T>(endpoint: string, options?: RequestInit): Promise<T>;
+    /**
+     * Make a POST request
+     */
+    post<T>(endpoint: string, data?: any, options?: RequestInit): Promise<T>;
+    /**
+     * Make a PATCH request
+     */
+    patch<T>(endpoint: string, data?: any, options?: RequestInit): Promise<T>;
+    /**
+     * Make a DELETE request
+     */
+    delete<T>(endpoint: string, options?: RequestInit): Promise<T>;
+    /**
+     * Upload a file using FormData
+     */
+    upload<T>(endpoint: string, formData: FormData): Promise<T>;
+}
+
+declare const TOKEN_KEY = "dim_sdk_token";
+interface IStorage {
+    set(key: string, value: string): void;
+    get(key: string): string | null;
+    delete(key: string): void;
+}
+declare class BrowserLocalStorage implements IStorage {
+    set(key: string, value: string): void;
+    get(key: string): string | null;
+    delete(key: string): void;
+}
+declare class NodeStorage implements IStorage {
+    private storage;
+    private readonly instanceId;
+    constructor();
+    set(key: string, value: string): void;
+    get(key: string): string | null;
+    delete(key: string): void;
+    /**
+     * Get the instance ID for debugging/verification
+     * @internal
+     */
+    getInstanceId(): string;
+}
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface ILogger {
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+declare class Logger implements ILogger {
+    private level;
+    private prefix;
+    constructor(prefix?: string);
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+    private shouldLog;
+    private formatMessage;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+declare const logger: Logger;
+declare const createLogger: (prefix: string) => Logger;
+
+type WsEventHandler = (payload: unknown) => void;
+type WsWildcardHandler = (event: string, payload: unknown) => void;
+interface WsTransport {
+    connect(): void;
+    disconnect(): void;
+    setAccessToken(token: string): void;
+    clearAccessToken(): void;
+    setAppId(appId: string): void;
+    waitUntilConnected(timeoutMs?: number): Promise<void>;
+    getConnectionState(): ConnectionState;
+    resetRooms(): void;
+    subscribeEvent(eventName: string, handler: WsEventHandler): () => void;
+    subscribeAll(handler: WsWildcardHandler): () => void;
+    joinRoom(roomName: string): () => void;
+    emit(eventName: string, payload?: unknown): void;
+}
+interface ConnectionState {
+    connected: boolean;
+    connecting: boolean;
+    error: string | null;
+}
+
+interface SDKConfig {
+    appId: string;
+    baseUrl?: string;
+    storage: IStorage;
+    httpClient?: IHttpClient;
+    wsTransport?: WsTransport;
+    logger?: ILogger;
+}
+type MoneyMinor = number;
+interface LoginResponse {
+    access_token: string;
+    user: {
+        id: string;
+        email: string | null;
+        username?: string | null;
+        isAdmin: boolean;
+        avatar?: string;
+        coverImage?: string;
+        bio?: string;
+        chessElo: number;
+        points: number;
+    };
+}
+interface GenerateHandshakeResponse {
+    message: string;
+    nonce: string;
+}
+/**
+ * Metadata about the wallet used for authentication.
+ * Used to track which wallet provider was used for login.
+ */
+interface WalletMeta {
+    /** The type of wallet connection */
+    type: 'phantom-embedded' | 'keypair';
+    /** The OAuth/connection provider (for phantom-embedded) */
+    provider?: 'google' | 'apple' | 'injected';
+    /** The name of the wallet (e.g., 'phantom', 'solflare') */
+    walletName?: string;
+}
+interface User {
+    id: string;
+    email: string | null;
+    username?: string | null;
+    isAdmin: boolean;
+    avatar?: string;
+    coverImage?: string;
+    bio?: string;
+    chessElo: number;
+    points: number;
+    createdAt: string;
+    updatedAt: string;
+    banned?: boolean;
+    bannedAt?: string;
+    bannedReason?: string;
+    loginAddress?: string | null;
+}
+interface PaginatedUsers {
+    users: User[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface FeatureFlag {
+    id: string;
+    name: string;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ApiError {
+    error?: string;
+    message?: string | string[];
+    statusCode?: number;
+    code?: string;
+}
+interface UsernameAvailabilityResponse {
+    valid: boolean;
+    available: boolean;
+}
+interface PublicUser {
+    id: string;
+    username?: string;
+    avatar?: string;
+    coverImage?: string;
+    bio?: string;
+    chessElo: number;
+    points: number;
+    connectedStatus: 'online' | 'away' | 'offline';
+    lastConnectedAt?: string;
+    createdAt: string;
+    updatedAt: string;
+    friendsCount: number;
+    friendshipStatus?: 'none' | 'incoming' | 'outgoing' | 'friends';
+    /** Number of unique users currently spectating this user. Only present on profile / game views. */
+    spectatorCount?: number;
+}
+interface PaginatedFriends {
+    friends: PublicUser[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface SearchUser {
+    id: string;
+    username?: string;
+    avatar?: string;
+    chessElo: number;
+    connectedStatus: 'online' | 'away' | 'offline';
+    lastConnectedAt?: string;
+    createdAt: string;
+    updatedAt: string;
+    friendshipStatus?: 'none' | 'incoming' | 'outgoing' | 'friends';
+    walletAddress?: string;
+}
+interface FriendRequestItem {
+    id: string;
+    user: PublicUser;
+    mutualFriendsCount: number;
+    createdAt: string;
+}
+interface PaginatedSearchUsers {
+    users: SearchUser[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface Session {
+    id: string;
+    userId: string;
+    loginMethod: 'email' | 'wallet';
+    walletMeta?: WalletMeta;
+    timestamp: string;
+    user?: {
+        id: string;
+        email: string | null;
+        username: string | null;
+        isAdmin: boolean;
+        avatar?: string;
+    };
+}
+interface PaginatedSessions {
+    sessions: Session[];
+    total: number;
+}
+type ActivityFeedItemType = 'new_user' | 'win' | 'lobby_created' | 'game_started';
+interface ActivityFeedUser {
+    id: string;
+    username: string;
+    avatarUrl?: string;
+}
+interface ActivityFeedItem {
+    id: string;
+    type: ActivityFeedItemType;
+    user: ActivityFeedUser;
+    opponent?: ActivityFeedUser;
+    game?: string;
+    amount?: number;
+    timestamp: number;
+}
+interface ActivityFeedResponse {
+    items: ActivityFeedItem[];
+}
+interface LeaderboardEntry {
+    rank: number;
+    userId: string;
+    username: string;
+    avatar?: string;
+    wins: number;
+    losses: number;
+    winRate: number;
+    gameEarnings: MoneyMinor;
+    referralEarnings: MoneyMinor;
+    earnings: MoneyMinor;
+}
+interface LeaderboardResponse {
+    entries: LeaderboardEntry[];
+    generatedAt: string;
+}
+interface LeaderboardQuery {
+    startDate?: string;
+    endDate?: string;
+    limit?: number;
+}
+type LeaderboardRange = LeaderboardQuery;
+interface CurrentGame {
+    gameId: string;
+    gameType: string;
+    status: string;
+}
+/** User activity for spectate flow. GET /users/:userId/activity */
+type UserActivityStatus = 'in_game' | 'in_lobby' | 'idle';
+interface UserActivity {
+    status: UserActivityStatus;
+    gameId?: string;
+    gameType?: string;
+    lobbyId?: string;
+    lobbyStatus?: string;
+}
+interface GameHistoryItem {
+    id: string;
+    gameType: string;
+    gameName: string;
+    gameImage?: string;
+    result: 'win' | 'loss' | 'draw';
+    betAmount: MoneyMinor;
+    winnings?: MoneyMinor;
+    opponent?: {
+        id: string;
+        username?: string;
+        avatar?: string;
+    };
+    playedAt: string;
+    depositTransactionHashes?: string[];
+    payoutTransactionHash?: string;
+}
+interface UserStats {
+    gamesPlayed: number;
+    wins: number;
+    losses: number;
+    totalEarned: MoneyMinor;
+    referralEarned: MoneyMinor;
+    totalLost: MoneyMinor;
+    totalFeesPaid: MoneyMinor;
+    chessElo: number;
+    points: number;
+    marketOrdersPlaced: number;
+}
+interface AdminStats {
+    /** Fee payer wallet public key (base58), when configured. */
+    feePayerWalletAddress: string | null;
+    /** Escrow wallet public key (base58), when configured. */
+    escrowWalletAddress: string | null;
+    totalGamesPlayed: number;
+    totalFeesGenerated: MoneyMinor;
+    totalFeesPaid: MoneyMinor;
+    totalFeesUnpaid: MoneyMinor;
+    totalVolume: MoneyMinor;
+    totalUsers: number;
+    totalFriendships: number;
+    pendingFriendRequests: number;
+    /** Total confirmed P2P transfers. */
+    totalTransferCount: number;
+    /** Aggregate USDC fees collected from P2P transfers (minor units). */
+    totalTransferFeesUsdc: MoneyMinor;
+    /** Aggregate SOL fees collected from P2P transfers (lamports). */
+    totalTransferFeesSol: number;
+    /** Fee payer wallet SOL balance (float, SOL). */
+    feePayerSolBalance: number;
+    /** Fee payer wallet USDC balance (minor units). */
+    feePayerUsdcBalance: number;
+    /** Escrow wallet SOL balance (float, SOL). */
+    escrowSolBalance: number;
+    /** Escrow wallet USDC balance (minor units). */
+    escrowUsdcBalance: MoneyMinor;
+    /** Total unsettled liabilities reserved in escrow (minor units). */
+    escrowLiabilitiesUsdc: MoneyMinor;
+    /** Total accrued fees according to accounting sources (minor units). */
+    accruedFeesUsdc: MoneyMinor;
+    /** Configured reserve buffer that cannot be swept (minor units). */
+    reserveBufferUsdc: MoneyMinor;
+    /** Maximum safe sweepable amount right now (minor units). */
+    maxSweepableUsdc: MoneyMinor;
+    /** Last successful sweep amount (minor units). */
+    lastSweepAmountUsdc: MoneyMinor;
+    /** Last successful sweep tx hash. */
+    lastSweepTxHash: string | null;
+    /** Last successful sweep confirmation time. */
+    lastSweepAt: string | null;
+    /** Total ATAs funded by the fee payer. */
+    totalAtasFunded: number;
+    /** Estimated total cost of funded ATAs (lamports). */
+    estimatedAtaCostLamports: number;
+    /** Total prediction markets created. */
+    totalMarkets: number;
+    /** Total volume traded across all prediction markets (minor units). */
+    totalMarketVolume: MoneyMinor;
+    /** Total fees collected from prediction markets (minor units). */
+    totalMarketFees: MoneyMinor;
+}
+interface EscrowSweepPreview {
+    escrowSolBalance: number;
+    escrowUsdcBalance: MoneyMinor;
+    accruedFeesUsdc: MoneyMinor;
+    reserveBufferUsdc: MoneyMinor;
+    maxSweepableUsdc: MoneyMinor;
+    liabilities: Record<string, MoneyMinor>;
+}
+interface EscrowSweepRecord {
+    id: string;
+    requestedByUserId: string;
+    requestedAmount: MoneyMinor;
+    approvedAmount: MoneyMinor;
+    destinationAddress: string;
+    txHash: string | null;
+    status: 'PENDING' | 'CONFIRMED' | 'FAILED';
+    errorMessage: string | null;
+    createdAt: string;
+    confirmedAt: string | null;
+    failedAt: string | null;
+}
+type CriticalIncidentSeverity = 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW';
+type CriticalIncidentStatus = 'OPEN' | 'ACKNOWLEDGED' | 'RESOLVED';
+type CriticalIncidentImpactType = 'FUNDS_LOSS' | 'FUNDS_LOCKED' | 'UNAUTHORIZED_TRANSFER' | 'ACCOUNTING_MISMATCH';
+type CriticalIncidentCategory = 'GAME_PAYOUT_FAILED' | 'BET_PAYOUT_FAILED' | 'ESCROW_SWEEP_FAILED' | 'ESCROW_SWEEP_STUCK' | 'REFUND_FAILED' | 'TRANSFER_AUTH_MISMATCH' | 'DEPOSIT_OWNERSHIP_MISMATCH' | 'TRANSACTION_STUCK' | 'RECONCILIATION_MISMATCH';
+interface CriticalIncident {
+    id: string;
+    fingerprint: string;
+    category: CriticalIncidentCategory;
+    severity: CriticalIncidentSeverity;
+    status: CriticalIncidentStatus;
+    impactType: CriticalIncidentImpactType;
+    source: string;
+    sourceKey?: string | null;
+    title: string;
+    description: string;
+    amountMinor?: MoneyMinor | null;
+    currencyMint?: string | null;
+    walletTransactionSignature?: string | null;
+    relatedSignature?: string | null;
+    gameHistoryId?: string | null;
+    marketId?: string | null;
+    lobbyId?: string | null;
+    userId?: string | null;
+    escrowSweepId?: string | null;
+    retryCount: number;
+    lastError?: string | null;
+    lastEscalatedAt?: string | null;
+    escalationAttempts: number;
+    lastEscalationError?: string | null;
+    detectedAt: string;
+    resolvedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CriticalIncidentSummary {
+    openCritical: number;
+    openHigh: number;
+    openTotal: number;
+    impactedAmountMinor: MoneyMinor;
+    freshest: CriticalIncident[];
+}
+interface PaginatedCriticalIncidents {
+    items: CriticalIncident[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface AdminDailyStatsItem {
+    date: string;
+    gamesPlayed: number;
+    platformFees: MoneyMinor;
+    referralFees: MoneyMinor;
+    bettingFees: MoneyMinor;
+    marketFees: MoneyMinor;
+}
+interface AdminDailyStats {
+    days: AdminDailyStatsItem[];
+}
+interface ReferralSummary {
+    code: string | null;
+    link?: string;
+    hasReferrer: boolean;
+    totals: {
+        level1: MoneyMinor;
+        level2: MoneyMinor;
+        level3: MoneyMinor;
+    };
+    earnings: {
+        pending: MoneyMinor;
+        claimed: MoneyMinor;
+    };
+}
+interface ApplyReferralCodeResponse {
+    success: boolean;
+    referrerUsername: string;
+}
+interface ReferralTreeItem {
+    id: string;
+    username?: string | null;
+    createdAt: string;
+}
+interface ReferralTreeResponse {
+    level: 1 | 2 | 3;
+    items: ReferralTreeItem[];
+    nextCursor?: string;
+}
+type ReferralRewardStatus = 'PENDING' | 'CLAIMED' | 'CANCELLED';
+interface ReferralRewardItem {
+    id: string;
+    referredUserId: string;
+    referredUsername?: string | null;
+    gameHistoryId: string;
+    level: number;
+    amount: MoneyMinor;
+    status: ReferralRewardStatus;
+    createdAt: string;
+    claimedAt?: string;
+}
+interface ReferralRewardsResponse {
+    items: ReferralRewardItem[];
+    nextCursor?: string;
+}
+interface ClaimReferralRewardsResponse {
+    claimedCount: number;
+    claimedAmount: MoneyMinor;
+    walletTransactionSignature?: string;
+}
+type ReportStatus = 'PENDING' | 'READ' | 'RESOLVED' | 'DISMISSED';
+interface ReportUser {
+    id: string;
+    username?: string;
+    avatar?: string;
+}
+interface Report {
+    id: string;
+    reporterId: string;
+    reportedUserId: string;
+    reason: string;
+    status: ReportStatus;
+    adminNotes?: string;
+    createdAt: string;
+    updatedAt: string;
+    reporter?: ReportUser;
+    reportedUser?: ReportUser;
+}
+interface PaginatedReports {
+    reports: Report[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface ReportCount {
+    count: number;
+}
+type SupportTicketStatus = 'OPEN' | 'IN_PROGRESS' | 'WAITING_REPLY' | 'RESOLVED' | 'CLOSED';
+type SupportTicketCategory = 'BUG' | 'FEATURE_REQUEST' | 'QUESTION' | 'ACCOUNT' | 'PAYMENT' | 'GAME' | 'TECHNICAL' | 'OTHER';
+type SupportTicketPriority = 'LOW' | 'NORMAL' | 'HIGH' | 'URGENT';
+type SupportMessageSenderRole = 'USER' | 'ADMIN';
+interface SupportTicketUser {
+    id: string;
+    username?: string;
+    avatar?: string;
+}
+interface SupportMessage {
+    id: string;
+    ticketId: string;
+    senderId: string;
+    senderRole: SupportMessageSenderRole;
+    content: string;
+    createdAt: string;
+    sender?: SupportTicketUser;
+}
+interface SupportTicket {
+    id: string;
+    userId: string;
+    subject: string;
+    category: SupportTicketCategory;
+    status: SupportTicketStatus;
+    priority: SupportTicketPriority;
+    createdAt: string;
+    updatedAt: string;
+    user?: SupportTicketUser;
+    messages?: SupportMessage[];
+    messageCount?: number;
+}
+interface PaginatedSupportTickets {
+    tickets: SupportTicket[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+type AppNotificationType = 'challenge_received' | 'challenge_accepted' | 'challenge_declined' | 'friend_request' | 'friend_accepted' | 'game_invite' | 'game_result' | 'achievement' | 'system' | 'usd_received';
+interface AppNotification {
+    id: string;
+    type: AppNotificationType;
+    title: string;
+    message: string;
+    read: boolean;
+    fromUserId?: string;
+    fromUsername?: string;
+    avatar?: string;
+    actionPayload?: Record<string, unknown>;
+    createdAt: string;
+}
+interface PaginatedNotificationsResponse {
+    notifications: AppNotification[];
+    total: number;
+    page: number;
+    limit: number;
+    unreadCount: number;
+}
+interface Achievement {
+    id: string;
+    code: string;
+    name: string;
+    description: string | null;
+    category: string | null;
+    icon: string | null;
+}
+interface UserAchievement {
+    achievementId: string;
+    code: string;
+    name: string;
+    description: string | null;
+    icon: string | null;
+    unlockedAt: string;
+}
+
+interface WalletResponse {
+    publicKey: string;
+}
+/**
+ * Interface for wallet signing operations.
+ * Allows plugging in different signing implementations (e.g., Phantom, Keypair).
+ */
+interface WalletSigner {
+    /**
+     * Optional wallet address used by auth flows that require address resolution.
+     * Example: Solana base58 public key.
+     */
+    address?: string;
+    /**
+     * Sign a message and return the signature
+     * @param message - The message to sign (typically a string)
+     * @returns The signature as Uint8Array or base64 string
+     */
+    signMessage: (message: string) => Promise<Uint8Array | string>;
+    /**
+     * Sign a transaction
+     * @param transaction - The Solana transaction to sign
+     * @returns The signed transaction
+     */
+    signTransaction: (transaction: Transaction) => Promise<Transaction>;
+}
+interface BalanceResponse {
+    sol: number;
+    usdc: MoneyMinor;
+    publicKey: string;
+}
+type WalletActivityKind = 'DEPOSIT' | 'REFUND' | 'PAYOUT' | 'TRANSFER';
+type WalletActivityStatus = 'SIGNED' | 'CONFIRMED' | 'FAILED' | 'MISSING';
+type WalletActivityDirection = 'IN' | 'OUT';
+type WalletActivityCounterpartyType = 'USER' | 'GAME' | 'LOBBY' | 'SYSTEM';
+type WalletClaimAction = {
+    type: 'lobby_deposit_refund';
+    lobbyId: string;
+    depositSignature: string;
+} | {
+    type: 'game_payout';
+    gameHistoryId: string;
+    gameId: string;
+} | {
+    type: 'referral_rewards_claim';
+};
+interface WalletActivityItem {
+    id: string;
+    signature?: string;
+    kind: WalletActivityKind;
+    status: WalletActivityStatus;
+    direction: WalletActivityDirection;
+    amount: MoneyMinor;
+    mint: string;
+    createdAt: string;
+    confirmedAt?: string;
+    context: {
+        type?: 'LOBBY' | 'GAME' | 'REFERRAL' | 'P2P';
+        id?: string;
+    };
+    counterparty: {
+        type: WalletActivityCounterpartyType;
+        username?: string;
+        id?: string;
+    };
+    claimable: boolean;
+    claimAction?: WalletClaimAction;
+    displayTitle?: string;
+    displaySubtitle?: string;
+}
+interface WalletActivityResponse {
+    items: WalletActivityItem[];
+    nextCursor?: string;
+}
+/** Admin only: one row per transaction with from/to user identification. */
+interface AdminWalletActivityItem {
+    id: string;
+    signature?: string;
+    kind: WalletActivityKind;
+    status: WalletActivityStatus;
+    direction: WalletActivityDirection;
+    amount: MoneyMinor;
+    mint: string;
+    createdAt: string;
+    confirmedAt?: string;
+    context: {
+        type?: 'LOBBY' | 'GAME' | 'REFERRAL' | 'P2P';
+        id?: string;
+    };
+    counterparty: {
+        type: WalletActivityCounterpartyType;
+        username?: string;
+        id?: string;
+    };
+    displayTitle?: string;
+    displaySubtitle?: string;
+    fromUserId?: string;
+    toUserId?: string;
+    fromUsername?: string;
+    toUsername?: string;
+}
+interface AdminWalletActivityResponse {
+    items: AdminWalletActivityItem[];
+    nextCursor?: string;
+}
+interface FaucetResponse {
+    solTransactionHash: string;
+    usdcTransactionHash: string;
+    solAmount: number;
+    usdcAmount: MoneyMinor;
+}
+type TransferToken = 'USDC' | 'SOL';
+declare const TRANSFER_FEE_MINOR = 10000;
+declare const MIN_TRANSFER_AMOUNT = 50000;
+declare const MIN_SOL_TRANSFER_AMOUNT = 1000000;
+declare const SOL_DECIMALS = 9;
+declare const SOL_MINT = "SOL";
+declare const ESTIMATED_SOL_FEE_LAMPORTS = 10000;
+interface PrepareTransferRequest {
+    senderAddress: string;
+    recipient: string;
+    amount: number;
+    token?: TransferToken;
+}
+interface PrepareTransferResponse {
+    transaction: string;
+    fee: number;
+    totalAmount: number;
+    recipientAddress: string;
+    token: TransferToken;
+    ataCreated?: boolean;
+}
+interface SubmitTransferRequest {
+    signedTransaction: string;
+    senderAddress: string;
+    recipientAddress: string;
+    amount: number;
+    token?: TransferToken;
+    ataCreated?: boolean;
+    recipientInput?: string;
+}
+interface SubmitTransferResponse {
+    signature: string;
+    status: 'confirmed' | 'pending';
+}
+interface SendTransferResponse extends SubmitTransferResponse {
+    recipientAddress: string;
+    fee: number;
+    totalAmount: number;
+    token: TransferToken;
+    ataCreated?: boolean;
+}
+declare class Wallet {
+    private http;
+    private logger;
+    private signer;
+    private walletData;
+    constructor(http: IHttpClient, logger?: ILogger);
+    /**
+     * Set the signer to use for signing operations.
+     * This should be called before any signing operations.
+     * @param signer - The signer implementation (e.g., Phantom wallet)
+     */
+    setSigner(signer: WalletSigner): void;
+    /**
+     * Clear the signer (e.g. on logout so the next session can register a different wallet).
+     */
+    clearSigner(): void;
+    /**
+     * Check if a signer has been configured
+     */
+    hasSigner(): boolean;
+    /**
+     * Return signer address if available.
+     */
+    getSignerAddress(): string | null;
+    /**
+     * Load wallet data from API
+     */
+    loadWallet(): Promise<WalletResponse>;
+    /**
+     * Sign a message using the configured signer
+     * @param message - The message to sign
+     * @returns The signature
+     */
+    signMessage(message: string): Promise<Uint8Array | string>;
+    /**
+     * Sign a transaction using the configured signer
+     * @param transaction - The transaction to sign
+     * @returns The signed transaction
+     */
+    signTransaction(transaction: Transaction): Promise<Transaction>;
+    /**
+     * Get SOL and USDC balances
+     */
+    getBalances(): Promise<BalanceResponse>;
+    getActivity(params?: {
+        limit?: number;
+        cursor?: string;
+        kinds?: WalletActivityKind[];
+    }): Promise<WalletActivityResponse>;
+    getUserActivity(userId: string, params?: {
+        limit?: number;
+        cursor?: string;
+        kinds?: WalletActivityKind[];
+    }): Promise<WalletActivityResponse>;
+    /**
+     * Get paginated wallet activity across all users (admin only).
+     * Optional filters: kinds, userId. Sort by date (asc/desc).
+     */
+    getAdminActivity(params?: {
+        limit?: number;
+        cursor?: string;
+        kinds?: WalletActivityKind[];
+        userId?: string;
+        sortOrder?: 'asc' | 'desc';
+    }): Promise<AdminWalletActivityResponse>;
+    /**
+     * Request test funds from faucet (development only)
+     * Sends 10 USDC and 0.05 SOL to the user's wallet
+     */
+    requestFaucet(): Promise<FaucetResponse>;
+    /**
+     * Prepare a transfer transaction (USDC or SOL)
+     * This is an open endpoint that doesn't require authentication
+     *
+     * @param senderAddress - Sender's Solana wallet address
+     * @param recipient - Username OR Solana address of the recipient
+     * @param amountMinor - Amount in USDC minor units or SOL lamports
+     * @param token - Token type ('USDC' or 'SOL'), defaults to 'USDC'
+     * @returns Prepared transaction info including base64 encoded transaction
+     */
+    prepareTransfer(senderAddress: string, recipient: string, amountMinor: number, token?: TransferToken): Promise<PrepareTransferResponse>;
+    /**
+     * Submit a signed transfer transaction
+     * This is an open endpoint that doesn't require authentication
+     *
+     * @param signedTransaction - Base64 encoded signed transaction
+     * @param senderAddress - Sender's Solana wallet address (for history tracking)
+     * @param recipientAddress - Recipient's Solana wallet address (for history tracking)
+     * @param amount - Transfer amount in minor units (for history tracking)
+     * @param token - Token type ('USDC' or 'SOL'), defaults to 'USDC'
+     * @returns Transaction signature and status
+     */
+    submitTransfer(signedTransaction: string, senderAddress: string, recipientAddress: string, amount: number, token?: TransferToken, ataCreated?: boolean, recipientInput?: string): Promise<SubmitTransferResponse>;
+    /**
+     * Full transfer flow in one call: prepare -> sign -> submit
+     * Recipient can be username, .sol domain, or Solana address (resolved by backend).
+     */
+    send(recipient: string, amount: number, token?: TransferToken): Promise<SendTransferResponse>;
+}
+
+declare class Auth {
+    private http;
+    private storage;
+    private wallet;
+    private logger;
+    constructor(http: IHttpClient, storage: IStorage, wallet: Wallet, logger?: ILogger);
+    login(email: string, password: string): Promise<LoginResponse>;
+    private generateHandshake;
+    loginWithWallet(options?: {
+        referralCode?: string;
+        walletMeta?: WalletMeta;
+    }): Promise<LoginResponse>;
+    logout(): void;
+    isAuthenticated(): boolean;
+    getLatestSessions(limit?: number): Promise<PaginatedSessions>;
+}
+
+declare class Admin {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    getUserById(id: string): Promise<User>;
+    getStats(): Promise<AdminStats>;
+    getAdminStats(): Promise<AdminStats>;
+    getDailyStats(days?: number): Promise<AdminDailyStats>;
+    getAdminDailyStats(days?: number): Promise<AdminDailyStats>;
+    getEscrowSweepPreview(): Promise<EscrowSweepPreview>;
+    getEscrowSweeps(limit?: number): Promise<EscrowSweepRecord[]>;
+    executeEscrowSweep(amountUsdcMinor: number, idempotencyKey?: string): Promise<EscrowSweepRecord>;
+    banUser(userId: string, reason?: string): Promise<User>;
+    unbanUser(userId: string): Promise<User>;
+    getCriticalIncidentSummary(hours?: number): Promise<CriticalIncidentSummary>;
+    getCriticalIncidents(input: {
+        page?: number;
+        limit?: number;
+        status?: CriticalIncidentStatus;
+        severity?: CriticalIncidentSeverity;
+        category?: CriticalIncidentCategory;
+    }): Promise<PaginatedCriticalIncidents>;
+    resolveCriticalIncident(id: string, resolutionNote?: string): Promise<CriticalIncident>;
+}
+
+declare class Users {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    getUsers(page?: number, limit?: number, username?: string, address?: string): Promise<PaginatedUsers>;
+    getUserById(id: string): Promise<User>;
+    isUsernameAvailable(username: string): Promise<UsernameAvailabilityResponse>;
+    updateUsername(username: string): Promise<User>;
+    getPublicUserByUsername(username: string): Promise<PublicUser>;
+    /**
+     * Get a public user profile by ID.
+     * Returns PublicUser with optional spectatorCount.
+     */
+    getPublicUserById(userId: string): Promise<PublicUser>;
+    searchUsers(username: string, page?: number, limit?: number): Promise<PaginatedSearchUsers>;
+    getFriends(userId: string, page?: number, limit?: number, search?: string): Promise<PaginatedFriends>;
+    addFriend(userId: string): Promise<{
+        message: string;
+        friendshipStatus: 'outgoing' | 'friends';
+    }>;
+    removeFriend(userId: string): Promise<{
+        message: string;
+    }>;
+    getIncomingFriendRequests(): Promise<FriendRequestItem[]>;
+    getOutgoingFriendRequests(): Promise<FriendRequestItem[]>;
+    acceptFriendRequest(userId: string): Promise<{
+        message: string;
+    }>;
+    declineFriendRequest(userId: string): Promise<{
+        message: string;
+    }>;
+    cancelFriendRequest(userId: string): Promise<{
+        message: string;
+    }>;
+    updateProfile(data: {
+        bio?: string;
+        username?: string;
+    }): Promise<User>;
+    uploadAvatar(file: File): Promise<User>;
+    uploadCoverImage(file: File): Promise<User>;
+    removeAvatar(): Promise<User>;
+    removeCoverImage(): Promise<User>;
+    getAllFiles(): Promise<Array<{
+        id: string;
+        path: string;
+        filename: string;
+        type: 'avatar' | 'cover';
+        userId: string;
+        size: number;
+        createdAt: string;
+    }>>;
+    deleteFile(fileId: string): Promise<{
+        message: string;
+    }>;
+    getGameHistory(userId: string): Promise<GameHistoryItem[]>;
+    /**
+     * Get user activity for spectate flow. Returns in_game (with gameId, gameType), in_lobby (with lobbyId, lobbyStatus), or idle.
+     */
+    getUserActivity(userId: string): Promise<UserActivity>;
+    /**
+     * Get the current active game for a user (if they are a player in one).
+     * Returns null if the user is not in an active game.
+     */
+    getCurrentGame(userId: string): Promise<CurrentGame | null>;
+    getUserStats(userId: string): Promise<UserStats>;
+}
+
+declare class FeatureFlags {
+    private http;
+    private logger?;
+    private flags;
+    private loaded;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    getFeatureFlags(): Promise<FeatureFlag[]>;
+    isEnabledFlag(name: string): boolean;
+    isLoaded(): boolean;
+    updateFeatureFlag(name: string, enabled: boolean): Promise<FeatureFlag>;
+    createFeatureFlag(name: string, enabled: boolean): Promise<FeatureFlag>;
+}
+
+interface BetOption {
+    amount: MoneyMinor;
+    playersOnline: number;
+    estimatedTime: string;
+}
+interface LobbyPlayer {
+    userId: string;
+    username?: string;
+    avatar?: string;
+    joinedAt: string;
+    connected?: boolean;
+    /** USDC balance in minor units (cached, short TTL). Shown in lobby and used to gate Start Game. */
+    usdcBalance?: number;
+}
+interface Lobby {
+    id: string;
+    gameType: string;
+    gameName: string;
+    status: 'waiting' | 'preparing' | 'queued' | 'active';
+    creatorId: string;
+    maxPlayers: number;
+    betAmount?: MoneyMinor;
+    betOptions?: BetOption[];
+    gameId?: string;
+    createdAt: string;
+    updatedAt: string;
+    players: LobbyPlayer[];
+}
+interface CreateLobbyRequest {
+    gameType: string;
+}
+interface InviteFriendRequest {
+    friendId: string;
+}
+interface QueueStats {
+    totalPlayersInQueue: number;
+    queueSizes: Record<string, number>;
+    totalQueuedLobbies: number;
+}
+type ChatMessageType = 'user' | 'system';
+type SystemMessageType = 'player_joined' | 'player_left' | 'bet_changed' | 'call_joined' | 'call_left' | 'global_help' | 'global_challenge' | 'global_tip' | 'spectator_donation';
+interface ChatMessageReply {
+    id: string;
+    userId?: string;
+    username?: string;
+    message: string;
+}
+interface ChatReaction {
+    emoji: string;
+    userId: string;
+    username?: string;
+    createdAt: string;
+}
+interface ChatReadBy {
+    userId: string;
+    readAt: string;
+}
+interface ChatMessage {
+    id: string;
+    lobbyId: string;
+    userId?: string;
+    username?: string;
+    avatarUrl?: string;
+    message: string;
+    type: ChatMessageType;
+    systemType?: SystemMessageType;
+    metadata?: Record<string, any>;
+    replyTo?: ChatMessageReply;
+    reactions?: ChatReaction[];
+    readBy?: ChatReadBy[];
+    createdAt: string;
+}
+
+declare class Lobbies {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    createLobby(gameType: string, betAmount?: MoneyMinor): Promise<Lobby>;
+    getLobby(lobbyId: string): Promise<Lobby>;
+    inviteFriend(lobbyId: string, friendId: string): Promise<{
+        message: string;
+    }>;
+    acceptInvite(lobbyId: string): Promise<Lobby>;
+    joinLobby(lobbyId: string): Promise<Lobby>;
+    removePlayer(lobbyId: string, userId: string): Promise<{
+        message: string;
+    }>;
+    kickPlayer(lobbyId: string, userId: string): Promise<{
+        message: string;
+    }>;
+    leaveLobby(lobbyId: string): Promise<{
+        message: string;
+    }>;
+    joinQueue(lobbyId: string): Promise<Lobby>;
+    cancelQueue(lobbyId: string): Promise<Lobby>;
+    updateBetAmount(lobbyId: string, betAmount: MoneyMinor): Promise<Lobby>;
+    playSound(lobbyId: string, sound: string): Promise<{
+        success: boolean;
+    }>;
+    getActiveLobbies(): Promise<Lobby[]>;
+    getQueueStats(): Promise<QueueStats>;
+    deleteLobby(lobbyId: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * Play again: Create a new lobby, start deposits, and prepare deposit transaction
+     * Returns the lobby and unsigned transaction that needs to be signed
+     * @param gameType - The game type to play again
+     * @param betAmount - The bet amount (same as previous game)
+     * @param escrow - The escrow service instance (from sdk.escrow)
+     */
+    playAgain(gameType: string, betAmount: MoneyMinor, escrow: {
+        startDeposits: (id: string) => Promise<void>;
+        prepareDepositTransaction: (id: string) => Promise<{
+            transaction: string;
+            message: string;
+        }>;
+    }): Promise<{
+        lobby: Lobby;
+        unsignedTransaction: string;
+    }>;
+}
+
+interface GameType {
+    id: string;
+    name: string;
+    maxPlayers: number;
+    minPlayers: number;
+    description?: string;
+    available: boolean;
+    betOptions?: BetOption[];
+}
+/**
+ * Real-time metrics for a game type.
+ * Includes player counts, active games, and money currently in play.
+ */
+interface GameMetrics {
+    /** The game type identifier (e.g., 'chess', 'rock-paper-scissors') */
+    gameType: string;
+    /** Number of users currently playing or waiting in lobbies for this game type */
+    usersPlaying: number;
+    /** Number of active games currently in progress */
+    liveGames: number;
+    /** Total amount of money (in minor units) currently wagered in active games */
+    moneyInPlay: number;
+}
+interface GamePlayer {
+    userId: string;
+    username: string;
+    avatar?: string;
+    status?: 'active' | 'disconnected';
+}
+interface Game {
+    gameId: string;
+    gameType: string;
+    status: 'active' | 'completed' | 'abandoned';
+    createdAt: string;
+    players: GamePlayer[];
+    lobbyIds: string[];
+}
+interface AdminGameHistoryPlayer {
+    userId: string;
+    username?: string;
+    avatar?: string;
+}
+interface AdminGameHistoryFeePlayer {
+    userId: string;
+    username?: string;
+    betAmount: MoneyMinor;
+    feeAmount: MoneyMinor;
+    netAmount: MoneyMinor;
+    discountApplied: boolean;
+    referralPayout: MoneyMinor;
+    platformFeeNet: MoneyMinor;
+    referralSplits: {
+        level: number;
+        referrerId: string;
+        referrerUsername?: string;
+        amount: MoneyMinor;
+    }[];
+}
+interface AdminGameHistoryFeeBreakdown {
+    totalDeposited: MoneyMinor;
+    totalFee: MoneyMinor;
+    totalPayout: MoneyMinor;
+    players: AdminGameHistoryFeePlayer[];
+}
+interface SpectatorMetricsByUser {
+    userId: string;
+    spectatorCount: number;
+}
+interface SpectatorMetrics {
+    total: number;
+    byUser: SpectatorMetricsByUser[];
+}
+interface AdminGameHistory {
+    id: string;
+    gameId: string;
+    gameType: string;
+    playerIds: string[];
+    players: AdminGameHistoryPlayer[];
+    winnerId?: string;
+    winner?: AdminGameHistoryPlayer;
+    betAmount: MoneyMinor | null;
+    wonAmount: MoneyMinor | null;
+    totalDeposited: MoneyMinor | null;
+    feeBreakdown?: AdminGameHistoryFeeBreakdown;
+    depositTransactionHashes: string[];
+    payoutTransactionHash?: string;
+    feeTransactionHash?: string;
+    completedAt: string;
+    createdAt: string;
+}
+type GameStateResponse = RpsGameState | ChessGameState | NimGameState | DotsAndBoxesGameState | TicTacToeGameState | Connect4GameState;
+type ValidAction = RpsGameAction | ChessGameAction | NimGameAction | DotsAndBoxesGameAction | TicTacToeGameAction | Connect4GameAction;
+
+interface DonateToGameResponse {
+    signature: string;
+    status: string;
+    escrowAddress: string;
+    amountMinor: number;
+}
+declare class Games {
+    private http;
+    private wallet;
+    private logger?;
+    constructor(http: IHttpClient, wallet: Wallet, logger?: ILogger | undefined);
+    getAvailableGames(): Promise<GameType[]>;
+    /**
+     * Get real-time metrics for all games.
+     * Returns player counts, active games, and money in play per game type.
+     * This is a public endpoint that doesn't require authentication.
+     */
+    getMetrics(): Promise<GameMetrics[]>;
+    getGame(gameId: string): Promise<Game>;
+    /**
+     * Get list of currently active (live) games. Public endpoint for spectating.
+     */
+    getLiveGames(): Promise<Game[]>;
+    getAdminGameHistory(gameId: string): Promise<AdminGameHistory>;
+    /**
+     * Get current spectator counts (total and per user). Admin only.
+     */
+    getSpectatorMetrics(): Promise<SpectatorMetrics>;
+    /**
+     * Submit a typed action for any game
+     */
+    submitAction(gameId: string, action: ValidAction): Promise<void>;
+    /**
+     * Get current game state with timer information
+     */
+    getGameState(gameId: string): Promise<GameStateResponse>;
+    /**
+     * Request a rematch for a completed game
+     */
+    requestRematch(gameId: string): Promise<{
+        success: boolean;
+        bothReady: boolean;
+        newGameId?: string;
+    }>;
+    /**
+     * Cancel a rematch request
+     */
+    cancelRematch(gameId: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Get current rematch state for a game
+     */
+    getRematchState(gameId: string): Promise<{
+        requestedBy: string[];
+    }>;
+    /**
+     * Prepare a game donation (returns unsigned transaction for client to sign).
+     * Call donateToGame with the signed transaction after signing.
+     */
+    prepareGameDonation(gameId: string, amountMinor: number): Promise<{
+        transaction: string;
+        escrowAddress: string;
+        amountMinor: number;
+    }>;
+    /**
+     * Submit a signed game donation. Sign the transaction from prepareGameDonation first.
+     */
+    donateToGame(gameId: string, amountMinor: number, signedTransaction: string): Promise<{
+        signature: string;
+        status: string;
+    }>;
+    /**
+     * One-call donation flow: prepare -> sign -> submit.
+     */
+    sendDonation(gameId: string, amountMinor: number): Promise<DonateToGameResponse>;
+    /**
+     * Notify backend that a rematch lobby was created (coordinator calls this)
+     * Backend will broadcast the lobby ID to other players
+     */
+    notifyRematchLobbyCreated(gameId: string, lobbyId: string): Promise<void>;
+}
+
+/** A player currently in an active game; used for "Live now" and "Who to watch" UI. */
+interface LivePlayer {
+    userId: string;
+    username: string;
+    avatar?: string;
+    gameId: string;
+    gameType: string;
+    spectatorCount: number;
+}
+/** Paginated response for live players (newest first, sample of games per page). */
+interface LivePlayersPage {
+    items: LivePlayer[];
+    nextCursor: string | null;
+}
+/**
+ * SDK class for spectate discovery — finding who to watch.
+ *
+ * @example
+ * ```ts
+ * const page = await sdk.spectate.getLivePlayers({ limit: 10 });
+ * console.log(page.items); // LivePlayer[]
+ * ```
+ */
+declare class Spectate {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    /**
+     * Get list of live players (one per unique player), sampled from newest games, paginated.
+     * Use for "Live now" and "Who to watch" UI; link to /spectate/:username.
+     * @param options.limit - Number of games to consider per page (1–20, default 10).
+     * @param options.cursor - Opaque cursor from previous page for next page.
+     */
+    getLivePlayers(options?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<LivePlayersPage>;
+}
+
+/**
+ * Retry configuration options
+ */
+interface RetryOptions {
+    /** Maximum number of retry attempts (default: 3) */
+    maxAttempts?: number;
+    /** Base delay in milliseconds (default: 1000) */
+    baseDelayMs?: number;
+    /** Maximum delay in milliseconds (default: 10000) */
+    maxDelayMs?: number;
+    /** Multiplier for exponential backoff (default: 2) */
+    backoffMultiplier?: number;
+    /** Function to determine if error is retryable (default: network/5xx errors) */
+    isRetryable?: (error: unknown) => boolean;
+    /** Callback for each retry attempt */
+    onRetry?: (attempt: number, error: unknown, delayMs: number) => void;
+}
+/**
+ * Default function to determine if an error is retryable.
+ * Retries on network errors and 5xx server errors.
+ */
+declare function isRetryableError(error: unknown): boolean;
+/**
+ * Execute an async function with exponential backoff retry.
+ *
+ * @param fn - Async function to execute
+ * @param options - Retry configuration
+ * @returns Promise resolving to the function result
+ * @throws Last error if all retries exhausted
+ *
+ * @example
+ * ```typescript
+ * const result = await withRetry(
+ *   () => fetch('/api/data'),
+ *   { maxAttempts: 3, baseDelayMs: 500 }
+ * );
+ * ```
+ */
+declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+
+type ChatContextType = 'lobby' | 'game' | 'dm' | 'global';
+interface ChatContext {
+    type: ChatContextType;
+    id: string;
+}
+interface SendMessageRequest {
+    message: string;
+    replyTo?: ChatMessageReply;
+    gifUrl?: string;
+}
+interface DmThread {
+    dmKey: string;
+    otherUser: PublicUser;
+    lastMessage: string | null;
+    lastMessageAt: string | null;
+    lastMessageSenderId: string | null;
+    lastMessageSenderUsername: string | null;
+    unreadCount: number;
+}
+declare class Chat {
+    private http;
+    private logger?;
+    private retryOptions;
+    constructor(http: IHttpClient, logger?: any | undefined, retryOptions?: RetryOptions);
+    private encodeContextId;
+    /**
+     * Send a chat message with automatic retry on transient failures
+     *
+     * @param clientMessageId - Optional client-generated ID for optimistic UI.
+     *                          Echoed back in response metadata for deduplication.
+     */
+    sendMessage(context: ChatContext, message: string, replyTo?: ChatMessageReply, gifUrl?: string, clientMessageId?: string): Promise<ChatMessage>;
+    /** Response from paginated chat history */
+    getChatHistory(context: ChatContext, limit?: number, cursor?: string): Promise<ChatMessage[]>;
+    /**
+     * Get chat history with pagination support.
+     * Returns messages and a cursor for loading older messages.
+     * For global context, uses the public endpoint so it works without auth.
+     */
+    getChatHistoryPaginated(context: ChatContext, limit?: number, cursor?: string): Promise<{
+        messages: ChatMessage[];
+        nextCursor: string | null;
+    }>;
+    /**
+     * Add a reaction to a message
+     */
+    addReaction(context: ChatContext, messageId: string, emoji: string): Promise<ChatMessage>;
+    /**
+     * Remove a reaction from a message
+     */
+    removeReaction(context: ChatContext, messageId: string, emoji: string): Promise<ChatMessage>;
+    /**
+     * Mark a message as read
+     */
+    markAsRead(context: ChatContext, messageId: string): Promise<ChatMessage>;
+    listDmThreads(): Promise<DmThread[]>;
+    getDmThread(dmKey: string): Promise<DmThread>;
+    /**
+     * Mark all messages in a DM thread as read
+     */
+    markDmThreadAsRead(dmKey: string): Promise<{
+        markedCount: number;
+    }>;
+    /**
+     * Accept a global chat challenge. Returns the lobby (and gameId if started).
+     */
+    acceptGlobalChallenge(challengeId: string): Promise<{
+        lobbyId: string;
+        gameId?: string;
+        status: string;
+    }>;
+    /**
+     * Broadcast a tip message to global chat (call after the user has signed and submitted the transfer).
+     */
+    broadcastGlobalTip(recipientUserId: string, amount: number): Promise<ChatMessage>;
+}
+
+interface CreateChallengeRequest {
+    gameType: string;
+    amount: number;
+    targetUserId?: string;
+    targetUsername?: string;
+    /** When set, post challenge system message to this DM thread (format: "userId1:userId2" sorted). */
+    dmKey?: string;
+}
+interface CreateChallengeResponse {
+    challengeId: string;
+    challengerId: string;
+    targetUserId: string;
+    gameType: string;
+    amountMinor: number;
+    challengerUsername?: string;
+}
+interface AcceptChallengeResponse {
+    lobbyId: string;
+    gameId?: string;
+    status: string;
+}
+declare class Challenges {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: any | undefined);
+    /**
+     * Create a challenge (any user can challenge any other user by id or username).
+     */
+    create(dto: CreateChallengeRequest): Promise<CreateChallengeResponse>;
+    /**
+     * Accept a challenge. Only the challenged user can accept. Creates a lobby with the challenge amount and adds both users.
+     */
+    accept(challengeId: string): Promise<AcceptChallengeResponse>;
+    /**
+     * Decline a challenge. Only the challenged user can decline. Optionally post a "declined" message to the DM thread.
+     */
+    decline(challengeId: string, dmKey?: string): Promise<{
+        message?: string;
+    }>;
+}
+
+interface PrepareTipRequest {
+    recipientUsername: string;
+    amount: number;
+}
+interface PrepareTipResponse {
+    transaction: string;
+    fee: number;
+    totalAmount: number;
+    recipientAddress: string;
+    recipientUserId: string;
+    recipientUsername: string;
+    amount: number;
+}
+interface BroadcastTipRequest {
+    recipientUserId: string;
+    amount: number;
+}
+interface SendTipResponse extends SubmitTransferResponse {
+    recipientAddress: string;
+    recipientUserId: string;
+    recipientUsername: string;
+    amount: number;
+    fee: number;
+    totalAmount: number;
+    message: ChatMessage;
+}
+/**
+ * Tips are a shorthand for wallet send + global tip broadcast.
+ */
+declare class Tips {
+    private http;
+    private wallet;
+    private chat;
+    private logger?;
+    constructor(http: IHttpClient, wallet: Wallet, chat: Chat, logger?: any | undefined);
+    prepare(dto: PrepareTipRequest): Promise<PrepareTipResponse>;
+    /**
+     * Broadcast a tip message to global chat (call after the transfer has been submitted).
+     */
+    broadcast(dto: BroadcastTipRequest): Promise<ChatMessage>;
+    /**
+     * One-call tip flow: prepare -> sign -> submit transfer -> broadcast tip message.
+     */
+    send(recipientUsername: string, amount: number): Promise<SendTipResponse>;
+}
+
+type WsEventName = 'lobby:created' | 'lobby:updated' | 'lobby:player:joined' | 'lobby:player:left' | 'lobby:player:connected' | 'lobby:player:disconnected' | 'lobby:bet:updated' | 'lobby:invitation' | 'lobby:deleted' | 'lobby:queue:joined' | 'lobby:queue:cancelled' | 'lobby:matched' | 'lobby:typing:start' | 'lobby:typing:stop' | 'game:updated' | 'game:completed' | 'game:paid' | 'game:abandoned' | 'game:turn' | 'game:move' | 'game:state' | 'game:player:connected' | 'game:player:disconnected' | 'game:rps:starting' | 'game:rps:round:started' | 'game:rps:action:received' | 'game:rps:timer:cutoff' | 'game:rps:round:reveal' | 'game:rps:round:completed' | 'game:rps:timeout' | 'game:rematch:requested' | 'game:rematch:cancelled' | 'game:rematch:started' | 'game:rematch:lobby:created' | 'game:pot:updated' | 'game:market:price:updated' | 'game:market:order:filled' | 'game:market:resolved' | 'spectator:count:updated' | 'chat:message' | 'chat:reaction' | 'chat:read' | 'chat:typing' | 'notification';
+type GameTurnPayload = {
+    turn: number;
+    currentPlayerId: string;
+    gameId?: string;
+    [key: string]: unknown;
+};
+type GameMovePayload = ChessMovePayload;
+type GameStatePayload = {
+    state: GameStateResponse;
+    gameId?: string;
+};
+type GamePlayerConnectionPayload = {
+    userId: string;
+    gameId: string;
+};
+type GameStartingPayload = {
+    gameId: string;
+    startedAt: string;
+    bufferEndsAt: string;
+    timeRemaining: number;
+    betAmount: MoneyMinor;
+};
+type GameRoundStartedPayload = {
+    gameId: string;
+    roundNumber: number;
+    startedAt: string;
+    selectionEndsAt: string;
+    timeRemaining: number;
+};
+type GameActionReceivedPayload = {
+    gameId: string;
+    roundNumber: number;
+    playerId: string;
+    submittedAt: string;
+};
+type GameTimerCutoffPayload = {
+    gameId: string;
+    roundNumber: number;
+    cutoffAt: string;
+    newEndsAt: string;
+};
+type GameRoundRevealPayload = {
+    gameId: string;
+    roundNumber: number;
+    actions: Record<string, RpsAction>;
+    revealEndsAt: string;
+    timeRemaining: number;
+};
+type GameRoundCompletedPayload = {
+    gameId: string;
+    roundNumber: number;
+    winnerId: string | null;
+    scores: Record<string, number>;
+    actions: Record<string, RpsAction>;
+};
+type GameTimeoutPayload = {
+    gameId: string;
+    roundNumber: number;
+    playerId: string;
+    action: RpsAction;
+    isTimeout: boolean;
+};
+type GameCompletionBasePayload = {
+    gameId: string;
+    gameType: GameStateResponse['gameType'];
+    winnerId: string | null;
+    wonAmount: number;
+    isDraw: boolean;
+};
+type RpsGameCompletionPayload = GameCompletionBasePayload & {
+    gameType: 'rock-paper-scissors';
+    finalScores: Record<string, number>;
+    rounds: Array<{
+        roundNumber: number;
+        actions: Record<string, RpsAction>;
+        winnerId: string | null;
+        completedAt?: string;
+    }>;
+};
+type GenericGameCompletionPayload = GameCompletionBasePayload & {
+    gameType: Exclude<GameStateResponse['gameType'], 'rock-paper-scissors'>;
+};
+type GameCompletionPayload = RpsGameCompletionPayload | GenericGameCompletionPayload;
+type MarketPriceUpdatedPayload = {
+    gameId: string;
+    prices: Record<string, number>;
+    totalCollateral: string;
+    totalVolume: string;
+};
+type MarketOrderFilledPayload = {
+    gameId: string;
+    orderId: string;
+    userId: string;
+    outcomeId: string;
+    filledQuantity: string;
+    pricePerShare: string;
+};
+type MarketResolvedPayload = {
+    gameId: string;
+    resolvedOutcome: string | null;
+    isDraw: boolean;
+};
+type WsEvent = {
+    event: 'lobby:created';
+    payload: Lobby;
+} | {
+    event: 'lobby:updated';
+    payload: Lobby;
+} | {
+    event: 'lobby:player:joined';
+    payload: {
+        userId: string;
+        lobby: Lobby;
+    };
+} | {
+    event: 'lobby:player:left';
+    payload: {
+        userId: string;
+        lobby: Lobby;
+    };
+} | {
+    event: 'lobby:player:connected';
+    payload: {
+        userId: string;
+        lobbyId: string;
+    };
+} | {
+    event: 'lobby:player:disconnected';
+    payload: {
+        userId: string;
+        lobbyId: string;
+    };
+} | {
+    event: 'lobby:bet:updated';
+    payload: Lobby;
+} | {
+    event: 'lobby:invitation';
+    payload: unknown;
+} | {
+    event: 'lobby:deleted';
+    payload: {
+        lobbyId: string;
+    };
+} | {
+    event: 'lobby:queue:joined';
+    payload: {
+        lobby: Lobby;
+        queuedAt: string;
+    };
+} | {
+    event: 'lobby:queue:cancelled';
+    payload: {
+        lobby: Lobby;
+    };
+} | {
+    event: 'lobby:matched';
+    payload: {
+        gameId: string;
+        gameType: string;
+        matchedLobbies: Lobby[];
+    };
+} | {
+    event: 'lobby:typing:start';
+    payload: {
+        lobbyId: string;
+        userId: string;
+    };
+} | {
+    event: 'lobby:typing:stop';
+    payload: {
+        lobbyId: string;
+        userId: string;
+    };
+} | {
+    event: 'game:updated';
+    payload: Game;
+} | {
+    event: 'game:completed';
+    payload: GameCompletionPayload;
+} | {
+    event: 'game:paid';
+    payload: GameCompletionPayload;
+} | {
+    event: 'game:abandoned';
+    payload: Game;
+} | {
+    event: 'game:turn';
+    payload: GameTurnPayload;
+} | {
+    event: 'game:move';
+    payload: GameMovePayload;
+} | {
+    event: 'game:state';
+    payload: GameStatePayload;
+} | {
+    event: 'game:player:connected';
+    payload: GamePlayerConnectionPayload;
+} | {
+    event: 'game:player:disconnected';
+    payload: GamePlayerConnectionPayload;
+} | {
+    event: 'game:rps:starting';
+    payload: GameStartingPayload;
+} | {
+    event: 'game:rps:round:started';
+    payload: GameRoundStartedPayload;
+} | {
+    event: 'game:rps:action:received';
+    payload: GameActionReceivedPayload;
+} | {
+    event: 'game:rps:timer:cutoff';
+    payload: GameTimerCutoffPayload;
+} | {
+    event: 'game:rps:round:reveal';
+    payload: GameRoundRevealPayload;
+} | {
+    event: 'game:rps:round:completed';
+    payload: GameRoundCompletedPayload;
+} | {
+    event: 'game:rps:timeout';
+    payload: GameTimeoutPayload;
+} | {
+    event: 'game:rematch:requested';
+    payload: {
+        gameId: string;
+        userId?: string;
+        requestedBy?: string[];
+    };
+} | {
+    event: 'game:rematch:cancelled';
+    payload: {
+        gameId: string;
+        userId?: string;
+        requestedBy?: string[];
+    };
+} | {
+    event: 'game:rematch:started';
+    payload: {
+        gameId: string;
+        gameType?: string;
+        betAmount?: MoneyMinor;
+        playerIds?: string[];
+        coordinatorId?: string;
+        newLobbyId?: string;
+    };
+} | {
+    event: 'game:rematch:lobby:created';
+    payload: {
+        gameId: string;
+        newLobbyId: string;
+    };
+} | {
+    event: 'game:pot:updated';
+    payload: {
+        gameId: string;
+        totalPotMinor: number;
+    };
+} | {
+    event: 'game:market:price:updated';
+    payload: MarketPriceUpdatedPayload;
+} | {
+    event: 'game:market:order:filled';
+    payload: MarketOrderFilledPayload;
+} | {
+    event: 'game:market:resolved';
+    payload: MarketResolvedPayload;
+} | {
+    event: 'spectator:count:updated';
+    payload: {
+        userId: string;
+        count: number;
+    };
+} | {
+    event: 'chat:message';
+    payload: ChatMessage;
+} | {
+    event: 'chat:reaction';
+    payload: ChatMessage;
+} | {
+    event: 'chat:read';
+    payload: {
+        messageId: string;
+        userId: string;
+        readAt?: string;
+    };
+} | {
+    event: 'chat:typing';
+    payload: {
+        context: ChatContext;
+        userId: string;
+        username?: string;
+        typing: boolean;
+    };
+} | {
+    event: 'notification';
+    payload: unknown;
+};
+
+type EqualityFn<T> = (a: T, b: T) => boolean;
+interface SdkStore<S> {
+    getSnapshot(): S;
+    getState(): S;
+    setState(next: S): void;
+    updateState(updater: (prev: S) => S): void;
+    subscribe(listener: () => void): () => void;
+    subscribeSelector<T>(selector: (state: S) => T, listener: () => void, isEqual?: EqualityFn<T>): () => void;
+}
+declare function createSdkStore<S>(initial: S): SdkStore<S>;
+
+type NotificationEvent = {
+    title: string;
+    body?: string;
+    icon?: string;
+    tag?: string;
+    data?: unknown;
+    /** Notification type (e.g. challenge_accepted) for app logic like auto-navigation */
+    type?: string;
+    /** Action payload (e.g. { lobbyId }) when present on the payload */
+    actionPayload?: Record<string, unknown>;
+};
+
+type NotificationsStoreState = {
+    notifications: NotificationEvent[];
+    lastNotification: NotificationEvent | null;
+    appNotifications: AppNotification[];
+};
+type NotificationsStore = {
+    store: SdkStore<NotificationsStoreState>;
+    applyWsEvent: (event: WsEvent) => void;
+    setListFromApi: (res: PaginatedNotificationsResponse) => void;
+    clear: () => void;
+};
+declare function createNotificationsStore(): NotificationsStore;
+
+interface ListNotificationsParams {
+    page?: number;
+    limit?: number;
+}
+declare class Notifications {
+    private http;
+    private notificationsStore;
+    private logger?;
+    constructor(http: IHttpClient, notificationsStore: NotificationsStore, logger?: ILogger | undefined);
+    /**
+     * List notifications for the current user (paginated).
+     * Results are always merged into the SDK notifications store.
+     */
+    list(params?: ListNotificationsParams): Promise<PaginatedNotificationsResponse>;
+    /**
+     * Mark a notification as read.
+     */
+    markAsRead(id: string): Promise<AppNotification>;
+    /**
+     * Mark all notifications as read.
+     */
+    markAllAsRead(): Promise<void>;
+    /**
+     * Dismiss (delete) a notification.
+     */
+    dismiss(id: string): Promise<void>;
+    /**
+     * Broadcast a notification to all connected users (admin only)
+     */
+    broadcastNotification(message: string): Promise<void>;
+    /**
+     * Send a notification to a specific user (admin only)
+     */
+    sendToUser(userId: string, message: string): Promise<void>;
+}
+
+declare class Achievements {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    /**
+     * List all achievement definitions.
+     */
+    list(): Promise<Achievement[]>;
+    /**
+     * Get unlocked achievements for the current user.
+     */
+    getMyAchievements(): Promise<UserAchievement[]>;
+    /**
+     * Get unlocked achievements for a user (e.g. for profile).
+     */
+    getForUser(userId: string): Promise<UserAchievement[]>;
+}
+
+interface DepositStatus {
+    status: 'pending' | 'signed' | 'confirmed' | 'failed';
+    transactionHash?: string;
+    signedAt?: string;
+    confirmedAt?: string;
+    errorMessage?: string;
+}
+interface DepositStatusResponse {
+    deposits: Array<{
+        userId: string;
+        status: 'pending' | 'signed' | 'confirmed' | 'failed';
+        transactionHash?: string;
+        signedAt?: string;
+        confirmedAt?: string;
+        errorMessage?: string;
+    }>;
+    allConfirmed: boolean;
+    canProceedToQueue: boolean;
+}
+interface PrepareDepositResponse {
+    transaction: string;
+    message: string;
+}
+interface SubmitDepositResponse {
+    signature: string;
+    status: string;
+}
+declare class Escrow {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    /**
+     * Start the deposit flow for a lobby
+     * Transitions the lobby to 'preparing' state
+     */
+    startDeposits(lobbyId: string): Promise<void>;
+    /**
+     * Prepare a deposit transaction for a user
+     * Returns an unsigned transaction that needs to be signed by the user
+     */
+    prepareDepositTransaction(lobbyId: string): Promise<PrepareDepositResponse>;
+    /**
+     * Submit a signed deposit transaction
+     * The transaction will be submitted to the Solana network and confirmed
+     */
+    submitDeposit(lobbyId: string, signedTransaction: string): Promise<SubmitDepositResponse>;
+    /**
+     * Check the deposit status for all players in a lobby
+     */
+    getDepositStatus(lobbyId: string): Promise<DepositStatusResponse>;
+    claimLobbyDepositRefund(lobbyId: string, depositSignature: string): Promise<{
+        signature: string;
+        status: string;
+    }>;
+    claimGamePayout(gameHistoryId: string): Promise<{
+        signature: string;
+        status: string;
+    }>;
+    /**
+     * Submit a signed deposit transaction and wait until the lobby is queued/active.
+     *
+     * Note: the backend may auto-transition the lobby to the queue once deposits are confirmed.
+     * In that case, calling /join-queue from the client would be redundant and can fail with
+     * "Current status: queued".
+     * @param lobbyId - The lobby ID
+     * @param signedTransaction - The signed transaction (base64 encoded)
+     * @param lobbies - The lobbies service instance (from sdk.lobbies) to read lobby status
+     */
+    submitDepositAndJoinQueue(lobbyId: string, signedTransaction: string, lobbies: {
+        getLobby: (id: string) => Promise<{
+            id: string;
+            status: string;
+        }>;
+    }): Promise<{
+        id: string;
+        status: string;
+    }>;
+}
+
+interface DailyRoom {
+    roomUrl: string;
+    roomName: string;
+    lobbyId: string;
+    createdAt: string;
+}
+interface DailyToken {
+    token: string;
+    roomUrl: string;
+    expiresAt: string;
+}
+interface DailyParticipant {
+    sessionId: string;
+    userId: string;
+    username?: string;
+    avatarUrl?: string;
+    audio: boolean;
+    video: boolean;
+}
+declare class Daily {
+    private http;
+    private logger;
+    constructor(http: IHttpClient, logger?: ILogger);
+    createDmRoom(dmKey: string): Promise<DailyRoom>;
+    getDmRoom(dmKey: string): Promise<DailyRoom | null>;
+    getDmToken(dmKey: string): Promise<DailyToken>;
+    deleteDmRoom(dmKey: string): Promise<void>;
+    notifyDmCallJoined(dmKey: string): Promise<void>;
+    notifyDmCallLeft(dmKey: string): Promise<void>;
+}
+
+declare class Referrals {
+    private http;
+    private logger;
+    constructor(http: IHttpClient, logger?: ILogger);
+    getSummary(): Promise<ReferralSummary>;
+    getTree(params?: {
+        level?: 1 | 2 | 3;
+        limit?: number;
+        cursor?: string;
+    }): Promise<ReferralTreeResponse>;
+    getRewards(params?: {
+        limit?: number;
+        cursor?: string;
+        status?: 'PENDING' | 'CLAIMED' | 'CANCELLED';
+    }): Promise<ReferralRewardsResponse>;
+    applyCode(referralCode: string): Promise<ApplyReferralCodeResponse>;
+    claimRewards(): Promise<ClaimReferralRewardsResponse>;
+}
+
+declare class Activity {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    getFeed(limit?: number): Promise<ActivityFeedResponse>;
+}
+
+declare class Leaderboards {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    getGlobalLeaderboard(query?: LeaderboardQuery): Promise<LeaderboardResponse>;
+    getGameLeaderboard(gameType: string, query?: LeaderboardQuery): Promise<LeaderboardResponse>;
+    getFriendsLeaderboard(query?: LeaderboardQuery): Promise<LeaderboardResponse>;
+    private buildEndpoint;
+}
+
+interface GetReportsOptions {
+    page?: number;
+    limit?: number;
+    status?: ReportStatus;
+}
+interface UpdateReportData {
+    status?: ReportStatus;
+    adminNotes?: string;
+}
+declare class Reports {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    /**
+     * Create a new report (authenticated users only)
+     * Rate limited to 5 reports per hour
+     * @param reportedUserId - The ID of the user being reported
+     * @param reason - The reason for the report (max 300 characters)
+     */
+    create(reportedUserId: string, reason: string): Promise<Report>;
+    /**
+     * Get all reports (admin only, paginated)
+     * @param options - Pagination and filter options
+     */
+    list(options?: GetReportsOptions): Promise<PaginatedReports>;
+    /**
+     * Get a single report by ID (admin only)
+     * @param id - The report ID
+     */
+    getById(id: string): Promise<Report>;
+    /**
+     * Get reports for a specific user (admin only)
+     * @param userId - The ID of the reported user
+     */
+    getByUser(userId: string): Promise<Report[]>;
+    /**
+     * Get report count for a specific user (admin only)
+     * @param userId - The ID of the reported user
+     */
+    getCountByUser(userId: string): Promise<ReportCount>;
+    /**
+     * Get count of pending reports (admin only)
+     */
+    getPendingCount(): Promise<{
+        count: number;
+    }>;
+    /**
+     * Update a report status/notes (admin only)
+     * @param id - The report ID
+     * @param data - Update data (status and/or adminNotes)
+     */
+    update(id: string, data: UpdateReportData): Promise<Report>;
+    /**
+     * Delete a report (admin only)
+     * @param id - The report ID
+     */
+    delete(id: string): Promise<void>;
+}
+
+interface CreateTicketData {
+    /** Optional subject (auto-generated from category if omitted) */
+    subject?: string;
+    /** The initial message describing the issue (max 2000 chars) */
+    message: string;
+    /** Ticket category (default: OTHER) */
+    category?: SupportTicketCategory;
+    /** Optional contact email */
+    email?: string;
+}
+interface GetTicketsOptions {
+    page?: number;
+    limit?: number;
+    status?: SupportTicketStatus;
+    category?: SupportTicketCategory;
+}
+interface UpdateTicketData {
+    status?: SupportTicketStatus;
+    priority?: SupportTicketPriority;
+}
+declare class Support {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    /**
+     * Create a new support ticket (authenticated users)
+     * Rate limited to 5 tickets per hour.
+     * @param data - Ticket data (message required, subject/category/email optional)
+     */
+    create(data: CreateTicketData): Promise<SupportTicket>;
+    /**
+     * Get my support tickets (paginated)
+     * @param options - Pagination and filter options
+     */
+    getMyTickets(options?: GetTicketsOptions): Promise<PaginatedSupportTickets>;
+    /**
+     * Get a specific ticket with all messages (user can only see own)
+     * @param ticketId - The ticket ID
+     */
+    getMyTicketById(ticketId: string): Promise<SupportTicket>;
+    /**
+     * Add a message to an existing ticket (user can only message own)
+     * @param ticketId - The ticket ID
+     * @param message - Message content (max 2000 chars)
+     */
+    addMessage(ticketId: string, message: string): Promise<SupportMessage>;
+    /**
+     * Close a ticket (user can close own)
+     * @param ticketId - The ticket ID
+     */
+    closeTicket(ticketId: string): Promise<SupportTicket>;
+    /**
+     * Get all support tickets (admin only, paginated)
+     * @param options - Pagination and filter options
+     */
+    list(options?: GetTicketsOptions): Promise<PaginatedSupportTickets>;
+    /**
+     * Get open ticket count (admin only)
+     */
+    getOpenCount(): Promise<{
+        count: number;
+    }>;
+    /**
+     * Get a single ticket by ID (admin only)
+     * @param ticketId - The ticket ID
+     */
+    getById(ticketId: string): Promise<SupportTicket>;
+    /**
+     * Update ticket status/priority (admin only)
+     * @param ticketId - The ticket ID
+     * @param data - Update data (status and/or priority)
+     */
+    update(ticketId: string, data: UpdateTicketData): Promise<SupportTicket>;
+    /**
+     * Reply to a ticket as admin (admin only)
+     * @param ticketId - The ticket ID
+     * @param message - Reply content (max 2000 chars)
+     */
+    reply(ticketId: string, message: string): Promise<SupportMessage>;
+    /**
+     * Delete a ticket (admin only)
+     * @param ticketId - The ticket ID
+     */
+    delete(ticketId: string): Promise<void>;
+}
+
+interface MarketState {
+    marketId: string;
+    gameId: string;
+    status: string;
+    outcomes: string[];
+    prices: Record<string, number>;
+    totalCollateral: string;
+    totalVolume: string;
+    totalFees: string;
+    resolvedOutcome: string | null;
+}
+interface MarketPosition {
+    outcomeId: string;
+    shares: string;
+    avgCostPerShare: string;
+    totalCost: string;
+    currentPrice: number;
+    currentValue: string;
+    unrealizedPnl: string;
+}
+interface MarketBuyResult {
+    tradeId: string;
+    sharesReceived: string;
+    costPerShare: string;
+    newPrices: Record<string, number>;
+}
+interface MarketSellResult {
+    tradeId: string;
+    amountReceived: string;
+    pricePerShare: string;
+    newPrices: Record<string, number>;
+}
+interface RedeemResult {
+    status: string;
+    payout: string;
+    fee: string;
+    netPayout: string;
+    profit: string;
+}
+interface AdminMarketStats {
+    totalMarkets: number;
+    openMarkets: number;
+    resolvedMarkets: number;
+    totalVolume: string;
+    totalFees: string;
+    uniqueTraders: number;
+}
+interface AdminMarketDailyStatsItem {
+    date: string;
+    marketsOpened: number;
+    marketsResolved: number;
+    tradesExecuted: number;
+    volume: string;
+    fees: string;
+}
+interface AdminMarketDailyStats {
+    days: AdminMarketDailyStatsItem[];
+}
+interface AdminMarketDetail {
+    id: string;
+    gameId: string;
+    status: string;
+    outcomes: string[];
+    resolvedOutcome: string | null;
+    totalCollateral: string;
+    totalVolume: string;
+    totalFees: string;
+    createdAt: string;
+    resolvedAt: string | null;
+    positionCount: number;
+}
+/**
+ * SDK class for prediction market operations.
+ *
+ * @example
+ * ```ts
+ * const market = await sdk.markets.getMarket(gameId);
+ * console.log(market.prices); // { playerAId: 0.6, playerBId: 0.4 }
+ *
+ * const { transaction } = await sdk.markets.prepareBuyOrder(gameId, playerAId, 1_000_000);
+ * // ... sign transaction ...
+ * const result = await sdk.markets.submitBuyOrder(gameId, signedTxBase64, playerAId, 1_000_000);
+ * console.log(result.sharesReceived);
+ * ```
+ */
+declare class Markets {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    /**
+     * Get the prediction market state for a game.
+     * Returns prices, volume, collateral, and resolution status.
+     */
+    getMarket(gameId: string): Promise<MarketState>;
+    /**
+     * Get the authenticated user's positions for a game.
+     * Returns shares held, average cost, current value, and unrealized P&L.
+     */
+    getMyPositions(gameId: string): Promise<MarketPosition[]>;
+    /**
+     * Prepare a buy order deposit transaction (unsigned, for client signing).
+     * @param gameId - The game ID
+     * @param outcomeId - The outcome to buy (typically a player ID)
+     * @param amountMinor - Amount to spend in USDC minor units
+     */
+    prepareBuyOrder(gameId: string, outcomeId: string, amountMinor: number): Promise<{
+        transaction: string;
+    }>;
+    /**
+     * Submit a signed buy order deposit transaction and execute the trade.
+     * Shares are received instantly via the AMM pool.
+     * @param gameId - The game ID
+     * @param signedTransaction - Base64-encoded signed Solana transaction
+     * @param outcomeId - The outcome to buy (typically a player ID)
+     * @param amountMinor - Amount to spend in USDC minor units
+     */
+    submitBuyOrder(gameId: string, signedTransaction: string, outcomeId: string, amountMinor: number): Promise<MarketBuyResult>;
+    /**
+     * Sell shares back to the AMM pool.
+     * @param gameId - The game ID
+     * @param outcomeId - The outcome to sell
+     * @param shares - Number of shares to sell (in minor units)
+     */
+    sellShares(gameId: string, outcomeId: string, shares: number): Promise<MarketSellResult>;
+    /**
+     * Redeem winning shares after a market is resolved.
+     * @param gameId - The game ID
+     */
+    redeemShares(gameId: string): Promise<RedeemResult>;
+    /**
+     * Get aggregate prediction market stats.
+     * Requires admin privileges.
+     */
+    getAdminStats(): Promise<AdminMarketStats>;
+    /**
+     * Get daily prediction market stats breakdown.
+     * Requires admin privileges.
+     * @param days - Number of days to look back (default 30)
+     */
+    getAdminDailyStats(days?: number): Promise<AdminMarketDailyStats>;
+    /**
+     * List all prediction markets with position counts.
+     * Requires admin privileges.
+     */
+    getAdminMarkets(page?: number, limit?: number): Promise<{
+        markets: AdminMarketDetail[];
+        total: number;
+    }>;
+}
+
+type LobbyMatchedEvent = {
+    gameId: string;
+    gameType: string;
+    matchedLobbies: Lobby[];
+};
+type LobbyStoreState = {
+    lobbiesById: Record<string, Lobby>;
+    matchedEvent: LobbyMatchedEvent | null;
+    typingByLobbyId: Record<string, string[]>;
+};
+type LobbyStore = {
+    store: SdkStore<LobbyStoreState>;
+    setBaseState: (lobbies: Lobby[]) => void;
+    applyWsEvent: (event: WsEvent) => void;
+    joinLobby: (lobbyId: string) => () => void;
+    subscribeMatched: (callback: (event: LobbyMatchedEvent) => void) => () => void;
+};
+declare function createLobbyStore(transport: WsTransport): LobbyStore;
+
+type GameStoreState = {
+    gamesById: Record<string, Game>;
+    /** Real-time spectator counts by userId, updated via spectator:count:updated WS events. */
+    spectatorCounts: Record<string, number>;
+};
+type GameStore = {
+    store: SdkStore<GameStoreState>;
+    setBaseState: (games: Game[]) => void;
+    applyWsEvent: (event: WsEvent) => void;
+    joinGame: (gameId: string) => () => void;
+    /** Join the spectate channel for a user. Returns a leave function. */
+    joinSpectateChannel: (spectatedUserId: string) => () => void;
+    /** Get a snapshot of the spectator count for a user (from the store). */
+    getSpectatorCount: (userId: string) => number;
+};
+declare function createGameStore(transport: WsTransport): GameStore;
+
+type GameActionsStoreState = {
+    statesByGameId: Record<string, GameStateResponse>;
+};
+type GameActionsStore = {
+    store: SdkStore<GameActionsStoreState>;
+    setBaseState: (gameId: string, state: GameStateResponse) => void;
+    clearState: (gameId: string) => void;
+    applyWsEvent: (event: WsEvent) => void;
+    joinGame: (gameId: string) => () => void;
+};
+declare function createGameActionsStore(transport: WsTransport): GameActionsStore;
+
+interface TypingUser {
+    userId: string;
+    username?: string;
+}
+interface ChatState {
+    context: ChatContext;
+    messages: ChatMessage[];
+    typingUsers: TypingUser[];
+}
+type ChatStoreState = {
+    contextsByKey: Record<string, ChatState>;
+};
+type ChatStore = {
+    store: SdkStore<ChatStoreState>;
+    setMessages: (context: ChatContext, messages: ChatMessage[]) => void;
+    applyWsEvent: (event: WsEvent) => void;
+    joinContext: (context: ChatContext) => () => void;
+    leaveContext: (context: ChatContext) => void;
+};
+declare function createChatStore(transport: WsTransport): ChatStore;
+
+type DmThreadsStoreState = {
+    threads: DmThread[];
+    loading: boolean;
+    error: string | null;
+    needsRefresh: boolean;
+};
+type DmThreadsStore = {
+    store: SdkStore<DmThreadsStoreState>;
+    setBaseState: (threads: DmThread[]) => void;
+    setLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    setCurrentUserId: (userId: string | null) => void;
+    applyWsEvent: (event: WsEvent) => void;
+};
+declare function createDmThreadsStore(): DmThreadsStore;
+
+type FriendshipStatus = 'none' | 'incoming' | 'outgoing' | 'friends';
+type FriendsStoreState = {
+    /** Optimistic overrides keyed by userId. Only set when status differs from API (e.g. 'outgoing' after send, cleared when API data arrives). */
+    friendshipStatusOverrides: Record<string, FriendshipStatus>;
+};
+type FriendsStore = {
+    store: SdkStore<FriendsStoreState>;
+    setOptimisticStatus: (userId: string, status: FriendshipStatus) => void;
+    clearOverride: (userId: string) => void;
+    clearOverridesForUsers: (userIds: string[]) => void;
+};
+declare function createFriendsStore(): FriendsStore;
+
+interface SdkUpgradeInfo {
+    message: string;
+    minSdkVersion: string;
+}
+declare class WsEventBus {
+    private transport;
+    private upgradeHandlers;
+    private upgradeUnsubscribe;
+    constructor(transport: WsTransport);
+    subscribe<T>(eventName: string, handler: (payload: T) => void): () => void;
+    /**
+     * Register a handler to be called when the server recommends an SDK upgrade.
+     * Returns an unsubscribe function.
+     */
+    onUpgradeRecommended(handler: (info: SdkUpgradeInfo) => void): () => void;
+}
+
+declare class SDK {
+    private http;
+    auth: Auth;
+    admin: Admin;
+    users: Users;
+    featureFlags: FeatureFlags;
+    lobbies: Lobbies;
+    games: Games;
+    spectate: Spectate;
+    chat: Chat;
+    challenges: Challenges;
+    tips: Tips;
+    daily: Daily;
+    activity: Activity;
+    leaderboards: Leaderboards;
+    notifications: Notifications;
+    achievements: Achievements;
+    wallet: Wallet;
+    escrow: Escrow;
+    referrals: Referrals;
+    reports: Reports;
+    support: Support;
+    markets: Markets;
+    wsTransport: WsTransport;
+    lobbyStore: LobbyStore;
+    gameStore: GameStore;
+    gameActionsStore: GameActionsStore;
+    chatStore: ChatStore;
+    dmThreadsStore: DmThreadsStore;
+    notificationsStore: NotificationsStore;
+    friendsStore: FriendsStore;
+    events: WsEventBus;
+    private wsRouter;
+    constructor(config: SDKConfig);
+    /**
+     * Ensure the shared WebSocket connection is established.
+     *
+     * Some backend operations (e.g. joining the matchmaking queue) require the user
+     * to be connected to the app via WebSocket.
+     */
+    ensureWebSocketConnected(timeoutMs?: number): Promise<void>;
+}
+
+/**
+ * SDK version constant.
+ *
+ * This must be kept in sync with the version in package.json.
+ * Sent to the API via the `X-SDK-Version` header on every HTTP request
+ * and in the Socket.IO handshake auth.
+ */
+declare const SDK_VERSION = "1.0.0";
+
+declare abstract class BaseWsTransport implements WsTransport {
+    private roomRefs;
+    private waiters;
+    protected connectionState: ConnectionState;
+    protected appId: string | null;
+    abstract connect(): void;
+    abstract disconnect(): void;
+    abstract setAccessToken(token: string): void;
+    abstract clearAccessToken(): void;
+    abstract subscribeEvent(eventName: string, handler: (payload: unknown) => void): () => void;
+    abstract subscribeAll(handler: (event: string, payload: unknown) => void): () => void;
+    abstract emit(eventName: string, payload?: unknown): void;
+    setAppId(appId: string): void;
+    getConnectionState(): ConnectionState;
+    resetRooms(): void;
+    joinRoom(roomName: string): () => void;
+    waitUntilConnected(timeoutMs?: number): Promise<void>;
+    protected updateConnectionState(next: Partial<ConnectionState>): void;
+    protected handleAuthFailure(message?: string): void;
+    protected onReconnect(): void;
+    protected abstract onJoinRoom(roomName: string): void;
+    protected abstract onLeaveRoom(roomName: string): void;
+    private leaveRoom;
+}
+
+declare class StandaloneWsTransport extends BaseWsTransport {
+    private socket;
+    private url;
+    private accessToken;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private reconnectDelayMax;
+    private wildcardHandlers;
+    private eventHandlers;
+    private registeredEvents;
+    private wildcardRegistered;
+    constructor(url: string);
+    connect(): void;
+    disconnect(): void;
+    setAccessToken(token: string): void;
+    clearAccessToken(): void;
+    subscribeEvent(eventName: string, handler: WsEventHandler): () => void;
+    subscribeAll(handler: WsWildcardHandler): () => void;
+    emit(eventName: string, payload?: unknown): void;
+    protected onJoinRoom(roomName: string): void;
+    protected onLeaveRoom(roomName: string): void;
+    private ensureSocket;
+    private reconnectWithAuth;
+    private scheduleReconnect;
+    private getEventHandlers;
+    private unsubscribeEvent;
+    private unsubscribeAll;
+    private dispatchEvent;
+    private dispatchWildcard;
+    private registerEventHandler;
+    private registerWildcard;
+}
+
+declare class SharedWorkerTransport extends BaseWsTransport {
+    private client;
+    private url;
+    constructor(workerUrl: string, socketUrl: string);
+    connect(): void;
+    disconnect(): void;
+    setAccessToken(token: string): void;
+    clearAccessToken(): void;
+    setAppId(appId: string): void;
+    subscribeEvent(eventName: string, handler: WsEventHandler): () => void;
+    subscribeAll(handler: WsWildcardHandler): () => void;
+    emit(eventName: string, payload?: unknown): void;
+    protected onJoinRoom(roomName: string): void;
+    protected onLeaveRoom(roomName: string): void;
+    private handleWorkerMessage;
+}
+
+declare class HttpClient implements IHttpClient {
+    private baseUrl;
+    private storage;
+    private logger;
+    private appId?;
+    constructor(baseUrl: string, storage: IStorage, logger?: ILogger, appId?: string);
+    request<T>(endpoint: string, options?: RequestInit): Promise<T>;
+    get<T>(endpoint: string, options?: RequestInit): Promise<T>;
+    post<T>(endpoint: string, data?: any, options?: RequestInit): Promise<T>;
+    patch<T>(endpoint: string, data?: any, options?: RequestInit): Promise<T>;
+    delete<T>(endpoint: string, options?: RequestInit): Promise<T>;
+    upload<T>(endpoint: string, formData: FormData): Promise<T>;
+}
+
+export { type AcceptChallengeResponse, type Achievement, Activity, type ActivityFeedItem, type ActivityFeedItemType, type ActivityFeedResponse, type ActivityFeedUser, Admin, type AdminDailyStats, type AdminDailyStatsItem, type AdminGameHistory, type AdminGameHistoryFeeBreakdown, type AdminGameHistoryFeePlayer, type AdminGameHistoryPlayer, type AdminMarketDailyStats, type AdminMarketDailyStatsItem, type AdminMarketDetail, type AdminMarketStats, type AdminStats, type AdminWalletActivityItem, type AdminWalletActivityResponse, type ApiError, type AppNotification, type AppNotificationType, type ApplyReferralCodeResponse, type BalanceResponse, type BetOption, type BroadcastTipRequest, BrowserLocalStorage, Challenges, Chat, type ChatContext, type ChatContextType, type ChatMessage, type ChatMessageReply, type ChatMessageType, type ChatReaction, type ChatReadBy, type ChatState, type ChatStore, type ChatStoreState, type ClaimReferralRewardsResponse, type CreateChallengeRequest, type CreateChallengeResponse, type CreateLobbyRequest, type CreateTicketData, type CriticalIncident, type CriticalIncidentCategory, type CriticalIncidentImpactType, type CriticalIncidentSeverity, type CriticalIncidentStatus, type CriticalIncidentSummary, type CurrentGame, Daily, type DailyParticipant, type DailyRoom, type DailyToken, type DepositStatus, type DepositStatusResponse, type DmThread, type DmThreadsStore, type DmThreadsStoreState, type DonateToGameResponse, ESTIMATED_SOL_FEE_LAMPORTS, Escrow, type EscrowSweepPreview, type EscrowSweepRecord, type FaucetResponse, type FeatureFlag, type FriendRequestItem, type FriendsStore, type FriendsStoreState, type FriendshipStatus, type Game, type GameActionsStore, type GameActionsStoreState, type GameHistoryItem, type GameMetrics, type GamePlayer, type GameStateResponse, type GameStore, type GameStoreState, type GameType, Games, type GenerateHandshakeResponse, type GetTicketsOptions, HttpClient, type IHttpClient, type ILogger, type IStorage, type InviteFriendRequest, type LeaderboardEntry, type LeaderboardQuery, type LeaderboardRange, type LeaderboardResponse, Leaderboards, type LivePlayer, type LivePlayersPage, Lobbies, type Lobby, type LobbyMatchedEvent, type LobbyPlayer, type LobbyStore, type LobbyStoreState, type LogLevel, type LoginResponse, MIN_SOL_TRANSFER_AMOUNT, MIN_TRANSFER_AMOUNT, type MarketBuyResult, type MarketPosition, type MarketSellResult, type MarketState, Markets, type MoneyMinor, NodeStorage, type NotificationEvent, type NotificationsStore, type NotificationsStoreState, type PaginatedCriticalIncidents, type PaginatedFriends, type PaginatedNotificationsResponse, type PaginatedReports, type PaginatedSearchUsers, type PaginatedSessions, type PaginatedSupportTickets, type PaginatedUsers, type PrepareDepositResponse, type PrepareTipRequest, type PrepareTipResponse, type PrepareTransferRequest, type PrepareTransferResponse, type PublicUser, type QueueStats, type RedeemResult, type ReferralRewardItem, type ReferralRewardStatus, type ReferralRewardsResponse, type ReferralSummary, type ReferralTreeItem, type ReferralTreeResponse, Referrals, type Report, type ReportCount, type ReportStatus, type ReportUser, Reports, type RetryOptions, SDK, type SDKConfig, SDK_VERSION, SOL_DECIMALS, SOL_MINT, type SdkStore, type SdkUpgradeInfo, type SearchUser, type SendMessageRequest, type SendTipResponse, type SendTransferResponse, type Session, SharedWorkerTransport, Spectate, type SpectatorMetrics, type SpectatorMetricsByUser, StandaloneWsTransport, type SubmitDepositResponse, type SubmitTransferRequest, type SubmitTransferResponse, Support, type SupportMessage, type SupportMessageSenderRole, type SupportTicket, type SupportTicketCategory, type SupportTicketPriority, type SupportTicketStatus, type SupportTicketUser, type SystemMessageType, TOKEN_KEY, TRANSFER_FEE_MINOR, Tips, type TransferToken, type TypingUser, type UpdateTicketData, type User, type UserAchievement, type UserActivity, type UserActivityStatus, type UserStats, type UsernameAvailabilityResponse, Users, type ValidAction, Wallet, type WalletActivityCounterpartyType, type WalletActivityDirection, type WalletActivityItem, type WalletActivityKind, type WalletActivityResponse, type WalletActivityStatus, type WalletClaimAction, type WalletMeta, type WalletResponse, type WalletSigner, type WsEvent, WsEventBus, type WsEventName, type WsTransport, type ConnectionState as WsTransportState, createChatStore, createDmThreadsStore, createFriendsStore, createGameActionsStore, createGameStore, createLobbyStore, createLogger, createNotificationsStore, createSdkStore, isRetryableError, logger, withRetry };