@edge-base/react-native 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,1246 @@
+import { HttpClient, GeneratedDbApi, IDatabaseLiveSubscriber, ContextManager, StorageClient, FunctionsClient, DbRef, ContextValue } from '@edge-base/core';
+import React from 'react';
+
+/**
+ * Token management for React Native — AsyncStorage based.
+ *: Access Token in memory, Refresh Token in persistent storage
+ *: onAuthStateChange
+ *
+ * Key differences from @edge-base/web TokenManager:
+ * - Uses AsyncStorage instead of localStorage (async reads/writes)
+ * - No BroadcastChannel (no multi-tab in RN)
+ * - No storage event listener (RN has no cross-tab concept)
+ * - Simpler: single-tab, single-process model
+ */
+/** Minimal interface compatible with @react-native-async-storage/async-storage */
+interface AsyncStorageAdapter {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+interface TokenPair {
+    accessToken: string;
+    refreshToken: string;
+}
+interface TokenUser {
+    id: string;
+    email?: string;
+    displayName?: string;
+    avatarUrl?: string;
+    role?: string;
+    isAnonymous?: boolean;
+    emailVisibility?: string;
+    custom?: Record<string, unknown>;
+}
+type AuthStateChangeHandler = (user: TokenUser | null) => void;
+declare class TokenManager {
+    private baseUrl;
+    private accessToken;
+    private refreshToken;
+    private refreshPromise;
+    private authStateListeners;
+    private cachedUser;
+    private storage;
+    private initialized;
+    private initPromise;
+    constructor(baseUrl: string, storage: AsyncStorageAdapter);
+    /** Wait for storage restore to complete */
+    ready(): Promise<void>;
+    private restore;
+    /** Get valid access token, refreshing if needed */
+    getAccessToken(doRefresh: (refreshToken: string) => Promise<TokenPair>): Promise<string | null>;
+    /** Set tokens after successful auth (sync in-memory + async persist) */
+    setTokens(tokens: TokenPair): void;
+    /** Get stored refresh token (sync from memory cache) */
+    getRefreshToken(): string | null;
+    /** Drop the current access token so the next request must refresh or fail fast. */
+    invalidateAccessToken(): void;
+    /** Read-only access to current access token (for websocket re-auth). */
+    get currentAccessToken(): string | null;
+    /** Clear all tokens on sign-out */
+    clearTokens(): void;
+    /** Get current user (from cached JWT payload) */
+    getCurrentUser(): TokenUser | null;
+    /** Subscribe to auth state changes. Fires immediately with current state. */
+    onAuthStateChange(handler: AuthStateChangeHandler): () => void;
+    private updateUser;
+    private emitAuthStateChange;
+    /** Clean up (no-op in RN, kept for API parity with web SDK) */
+    destroy(): void;
+}
+
+/**
+ * Auth client for React Native — API parity with @edge-base/web AuthClient.
+ *: onAuthStateChange
+ *: signInAnonymously
+ *: signUp with data
+ *: React Native OAuth via Linking API + deep link callback
+ *
+ * Key differences from web AuthClient:
+ * - signInWithOAuth uses Linking.openURL() instead of window.location.href
+ * - Handles deep link OAuth callback via Linking.addEventListener
+ * - TokenManager.getRefreshToken() is async (AsyncStorage)
+ * - Captcha is handled via TurnstileWebView component (see turnstile.tsx)
+ */
+
+interface SignUpOptions {
+    email: string;
+    password: string;
+    data?: {
+        displayName?: string;
+        avatarUrl?: string;
+        [key: string]: unknown;
+    };
+    /** Captcha token from TurnstileWebView */
+    captchaToken?: string;
+}
+interface SignInOptions {
+    email: string;
+    password: string;
+    /** Captcha token from TurnstileWebView */
+    captchaToken?: string;
+}
+interface AuthResult {
+    user: TokenUser;
+    accessToken: string;
+    refreshToken: string;
+}
+/** Returned when MFA is required during sign-in */
+interface MfaRequiredResult {
+    mfaRequired: true;
+    mfaTicket: string;
+    factors: MfaFactor[];
+}
+interface MfaFactor {
+    id: string;
+    type: string;
+}
+type SignInResult = AuthResult | MfaRequiredResult;
+interface TotpEnrollResult {
+    factorId: string;
+    secret: string;
+    qrCodeUri: string;
+    recoveryCodes: string[];
+}
+interface DisableTotpOptions {
+    password?: string;
+    code?: string;
+}
+interface Session {
+    id: string;
+    createdAt: string;
+    userAgent?: string;
+    ip?: string;
+}
+interface UpdateProfileOptions {
+    displayName?: string;
+    avatarUrl?: string;
+    emailVisibility?: string;
+}
+interface PasskeysAuthOptions {
+    email?: string;
+}
+interface LinkedIdentity {
+    id: string;
+    kind: 'oauth';
+    provider: string;
+    providerUserId: string;
+    createdAt: string;
+    canUnlink: boolean;
+}
+interface IdentityMethods {
+    total: number;
+    hasPassword: boolean;
+    hasMagicLink: boolean;
+    hasEmailOtp: boolean;
+    hasPhone: boolean;
+    passkeyCount: number;
+    oauthCount: number;
+    email?: string | null;
+    phone?: string | null;
+}
+interface IdentitiesResult {
+    ok?: boolean;
+    identities: LinkedIdentity[];
+    methods: IdentityMethods;
+}
+/** Minimal Linking interface — compatible with react-native Linking API */
+interface LinkingAdapter {
+    openURL(url: string): Promise<void>;
+    addEventListener(type: 'url', handler: (event: {
+        url: string;
+    }) => void): {
+        remove: () => void;
+    };
+    getInitialURL(): Promise<string | null>;
+}
+type OAuthStartOptions = {
+    provider: string;
+    redirectUrl?: string;
+    captchaToken?: string;
+};
+declare class AuthClient {
+    private client;
+    private tokenManager;
+    private core;
+    private corePublic;
+    private linking?;
+    private baseUrl;
+    constructor(client: HttpClient, tokenManager: TokenManager, core: GeneratedDbApi, corePublic: GeneratedDbApi, linking?: LinkingAdapter | undefined);
+    /** Register a new user. Optionally include user metadata. */
+    signUp(options: SignUpOptions): Promise<AuthResult>;
+    /** Sign in with email and password. Returns MfaRequiredResult if MFA is enabled. */
+    signIn(options: SignInOptions): Promise<SignInResult>;
+    /** Sign out — revokes current session on server and clears local tokens. */
+    signOut(): Promise<void>;
+    /** Refresh the current session using the stored refresh token. */
+    refreshSession(): Promise<AuthResult>;
+    /**
+     * Start OAuth sign-in flow.
+     * Opens the OAuth URL via Linking.openURL() and listens for the deep link callback.
+     * The app must be configured with a deep link scheme (e.g. myapp://auth/callback).
+     *
+     * @param provider - OAuth provider name (e.g. 'google', 'github')
+     * @param options.redirectUrl - Deep link URL to redirect back to after OAuth (required for RN)
+     * @param options.captchaToken - Optional captcha token
+     * @returns Promise that resolves with AuthResult when OAuth completes
+     *
+     * NOTE: Not delegated to Generated Core — this is URL construction + redirect, not a standard HTTP call.
+     */
+    signInWithOAuth(providerOrOptions: string | OAuthStartOptions, options?: {
+        redirectUrl?: string;
+        captchaToken?: string;
+    }): {
+        url: string;
+    };
+    /**
+     * Handle OAuth deep link callback.
+     * Call this when your app receives a deep link URL with auth tokens.
+     * Extract tokens from query params and store them.
+     *
+     * @example
+     * // In your navigation/linking config:
+     * Linking.addEventListener('url', ({ url }) => client.auth.handleOAuthCallback(url));
+     */
+    handleOAuthCallback(url: string): Promise<AuthResult | null>;
+    /** Sign in anonymously. */
+    signInAnonymously(options?: {
+        captchaToken?: string;
+    }): Promise<AuthResult>;
+    /**
+     * Send a magic link (passwordless login) email.
+     * If the email is not registered and autoCreate is enabled (server config), a new account is created.
+     */
+    signInWithMagicLink(options: {
+        email: string;
+        captchaToken?: string;
+    }): Promise<void>;
+    /**
+     * Verify a magic link token and sign in.
+     * Called after user clicks the link from their email.
+     */
+    verifyMagicLink(token: string): Promise<AuthResult>;
+    /**
+     * Send an SMS verification code to the given phone number.
+     * If the phone is not registered and autoCreate is enabled (server config), a new account is created on verify.
+     */
+    signInWithPhone(options: {
+        phone: string;
+        captchaToken?: string;
+    }): Promise<void>;
+    /**
+     * Verify the SMS code and sign in.
+     * Called after user receives the code from signInWithPhone.
+     */
+    verifyPhone(options: {
+        phone: string;
+        code: string;
+    }): Promise<AuthResult>;
+    /** Link current account with a phone number. Sends an SMS code. */
+    linkWithPhone(options: {
+        phone: string;
+    }): Promise<void>;
+    /** Verify phone link code. Completes phone linking for the current account. */
+    verifyLinkPhone(options: {
+        phone: string;
+        code: string;
+    }): Promise<void>;
+    /** Link anonymous account to email/password. */
+    linkWithEmail(options: {
+        email: string;
+        password: string;
+    }): Promise<AuthResult>;
+    /**
+     * Link anonymous account to OAuth provider. Returns URL to open in browser.
+     *
+     * NOTE: Not delegated — Generated Core's oauthLinkStart(provider) takes no body,
+     * but we need to pass { redirectUrl }.
+     */
+    linkWithOAuth(providerOrOptions: string | {
+        provider: string;
+        redirectUrl?: string;
+    }, options?: {
+        redirectUrl?: string;
+    }): Promise<{
+        redirectUrl: string;
+    }>;
+    /** Subscribe to authentication state changes. */
+    onAuthStateChange(callback: AuthStateChangeHandler): () => void;
+    /** Get current authenticated user (from cached JWT). */
+    get currentUser(): TokenUser | null;
+    /** List active sessions. */
+    listSessions(): Promise<Session[]>;
+    /** Revoke a specific session. */
+    revokeSession(sessionId: string): Promise<void>;
+    /** Update current user's profile. */
+    updateProfile(data: UpdateProfileOptions): Promise<TokenUser>;
+    /** Verify email address with token. */
+    verifyEmail(token: string): Promise<void>;
+    /** Request a verification email for the current user. */
+    requestEmailVerification(options?: {
+        redirectUrl?: string;
+    }): Promise<void>;
+    /** Verify a pending email change using the emailed token. */
+    verifyEmailChange(token: string): Promise<void>;
+    /** Request password reset email. */
+    requestPasswordReset(email: string, options?: {
+        captchaToken?: string;
+    }): Promise<void>;
+    /** Reset password with token. */
+    resetPassword(token: string, newPassword: string): Promise<void>;
+    /** Change password for authenticated user. */
+    changePassword(options: {
+        currentPassword: string;
+        newPassword: string;
+    }): Promise<AuthResult>;
+    /** Request an email change for the authenticated user. */
+    changeEmail(options: {
+        newEmail: string;
+        password: string;
+        redirectUrl?: string;
+    }): Promise<void>;
+    /** List linked sign-in identities for the current user. */
+    listIdentities(): Promise<IdentitiesResult>;
+    /** Unlink a linked OAuth identity by its identity ID. */
+    unlinkIdentity(identityId: string): Promise<IdentitiesResult>;
+    /** Send an email OTP code for sign-in. */
+    signInWithEmailOtp(options: {
+        email: string;
+    }): Promise<void>;
+    /** Verify an email OTP code and sign in. */
+    verifyEmailOtp(options: {
+        email: string;
+        code: string;
+    }): Promise<AuthResult>;
+    /** Generate WebAuthn registration options for the current authenticated user. */
+    passkeysRegisterOptions(): Promise<unknown>;
+    /** Verify and store a passkey registration response from the platform credential API. */
+    passkeysRegister(response: unknown): Promise<unknown>;
+    /** Generate WebAuthn authentication options. */
+    passkeysAuthOptions(options?: PasskeysAuthOptions): Promise<unknown>;
+    /** Verify a WebAuthn assertion and establish a session. */
+    passkeysAuthenticate(response: unknown): Promise<AuthResult>;
+    /** List registered passkeys for the current authenticated user. */
+    passkeysList(): Promise<unknown>;
+    /** Delete a registered passkey by credential ID. */
+    passkeysDelete(credentialId: string): Promise<unknown>;
+    /** MFA sub-namespace for TOTP enrollment, verification, and management. */
+    get mfa(): {
+        /** Enroll TOTP — returns secret, QR code URI, and recovery codes. */
+        enrollTotp(): Promise<TotpEnrollResult>;
+        /** Verify TOTP enrollment with factorId and a TOTP code. */
+        verifyTotpEnrollment(factorId: string, code: string): Promise<{
+            ok: true;
+        }>;
+        /** Verify TOTP code during MFA challenge (after signIn returns mfaRequired). */
+        verifyTotp(mfaTicket: string, code: string): Promise<AuthResult>;
+        /** Use a recovery code during MFA challenge. */
+        useRecoveryCode(mfaTicket: string, recoveryCode: string): Promise<AuthResult>;
+        /**
+         * Disable TOTP for the current user. Requires password or TOTP code.
+         */
+        disableTotp(options?: DisableTotpOptions): Promise<{
+            ok: true;
+        }>;
+        /** List enrolled MFA factors for the current user. */
+        listFactors(): Promise<{
+            factors: MfaFactor[];
+        }>;
+    };
+}
+
+type ChangeType = 'added' | 'modified' | 'removed';
+type ErrorHandler$1 = (error: {
+    code: string;
+    message: string;
+}) => void;
+interface DbChange<T = Record<string, unknown>> {
+    changeType: ChangeType;
+    table: string;
+    docId: string;
+    data: T | null;
+    timestamp: string;
+}
+interface DatabaseLiveOptions {
+    autoReconnect?: boolean;
+    maxReconnectAttempts?: number;
+    reconnectBaseDelay?: number;
+}
+declare class DatabaseLiveClient implements IDatabaseLiveSubscriber {
+    private baseUrl;
+    private tokenManager;
+    private ws;
+    private connectingPromise;
+    private subscriptions;
+    private connectedChannels;
+    private channelFilters;
+    private channelOrFilters;
+    private errorHandlers;
+    private reconnectAttempts;
+    private connected;
+    private authenticated;
+    private waitingForAuth;
+    private authRecoveryPromise;
+    private heartbeatTimer;
+    private unsubAuthState;
+    private options;
+    constructor(baseUrl: string, tokenManager: TokenManager, options?: DatabaseLiveOptions, contextManager?: ContextManager);
+    onSnapshot<T>(channel: string, callback: (change: DbChange<T>) => void, clientFilters?: unknown, serverFilters?: unknown, serverOrFilters?: unknown): () => void;
+    onError(handler: ErrorHandler$1): () => void;
+    connect(channel: string): Promise<void>;
+    reconnect(): void;
+    disconnect(): void;
+    private establishConnection;
+    private authenticate;
+    private handleMessage;
+    private sendSubscribe;
+    private sendUnsubscribe;
+    private resubscribeAll;
+    private refreshAuth;
+    private handleAuthStateChange;
+    private handleAuthenticationFailure;
+    private resyncFilters;
+    private scheduleReconnect;
+    private buildWsUrl;
+    private sendRaw;
+    private hasAuthContext;
+    private recoverAuthentication;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private handleContextChange;
+}
+
+/**
+ * RoomClient v2 — Client-side room connection for real-time multiplayer state.
+ *
+ *: Complete redesign from v1.
+ *   - 3 state areas: sharedState (all clients), playerState (per-player), serverState (server-only, not sent)
+ *   - Client can only read + subscribe + send(). All writes are server-only.
+ *   - send() returns a Promise resolved by requestId matching
+ *   - Subscription returns { unsubscribe() } object
+ *   - namespace + roomId identification (replaces single roomId)
+ */
+
+interface RoomOptions {
+    /** Auto-reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Max reconnect attempts (default: 10) */
+    maxReconnectAttempts?: number;
+    /** Base delay for reconnect backoff in ms (default: 1000) */
+    reconnectBaseDelay?: number;
+    /** Timeout for send() requests in ms (default: 10000) */
+    sendTimeout?: number;
+}
+interface Subscription {
+    unsubscribe(): void;
+}
+type SharedStateHandler = (state: Record<string, unknown>, changes: Record<string, unknown>) => void;
+type PlayerStateHandler = (state: Record<string, unknown>, changes: Record<string, unknown>) => void;
+type MessageHandler = (data: unknown) => void;
+type ErrorHandler = (error: {
+    code: string;
+    message: string;
+}) => void;
+type KickedHandler = () => void;
+type RoomConnectionState = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'disconnected' | 'auth_lost' | 'kicked';
+type RoomMemberLeaveReason = 'leave' | 'timeout' | 'kicked';
+interface RoomSignalMeta {
+    memberId?: string | null;
+    userId?: string | null;
+    connectionId?: string | null;
+    sentAt?: number;
+    serverSent?: boolean;
+}
+interface RoomMember {
+    memberId: string;
+    userId: string;
+    connectionId?: string;
+    connectionCount?: number;
+    role?: string;
+    state: Record<string, unknown>;
+}
+interface RoomReconnectInfo {
+    attempt: number;
+}
+type RoomMediaKind = 'audio' | 'video' | 'screen';
+interface RoomMediaTrack {
+    kind: RoomMediaKind;
+    trackId?: string;
+    deviceId?: string;
+    muted: boolean;
+    publishedAt?: number;
+    adminDisabled?: boolean;
+}
+interface RoomMemberMediaKindState {
+    published: boolean;
+    muted: boolean;
+    trackId?: string;
+    deviceId?: string;
+    publishedAt?: number;
+    adminDisabled?: boolean;
+}
+interface RoomMemberMediaState {
+    audio?: RoomMemberMediaKindState;
+    video?: RoomMemberMediaKindState;
+    screen?: RoomMemberMediaKindState;
+}
+interface RoomMediaMember {
+    member: RoomMember;
+    state: RoomMemberMediaState;
+    tracks: RoomMediaTrack[];
+}
+interface RoomMediaDeviceChange {
+    kind: RoomMediaKind;
+    deviceId: string;
+}
+declare class RoomClient {
+    private baseUrl;
+    private tokenManager;
+    private options;
+    /** Room namespace (e.g. 'game', 'chat') */
+    readonly namespace: string;
+    /** Room instance ID within the namespace */
+    readonly roomId: string;
+    private _sharedState;
+    private _sharedVersion;
+    private _playerState;
+    private _playerVersion;
+    private _members;
+    private _mediaMembers;
+    private ws;
+    private reconnectAttempts;
+    private connected;
+    private authenticated;
+    private joined;
+    private currentUserId;
+    private currentConnectionId;
+    private connectionState;
+    private reconnectInfo;
+    private connectingPromise;
+    private heartbeatTimer;
+    private intentionallyLeft;
+    private waitingForAuth;
+    private joinRequested;
+    private unsubAuthState;
+    private pendingRequests;
+    private pendingSignalRequests;
+    private pendingAdminRequests;
+    private pendingMemberStateRequests;
+    private pendingMediaRequests;
+    private sharedStateHandlers;
+    private playerStateHandlers;
+    private messageHandlers;
+    private allMessageHandlers;
+    private errorHandlers;
+    private kickedHandlers;
+    private memberSyncHandlers;
+    private memberJoinHandlers;
+    private memberLeaveHandlers;
+    private memberStateHandlers;
+    private signalHandlers;
+    private anySignalHandlers;
+    private mediaTrackHandlers;
+    private mediaTrackRemovedHandlers;
+    private mediaStateHandlers;
+    private mediaDeviceHandlers;
+    private reconnectHandlers;
+    private connectionStateHandlers;
+    readonly state: {
+        getShared: () => Record<string, unknown>;
+        getMine: () => Record<string, unknown>;
+        onSharedChange: (handler: SharedStateHandler) => Subscription;
+        onMineChange: (handler: PlayerStateHandler) => Subscription;
+        send: (actionType: string, payload?: unknown) => Promise<unknown>;
+    };
+    readonly meta: {
+        get: () => Promise<Record<string, unknown>>;
+    };
+    readonly signals: {
+        send: (event: string, payload?: unknown, options?: {
+            includeSelf?: boolean;
+        }) => Promise<void>;
+        sendTo: (memberId: string, event: string, payload?: unknown) => Promise<void>;
+        on: (event: string, handler: (payload: unknown, meta: RoomSignalMeta) => void) => Subscription;
+        onAny: (handler: (event: string, payload: unknown, meta: RoomSignalMeta) => void) => Subscription;
+    };
+    readonly members: {
+        list: () => RoomMember[];
+        onSync: (handler: (members: RoomMember[]) => void) => Subscription;
+        onJoin: (handler: (member: RoomMember) => void) => Subscription;
+        onLeave: (handler: (member: RoomMember, reason: RoomMemberLeaveReason) => void) => Subscription;
+        setState: (state: Record<string, unknown>) => Promise<void>;
+        clearState: () => Promise<void>;
+        onStateChange: (handler: (member: RoomMember, state: Record<string, unknown>) => void) => Subscription;
+    };
+    readonly admin: {
+        kick: (memberId: string) => Promise<void>;
+        mute: (memberId: string) => Promise<void>;
+        block: (memberId: string) => Promise<void>;
+        setRole: (memberId: string, role: string) => Promise<void>;
+        disableVideo: (memberId: string) => Promise<void>;
+        stopScreenShare: (memberId: string) => Promise<void>;
+    };
+    readonly media: {
+        list: () => RoomMediaMember[];
+        audio: {
+            enable: (payload?: {
+                trackId?: string;
+                deviceId?: string;
+            }) => Promise<void>;
+            disable: () => Promise<void>;
+            setMuted: (muted: boolean) => Promise<void>;
+        };
+        video: {
+            enable: (payload?: {
+                trackId?: string;
+                deviceId?: string;
+            }) => Promise<void>;
+            disable: () => Promise<void>;
+            setMuted: (muted: boolean) => Promise<void>;
+        };
+        screen: {
+            start: (payload?: {
+                trackId?: string;
+                deviceId?: string;
+            }) => Promise<void>;
+            stop: () => Promise<void>;
+        };
+        devices: {
+            switch: (payload: {
+                audioInputId?: string;
+                videoInputId?: string;
+                screenInputId?: string;
+            }) => Promise<void>;
+        };
+        onTrack: (handler: (track: RoomMediaTrack, member: RoomMember) => void) => Subscription;
+        onTrackRemoved: (handler: (track: RoomMediaTrack, member: RoomMember) => void) => Subscription;
+        onStateChange: (handler: (member: RoomMember, state: RoomMemberMediaState) => void) => Subscription;
+        onDeviceChange: (handler: (member: RoomMember, change: RoomMediaDeviceChange) => void) => Subscription;
+    };
+    readonly session: {
+        onError: (handler: ErrorHandler) => Subscription;
+        onKicked: (handler: KickedHandler) => Subscription;
+        onReconnect: (handler: (info: RoomReconnectInfo) => void) => Subscription;
+        onConnectionStateChange: (handler: (state: RoomConnectionState) => void) => Subscription;
+    };
+    constructor(baseUrl: string, namespace: string, roomId: string, tokenManager: TokenManager, options?: RoomOptions);
+    /** Get current shared state (read-only snapshot) */
+    getSharedState(): Record<string, unknown>;
+    /** Get current player state (read-only snapshot) */
+    getPlayerState(): Record<string, unknown>;
+    /**
+     * Get room metadata without joining (HTTP GET).
+     * Returns developer-defined metadata set by room.setMetadata() on the server.
+     */
+    getMetadata(): Promise<Record<string, unknown>>;
+    /**
+     * Static: Get room metadata without creating a RoomClient instance.
+     * Useful for lobby screens where you need room info before joining.
+     */
+    static getMetadata(baseUrl: string, namespace: string, roomId: string): Promise<Record<string, unknown>>;
+    /** Connect to the room, authenticate, and join */
+    join(): Promise<void>;
+    /** Leave the room and disconnect. Cleans up all pending requests. */
+    leave(): void;
+    /**
+     * Send an action to the server.
+     * Returns a Promise that resolves with the action result from the server.
+     *
+     * @example
+     * const result = await room.send('SET_SCORE', { score: 42 });
+     */
+    send(actionType: string, payload?: unknown): Promise<unknown>;
+    /**
+     * Subscribe to shared state changes.
+     * Called on full sync and on each shared_delta.
+     *
+     * @returns Subscription with unsubscribe()
+     */
+    onSharedState(handler: SharedStateHandler): Subscription;
+    /**
+     * Subscribe to player state changes.
+     * Called on full sync and on each player_delta.
+     *
+     * @returns Subscription with unsubscribe()
+     */
+    onPlayerState(handler: PlayerStateHandler): Subscription;
+    /**
+     * Subscribe to messages of a specific type sent by room.sendMessage().
+     *
+     * @example
+     * room.onMessage('game_over', (data) => { console.log(data.winner); });
+     *
+     * @returns Subscription with unsubscribe()
+     */
+    onMessage(messageType: string, handler: MessageHandler): Subscription;
+    /**
+     * Subscribe to ALL messages regardless of type.
+     *
+     * @returns Subscription with unsubscribe()
+     */
+    onAnyMessage(handler: (messageType: string, data: unknown) => void): Subscription;
+    /** Subscribe to errors */
+    onError(handler: ErrorHandler): Subscription;
+    /** Subscribe to kick events */
+    onKicked(handler: KickedHandler): Subscription;
+    private onSignal;
+    private onAnySignal;
+    private onMembersSync;
+    private onMemberJoin;
+    private onMemberLeave;
+    private onMemberStateChange;
+    private onReconnect;
+    private onConnectionStateChange;
+    private onMediaTrack;
+    private onMediaTrackRemoved;
+    private onMediaStateChange;
+    private onMediaDeviceChange;
+    private sendSignal;
+    private sendMemberState;
+    private clearMemberState;
+    private sendMemberStateRequest;
+    private sendAdmin;
+    private sendMedia;
+    private switchMediaDevices;
+    private establishConnection;
+    private ensureConnection;
+    private authenticate;
+    private handleMessage;
+    private handleSync;
+    private handleSharedDelta;
+    private handlePlayerDelta;
+    private handleActionResult;
+    private handleActionError;
+    private handleAuthAck;
+    private handleServerMessage;
+    private handleSignalFrame;
+    private handleSignalSent;
+    private handleSignalError;
+    private handleMembersSync;
+    private handleMediaSync;
+    private handleMemberJoinFrame;
+    private handleMemberLeaveFrame;
+    private handleMemberStateFrame;
+    private handleMemberStateError;
+    private handleMediaTrackFrame;
+    private handleMediaTrackRemovedFrame;
+    private handleMediaStateFrame;
+    private handleMediaDeviceFrame;
+    private handleMediaResult;
+    private handleMediaError;
+    private handleAdminResult;
+    private handleAdminError;
+    private handleKicked;
+    private handleError;
+    private refreshAuth;
+    private handleAuthStateChange;
+    private handleAuthenticationFailure;
+    private normalizeMembers;
+    private normalizeMediaMembers;
+    private normalizeMember;
+    private normalizeState;
+    private normalizeMediaMember;
+    private normalizeMediaState;
+    private normalizeMediaKindState;
+    private normalizeMediaTracks;
+    private normalizeMediaTrack;
+    private normalizeMediaKind;
+    private normalizeSignalMeta;
+    private normalizeLeaveReason;
+    private upsertMember;
+    private removeMember;
+    private syncMediaMemberInfo;
+    private ensureMediaMember;
+    private removeMediaMember;
+    private upsertMediaTrack;
+    private removeMediaTrack;
+    private mergeMediaState;
+    private rejectPendingVoidRequests;
+    private setConnectionState;
+    private sendRaw;
+    private buildWsUrl;
+    private scheduleReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+}
+
+/**
+ * React Native Push Notification client.
+ *
+ * Platform support (FCM 일원화):
+ * - iOS: FCM token via Firebase iOS SDK bridge (tokenProvider callback)
+ * - Android: FCM token via FirebaseMessaging bridge (tokenProvider callback)
+ *
+ * Zero-parameter register() design: tokenProvider closure is set by native
+ * app code (AppDelegate / Application) before register() is called.
+ * SDK never calls native APIs directly — avoids hard dependency on firebase-messaging.
+ *
+ * @example
+ * // In AppDelegate (iOS) or Application (Android):
+ * client.push.setTokenProvider(async () => {
+ *   const token = await messaging().getToken();  // FCM or APNs
+ *   return { token, platform: 'android' };
+ * });
+ * // Then anywhere:
+ * await client.push.register();
+ */
+
+type PushPlatform = 'ios' | 'android' | 'web';
+interface PushTokenProvider {
+    (): Promise<{
+        token: string;
+        platform: PushPlatform;
+    }>;
+}
+type PushPermissionStatus = 'granted' | 'denied' | 'not-determined' | 'provisional';
+interface PushPermissionProvider {
+    getPermissionStatus(): Promise<PushPermissionStatus>;
+    requestPermission(): Promise<PushPermissionStatus>;
+}
+interface PushMessage {
+    title?: string;
+    body?: string;
+    data?: Record<string, unknown>;
+}
+type PushMessageHandler = (message: PushMessage) => void;
+interface PushTopicProvider {
+    subscribeTopic(topic: string): Promise<void>;
+    unsubscribeTopic(topic: string): Promise<void>;
+}
+declare class PushClient {
+    private http;
+    private storage;
+    private core?;
+    private tokenProvider;
+    private permissionProvider;
+    private topicProvider;
+    private messageListeners;
+    private openedAppListeners;
+    constructor(http: HttpClient, storage: AsyncStorageAdapter, core?: GeneratedDbApi | undefined);
+    /**
+     * Set the native token provider.
+     * Must be called before register() — typically in App.tsx or native bootstrapping.
+     *
+     * @example (Firebase Messaging)
+     * client.push.setTokenProvider(async () => ({
+     *   token: await messaging().getToken(),
+     *   platform: 'android',
+     * }));
+     *
+     * @example (APNs via native bridge)
+     * client.push.setTokenProvider(async () => ({
+     *   token: nativeBridge.getAPNsToken(),
+     *   platform: 'ios',
+     * }));
+     */
+    setTokenProvider(provider: PushTokenProvider): void;
+    /**
+     * Set the native permission provider.
+     * Call this with your FCM / @notifee/react-native permission handler.
+     *
+     * @example (Firebase Messaging)
+     * client.push.setPermissionProvider({
+     *   getPermissionStatus: async () => {
+     *     const status = await messaging().hasPermission();
+     *     if (status === messaging.AuthorizationStatus.AUTHORIZED) return 'granted';
+     *     if (status === messaging.AuthorizationStatus.PROVISIONAL) return 'provisional';
+     *     if (status === messaging.AuthorizationStatus.DENIED) return 'denied';
+     *     return 'not-determined';
+     *   },
+     *   requestPermission: async () => {
+     *     const status = await messaging().requestPermission();
+     *     if (status === messaging.AuthorizationStatus.AUTHORIZED) return 'granted';
+     *     if (status === messaging.AuthorizationStatus.PROVISIONAL) return 'provisional';
+     *     return 'denied';
+     *   },
+     * });
+     */
+    setPermissionProvider(provider: PushPermissionProvider): void;
+    /**
+     * Get current push notification permission status.
+     * Uses custom provider if set via setPermissionProvider(), otherwise uses
+     * built-in platform defaults (PermissionsAndroid on Android, auto-grant on iOS).
+     */
+    getPermissionStatus(): Promise<PushPermissionStatus>;
+    /**
+     * Request push notification permission from the user.
+     * Uses custom provider if set via setPermissionProvider(), otherwise uses
+     * built-in platform defaults (PermissionsAndroid on Android, auto-grant on iOS).
+     */
+    requestPermission(): Promise<PushPermissionStatus>;
+    /**
+     * Register for push notifications.
+     * Zero-parameter — token is acquired via setTokenProvider().
+     * Token is cached; network request only fires if token changes.
+     */
+    register(options?: {
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    /**
+     * Unregister the current device from push notifications.
+     * Called automatically on signOut.
+     */
+    unregister(deviceId?: string): Promise<void>;
+    /** Listen for push messages while app is in foreground. */
+    onMessage(callback: PushMessageHandler): () => void;
+    /** Listen for notification taps that opened the app. */
+    onMessageOpenedApp(callback: PushMessageHandler): () => void;
+    /**
+     * Dispatch a foreground message to all onMessage listeners.
+     * Call this from your native FCM/APNs foreground handler.
+     *
+     * @example (Firebase Messaging)
+     * messaging().onMessage(async (remoteMessage) => {
+     *   client.push._dispatchForegroundMessage({
+     *     title: remoteMessage.notification?.title,
+     *     body: remoteMessage.notification?.body,
+     *     data: remoteMessage.data,
+     *   });
+     * });
+     */
+    _dispatchForegroundMessage(message: PushMessage): void;
+    /**
+     * Dispatch an opened-app notification to all onMessageOpenedApp listeners.
+     * Call this from your notification tap handler.
+     */
+    _dispatchOpenedAppMessage(message: PushMessage): void;
+    /**
+     * Set topic subscription provider.
+     * Inject your Firebase RN SDK's topic subscription handlers.
+     *
+     * @example
+     * client.push.setTopicProvider({
+     *   subscribeTopic: (topic) => messaging().subscribeToTopic(topic),
+     *   unsubscribeTopic: (topic) => messaging().unsubscribeFromTopic(topic),
+     * });
+     */
+    setTopicProvider(provider: PushTopicProvider): void;
+    /**
+     * Subscribe to a push notification topic.
+     * Delegates to the topic provider set via setTopicProvider().
+     */
+    subscribeTopic(topic: string): Promise<void>;
+    /**
+     * Unsubscribe from a push notification topic.
+     * Delegates to the topic provider set via setTopicProvider().
+     */
+    unsubscribeTopic(topic: string): Promise<void>;
+    private _defaultGetPermissionStatus;
+    private _defaultRequestPermission;
+    private getOrCreateDeviceId;
+}
+
+/**
+ * AppState-based lifecycle management for React Native.
+ *
+ * Responsibility:
+ * - Foreground: check if access token is about to expire → pre-emptive refresh
+ * - Foreground: reconnect WebSocket if disconnected during background
+ * - Background: disconnect WebSocket to avoid battery drain and server-side timeout
+ *
+ * Usage:
+ *   const lifecycle = new LifecycleManager(tokenManager, databaseLive, AppState);
+ *   lifecycle.start();
+ *   // on unmount or destroy:
+ *   lifecycle.stop();
+ */
+
+interface AppStateAdapter {
+    currentState: string;
+    addEventListener(type: 'change', handler: (state: string) => void): {
+        remove: () => void;
+    };
+}
+interface DatabaseLiveClientAdapter {
+    disconnect(): void;
+    reconnect?(): void;
+}
+declare class LifecycleManager {
+    private tokenManager;
+    private databaseLive;
+    private appState;
+    /** Optional: function to trigger token refresh (e.g. doRefresh from HttpClient) */
+    private doRefresh?;
+    private subscription;
+    private previousState;
+    constructor(tokenManager: TokenManager, databaseLive: DatabaseLiveClientAdapter | null, appState: AppStateAdapter, 
+    /** Optional: function to trigger token refresh (e.g. doRefresh from HttpClient) */
+    doRefresh?: ((refreshToken: string) => Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }>) | undefined);
+    /** Start listening to AppState changes. */
+    start(): void;
+    /** Stop listening to AppState changes and clean up. */
+    stop(): void;
+    private handleStateChange;
+    private onForeground;
+    private onBackground;
+}
+interface UseLifecycleOptions {
+    tokenManager: TokenManager;
+    databaseLive: DatabaseLiveClientAdapter | null;
+    appState: AppStateAdapter;
+    doRefresh?: (refreshToken: string) => Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }>;
+}
+/**
+ * React hook that manages lifecycle automatically.
+ * Starts on mount, stops on unmount.
+ *
+ * @example
+ * function App() {
+ *   const { AppState } = require('react-native');
+ *   useLifecycle({ tokenManager: client._tokenManager, databaseLive: client._databaseLive, appState: AppState });
+ * }
+ */
+declare function useLifecycle({ tokenManager, databaseLive, appState, doRefresh, }: UseLifecycleOptions): void;
+
+type AnalyticsProperties = Record<string, string | number | boolean>;
+interface AnalyticsEvent {
+    name: string;
+    properties?: AnalyticsProperties;
+    timestamp?: number;
+}
+/**
+ * React Native analytics helper.
+ *
+ * Unlike the browser client, RN sends events immediately because there is no
+ * sendBeacon/page-unload behavior to coordinate against.
+ */
+declare class ClientAnalytics {
+    private core;
+    constructor(core: GeneratedDbApi);
+    track(name: string, properties?: AnalyticsProperties): Promise<void>;
+    trackBatch(events: AnalyticsEvent[]): Promise<void>;
+    flush(): Promise<void>;
+    destroy(): void;
+}
+
+/**
+ * @edge-base/react-native — Full-featured client.
+ * All APIs: auth, database-live, storage, push, room, captcha (turnstile), lifecycle
+ *
+ * @example
+ * import { createClient } from '@edge-base/react-native';
+ * import AsyncStorage from '@react-native-async-storage/async-storage';
+ * import { Linking, AppState } from 'react-native';
+ *
+ * const client = createClient('https://my-app.edgebase.fun', {
+ *   storage: AsyncStorage,
+ *   linking: Linking,
+ *   appState: AppState,
+ * });
+ */
+
+interface JuneClientOptions {
+    /**
+     * AsyncStorage adapter.
+     * Pass `require('@react-native-async-storage/async-storage').default`
+     */
+    storage: AsyncStorageAdapter;
+    /**
+     * Linking adapter — pass `require('react-native').Linking`
+     * Required for OAuth sign-in.
+     */
+    linking?: LinkingAdapter;
+    /**
+     * AppState adapter — pass `require('react-native').AppState`
+     * Enables auto lifecycle management:
+     *   background → WebSocket disconnect
+     *   foreground → reconnect + token refresh
+     */
+    appState?: AppStateAdapter;
+    /** Database live subscription options (auto-reconnect, delays, etc.) */
+    databaseLive?: DatabaseLiveOptions;
+    /** Schema from typegen */
+    schema?: Record<string, unknown>;
+}
+declare class ClientEdgeBase {
+    readonly auth: AuthClient;
+    readonly storage: StorageClient;
+    readonly push: PushClient;
+    readonly functions: FunctionsClient;
+    readonly analytics: ClientAnalytics;
+    private databaseLive;
+    /** @internal exposed for advanced use (e.g. setDatabaseLive, testing) */
+    readonly _tokenManager: TokenManager;
+    /** @internal */
+    readonly _httpClient: HttpClient;
+    private lifecycleManager;
+    private contextManager;
+    private baseUrl;
+    private core;
+    constructor(url: string, options: JuneClientOptions);
+    /**
+     * Select a DB block by namespace and optional instance ID (#133 §2).
+     *
+     * @example
+     * const posts = await client.db('shared').table('posts').where('status', '==', 'published').get();
+     * client.db('shared').table('posts').onSnapshot((change) => { ... });
+     */
+    db(namespace: string, instanceId?: string): DbRef;
+    /**
+     * Get a Room client for ephemeral stateful real-time sessions.
+     *
+     * @param namespace - The room namespace (e.g. 'game', 'chat')
+     * @param roomId - The room instance ID within the namespace
+     * @param options - Connection options
+     *
+     * @example
+     * const room = client.room('game', 'room-123');
+     * await room.join();
+     * const result = await room.send('SET_SCORE', { score: 42 });
+     */
+    room(namespace: string, roomId: string, options?: RoomOptions): RoomClient;
+    /** Set legacy isolateBy context state. HTTP DB routing uses db(namespace, id). */
+    setContext(context: ContextValue): void;
+    /** Set locale for auth email i18n and Accept-Language headers. */
+    setLocale(locale: string | undefined): void;
+    /** Get the currently configured locale override. */
+    getLocale(): string | undefined;
+    /** Get the currently configured legacy isolateBy context state. */
+    getContext(): ContextValue;
+    /** Clean up all connections and listeners. */
+    destroy(): void;
+}
+/** Create a React Native EdgeBase client. */
+declare function createClient(url: string, options: JuneClientOptions): ClientEdgeBase;
+
+/**
+ * Client-side filter matching for database-live subscriptions.
+ *
+ * React Native shares the same query/filter tuple semantics as the web SDK,
+ * so the matching logic stays identical across both clients.
+ */
+type FilterOperator = '==' | '!=' | '<' | '>' | '<=' | '>=' | 'contains' | 'contains-any' | 'in' | 'not in';
+interface FilterEntry {
+    field: string;
+    operator: FilterOperator;
+    value: unknown;
+}
+declare function matchesFilter(data: Record<string, unknown>, filters: Record<string, unknown> | [string, FilterOperator, unknown][]): boolean;
+
+/**
+ * Turnstile CAPTCHA widget for React Native — WebView based.
+ *
+ * Supports all platforms:
+ * - iOS: WKWebView via react-native-webview
+ * - Android: android.webkit.WebView via react-native-webview
+ *   (uses window.ReactNativeWebView.postMessage instead of window.postMessage)
+ * - Web (React Native Web): Falls back to direct script injection
+ *
+ * Usage:
+ *   <TurnstileWebView
+ *     siteKey="your-site-key"
+ *     action="signup"
+ *     onToken={(token) => handleToken(token)}
+ *     onError={(err) => handleError(err)}
+ *   />
+ *
+ * Or use the helper hook:
+ *   const { token, isLoading, error, reset } = useTurnstile({ baseUrl, action });
+ */
+
+interface StyleProp {
+    [key: string]: unknown;
+}
+interface WebViewMessage {
+    nativeEvent: {
+        data: string;
+    };
+}
+interface WebViewProps {
+    source: {
+        html: string;
+    };
+    style?: StyleProp;
+    onMessage: (event: WebViewMessage) => void;
+    testID?: string;
+    javaScriptEnabled?: boolean;
+    originWhitelist?: string[];
+    scrollEnabled?: boolean;
+    showsHorizontalScrollIndicator?: boolean;
+    showsVerticalScrollIndicator?: boolean;
+}
+type TurnstileAppearance = 'always' | 'execute' | 'interaction-only';
+type TurnstileSize = 'normal' | 'compact' | 'flexible';
+interface TurnstileWebViewProps {
+    siteKey: string;
+    action?: string;
+    /** Called when Turnstile successfully issues a token */
+    onToken: (token: string) => void;
+    /** Called when Turnstile fails or times out */
+    onError?: (error: string) => void;
+    /** Called when an interactive challenge appears (show the WebView) */
+    onInteractive?: () => void;
+    /** Turnstile appearance mode */
+    appearance?: TurnstileAppearance;
+    /** Turnstile widget size */
+    size?: TurnstileSize;
+    /** Test identifier forwarded to the underlying WebView shell */
+    testID?: string;
+    /** Style for the WebView container */
+    style?: StyleProp;
+    /** WebView component — inject from react-native-webview */
+    WebViewComponent: React.ComponentType<WebViewProps>;
+}
+declare function TurnstileWebView({ siteKey, action, onToken, onError, onInteractive, appearance, size, testID, style, WebViewComponent, }: TurnstileWebViewProps): React.ReactElement;
+interface UseTurnstileOptions {
+    baseUrl: string;
+    action?: string;
+    /** Inject WebView component — pass require('react-native-webview').WebView */
+    WebViewComponent?: React.ComponentType<WebViewProps>;
+}
+interface UseTurnstileResult {
+    /** Current captcha token (null until resolved) */
+    token: string | null;
+    /** True while waiting for Turnstile to issue a token */
+    isLoading: boolean;
+    /** Error message if Turnstile failed */
+    error: string | null;
+    /** True if interactive challenge is needed (show the WebView) */
+    needsInteraction: boolean;
+    /** The siteKey fetched from server (null if captcha not configured) */
+    siteKey: string | null;
+    /** Reset state — useful to retry after error */
+    reset: () => void;
+    /** Manually set the token (for manual override flow) */
+    setToken: (token: string) => void;
+    /** Pass to TurnstileWebView.onToken for stateful integration */
+    onToken: (token: string) => void;
+    /** Pass to TurnstileWebView.onError for stateful integration */
+    onError: (error: string) => void;
+    /** Pass to TurnstileWebView.onInteractive for stateful integration */
+    onInteractive: () => void;
+}
+declare function useTurnstile({ baseUrl, action, }: UseTurnstileOptions): UseTurnstileResult;
+/**
+ * Detect if we're running on React Native Web (browser) vs native.
+ * Used internally to skip WebView when running on web platform.
+ */
+declare function isPlatformWeb(): boolean;
+
+export { type AppStateAdapter, type AsyncStorageAdapter, AuthClient, type AuthResult, type AuthStateChangeHandler, ClientAnalytics, ClientEdgeBase, DatabaseLiveClient, type DatabaseLiveClientAdapter, type DatabaseLiveOptions, type FilterEntry, type FilterOperator, type JuneClientOptions, LifecycleManager, type LinkingAdapter, type PasskeysAuthOptions, PushClient, type PushMessage, type PushMessageHandler, type PushPermissionProvider, type PushPermissionStatus, type PushPlatform, type PushTokenProvider, RoomClient, type RoomConnectionState, type RoomMediaDeviceChange, type RoomMediaKind, type RoomMediaMember, type RoomMediaTrack, type RoomMember, type RoomMemberLeaveReason, type RoomMemberMediaKindState, type RoomMemberMediaState, type RoomOptions, type RoomReconnectInfo, type RoomSignalMeta, type Session, type SignInOptions, type SignUpOptions, type Subscription, TokenManager, type TokenPair, type TokenUser, TurnstileWebView, type TurnstileWebViewProps, type UpdateProfileOptions, type UseLifecycleOptions, type UseTurnstileOptions, type UseTurnstileResult, createClient, isPlatformWeb, matchesFilter, useLifecycle, useTurnstile };