@pickleball/expo-sdk 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,1436 @@
+import React, { ReactNode } from 'react';
+import { ViewStyle } from 'react-native';
+export { PICKLEBALL_EXPO_SDK_VERSION } from './version.js';
+
+type LivestreamState = "idle" | "preparing" | "preview" | "connecting"
+/** Đã vào phòng, chưa phát — chờ lệnh phát từ app hoặc dashboard. */
+ | "standby" | "live" | "reconnecting" | "ending" | "ended" | "error";
+type SdkErrorCode = "PERMISSION_DENIED" | "NETWORK_UNAVAILABLE" | "TOKEN_EXPIRED" | "SDK_UPGRADE_REQUIRED" | "SESSION_CONFLICT" | "RECORDING_FAILED" | "CONSENT_REQUIRED" | "SDK_DISABLED" | "UNKNOWN";
+interface SdkError {
+    code: SdkErrorCode;
+    message: string;
+}
+interface BootstrapInput {
+    sdkVersion: string;
+    platform: "ios" | "android";
+    bundleId: string;
+    installationId: string;
+}
+interface SdkRemoteConfig {
+    enabled: boolean;
+    protocolVersion: 1;
+    minSdkVersion: string;
+    recommendedSdkVersion: string;
+    videoQuality: 720 | 1080;
+    reconnectTimeoutMs: number;
+    backgroundGraceMs: number;
+    telemetryIntervalMs: number;
+    maxSessionDurationMs: number;
+    /** Tự kết thúc phiên nếu ngồi standby quá lâu không phát (mặc định 15 phút). */
+    standbyTimeoutMs?: number;
+}
+interface SdkBootstrap {
+    config: SdkRemoteConfig;
+    serverTime: number;
+    rolloutEnabled: boolean;
+    message?: string;
+}
+interface StartLivestreamInput {
+    externalSessionId: string;
+    title: string;
+    visibility?: "public" | "private";
+    consentVersion: string;
+    metadata?: Record<string, string>;
+    /**
+     * true: vào phòng ở chế độ chờ (không publish) — server giữ status
+     * "scheduled" và KHÔNG khởi động recording egress cho tới khi publish.
+     * Engine tự đặt cờ này theo options.autoPublish; app không cần truyền.
+     */
+    standby?: boolean;
+}
+interface SdkTelemetryCredentials {
+    endpoint: string;
+    token: string;
+    expiresAt: number;
+}
+interface SdkSessionGrant {
+    sessionId: string;
+    serverUrl: string;
+    participantToken: string;
+    playbackUrl: string | null;
+    tokenExpiresAt: number;
+    telemetry: SdkTelemetryCredentials;
+    config: SdkRemoteConfig;
+}
+interface SdkSessionRefresh {
+    participantToken?: string;
+    tokenExpiresAt?: number;
+    telemetry?: SdkTelemetryCredentials;
+    config: SdkRemoteConfig;
+}
+interface EndLivestreamInput {
+    sessionId: string;
+    reason: "user" | "background_timeout" | "network_timeout" | "standby_timeout" | "error";
+}
+type EndReason = EndLivestreamInput["reason"];
+declare const SDK_TELEMETRY_EVENT_NAMES: readonly ["state_changed", "connection_quality", "reconnect", "error", "heartbeat", "session_ended"];
+type SdkTelemetryEventName = (typeof SDK_TELEMETRY_EVENT_NAMES)[number];
+interface SdkTelemetryEvent {
+    sessionId: string;
+    at: number;
+    name: SdkTelemetryEventName;
+    data?: Record<string, unknown>;
+}
+interface LivestreamSessionProvider {
+    bootstrap(input: BootstrapInput): Promise<SdkBootstrap>;
+    start(input: StartLivestreamInput): Promise<SdkSessionGrant>;
+    refresh(sessionId: string): Promise<SdkSessionRefresh>;
+    end(input: EndLivestreamInput): Promise<void>;
+    /**
+     * Báo server bắt đầu phát thật (standby → live): server bật recording
+     * egress + chuyển status live TRƯỚC khi engine publish track. Optional để
+     * giữ tương thích provider cũ — thiếu thì engine bỏ qua bước server.
+     */
+    publish?(sessionId: string): Promise<void>;
+    /** Báo server tạm dừng phát (live → standby): dừng egress, status về chờ. */
+    unpublish?(sessionId: string): Promise<void>;
+}
+declare function isSdkRemoteConfig(value: unknown): value is SdkRemoteConfig;
+declare function compareSemver(left: string, right: string): -1 | 0 | 1;
+declare function isSdkVersionSupported(version: string, minimum: string): boolean;
+
+type MatchFormat = "singles" | "doubles";
+type MatchScoringMode = "rally" | "sideOut";
+type MatchTeamId = "A" | "B";
+type CourtSide = "left" | "right";
+type MatchInputSource = "local" | "remote" | "voice" | "ble" | "system";
+interface MatchPlayer {
+    readonly id: string;
+    readonly name: string;
+}
+interface MatchTeam {
+    readonly id: MatchTeamId;
+    readonly name?: string;
+    /** Defaults to the first player in the roster. */
+    readonly initialServerId?: string;
+    readonly players: readonly MatchPlayer[];
+}
+interface MatchCreateInput {
+    readonly id: string;
+    readonly format: MatchFormat;
+    readonly scoringMode: MatchScoringMode;
+    readonly targetScore?: number;
+    readonly initialServingTeam?: MatchTeamId;
+    readonly teams: Readonly<Record<MatchTeamId, MatchTeam>>;
+}
+interface TeamScore {
+    readonly A: number;
+    readonly B: number;
+}
+interface ServeState {
+    readonly teamId: MatchTeamId;
+    readonly playerId: string;
+    readonly serverNumber: 1 | 2;
+    readonly court: CourtSide;
+}
+interface GameSnapshot {
+    readonly number: 1 | 2 | 3;
+    readonly score: TeamScore;
+    readonly startingServingTeam: MatchTeamId;
+    readonly winner: MatchTeamId | null;
+    readonly midGameSwitchCompleted: boolean;
+}
+type PendingCourtSwitch = {
+    readonly reason: "gameEnd";
+    readonly game: 1 | 2;
+} | {
+    readonly reason: "gameThreeMidpoint";
+    readonly game: 3;
+};
+interface MatchSnapshot {
+    readonly id: string;
+    readonly format: MatchFormat;
+    readonly scoringMode: MatchScoringMode;
+    readonly targetScore: number;
+    readonly bestOf: 3;
+    readonly teams: Readonly<Record<MatchTeamId, MatchTeam>>;
+    readonly designatedServerByTeam: Readonly<Record<MatchTeamId, string>>;
+    readonly initialServingTeam: MatchTeamId;
+    readonly courtSides: Readonly<Record<CourtSide, MatchTeamId>>;
+    readonly playerCourts: Readonly<Record<string, CourtSide>>;
+    readonly games: readonly GameSnapshot[];
+    readonly currentGame: 1 | 2 | 3;
+    readonly gamesWon: TeamScore;
+    readonly serve: ServeState;
+    readonly pendingCourtSwitch: PendingCourtSwitch | null;
+    readonly status: "inProgress" | "completed" | "ended";
+    readonly winner: MatchTeamId | null;
+    readonly endReason: string | null;
+    readonly sequence: number;
+}
+interface MatchCorrection {
+    readonly score?: Partial<TeamScore>;
+    readonly serve?: ServeState;
+    readonly playerCourts?: Readonly<Record<string, CourtSide>>;
+}
+interface MatchEventBase {
+    readonly schemaVersion: 1;
+    readonly id: string;
+    readonly sequence: number;
+    readonly source: MatchInputSource;
+}
+interface MatchCreatedEvent extends MatchEventBase {
+    readonly type: "matchCreated";
+    readonly input: MatchCreateInput;
+    readonly snapshot: MatchSnapshot;
+}
+interface RallyAwardedEvent extends MatchEventBase {
+    readonly type: "rallyAwarded";
+    readonly displaySide: CourtSide;
+    readonly winnerTeamId: MatchTeamId;
+}
+interface CourtSwitchConfirmedEvent extends MatchEventBase {
+    readonly type: "courtSwitchConfirmed";
+    readonly pending: PendingCourtSwitch;
+}
+interface MatchCorrectedEvent extends MatchEventBase {
+    readonly type: "matchCorrected";
+    readonly correction: MatchCorrection;
+}
+interface MatchEndedEvent extends MatchEventBase {
+    readonly type: "matchEnded";
+    readonly reason: string;
+}
+interface MatchEventUndoneEvent extends MatchEventBase {
+    readonly type: "matchEventUndone";
+    readonly targetEventId: string;
+    readonly restoredSnapshot: MatchSnapshot;
+}
+type MatchEvent = MatchCreatedEvent | RallyAwardedEvent | CourtSwitchConfirmedEvent | MatchCorrectedEvent | MatchEndedEvent | MatchEventUndoneEvent;
+interface MatchCreation {
+    readonly snapshot: MatchSnapshot;
+    readonly events: readonly [MatchCreatedEvent];
+}
+
+declare function createMatch(input: MatchCreateInput, source?: MatchInputSource): MatchCreation;
+declare function applyMatchEvent(snapshot: MatchSnapshot, event: MatchEvent): MatchSnapshot;
+declare function awardRally(snapshot: MatchSnapshot, displaySide: CourtSide, source?: MatchInputSource): RallyAwardedEvent | null;
+declare function confirmCourtSwitch(snapshot: MatchSnapshot, source?: MatchInputSource): CourtSwitchConfirmedEvent;
+declare function correctMatch(snapshot: MatchSnapshot, correction: MatchCorrection, source?: MatchInputSource): MatchCorrectedEvent;
+declare function endMatch(snapshot: MatchSnapshot, reason: string, source?: MatchInputSource): MatchEndedEvent;
+
+declare function replayMatchEvents(events: readonly unknown[]): MatchSnapshot;
+declare function undoLastMatchEvent(events: readonly MatchEvent[], source?: MatchInputSource): MatchEventUndoneEvent | null;
+
+declare const BTHOME_SERVICE_UUID: "FCD2";
+type RemoteButtonAction = "single" | "double" | "long";
+type RemoteInputMode = "bthome" | "hidVolume" | "both";
+type RemoteMappedAction = "left" | "right" | "undo" | "none";
+interface RemoteActionMapping {
+    readonly volumeUp: RemoteMappedAction;
+    readonly volumeDown: RemoteMappedAction;
+    readonly longPress: RemoteMappedAction;
+}
+declare const DEFAULT_REMOTE_ACTION_MAPPING: RemoteActionMapping;
+interface RemoteHidVolumeEvent {
+    readonly source: "hidVolume";
+    readonly direction: "volumeUp" | "volumeDown";
+    readonly repeat: boolean;
+    readonly longPress: boolean;
+    readonly timestamp: number;
+}
+type RemoteHidGesture = "single" | "double" | "hold";
+interface RemoteHidGestureMapping {
+    /** Raw HID direction emitted by the calibrated remote button. */
+    readonly direction: RemoteHidVolumeEvent["direction"];
+    /** Quiet window used to close one physical gesture burst. */
+    readonly settleMs: number;
+    /** Repeated volume changes required to classify a hold before the burst ends. */
+    readonly holdEventCount: number;
+    readonly single: RemoteMappedAction;
+    readonly double: RemoteMappedAction;
+    readonly hold: RemoteMappedAction;
+}
+interface RemoteBinding {
+    /** Stable identifier supplied by CoreBluetooth or BluetoothLeScanner. */
+    readonly deviceId: string;
+    readonly label?: string;
+}
+type RemotePermissionStatus = "unknown" | "granted" | "denied" | "restricted" | "unavailable";
+type RemoteStatus = "unavailable" | "poweredOff" | "idle" | "scanning" | "bound" | "outOfRange";
+interface RemoteCandidate {
+    readonly deviceId: string;
+    readonly label?: string;
+    readonly rssi: number;
+    readonly lastSeenAt: number;
+}
+interface RemoteState {
+    readonly status: RemoteStatus;
+    readonly permission: RemotePermissionStatus;
+    readonly binding: RemoteBinding | null;
+    readonly candidate: RemoteCandidate | null;
+    readonly lastSeenAt: number | null;
+    readonly error: RemoteError | null;
+    readonly hidCaptureArmed: boolean;
+    readonly lastInputSource: "bthome" | "hidVolume" | null;
+    readonly lastHidEvent: RemoteHidVolumeEvent | null;
+}
+type RemoteErrorCode = "permission_denied" | "permission_restricted" | "bluetooth_unavailable" | "bluetooth_powered_off" | "scan_failed" | "native_unavailable";
+declare class RemoteError extends Error {
+    readonly code: RemoteErrorCode;
+    readonly name = "RemoteError";
+    constructor(code: RemoteErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+interface RemoteScanAdvertisement {
+    readonly deviceId: string;
+    readonly name?: string;
+    readonly rssi: number;
+    readonly serviceUuid: string;
+    /** Base64 encoded FCD2 service-data payload, beginning with the device-info byte. */
+    readonly serviceData: string;
+    readonly timestamp: number;
+}
+type RemoteNativeState = {
+    readonly status: "permission";
+    readonly permission: RemotePermissionStatus;
+} | {
+    readonly status: "poweredOff" | "unavailable" | "scanning" | "idle";
+} | {
+    readonly status: "error";
+    readonly code: string;
+    readonly message: string;
+};
+interface RemoteService {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    dispose(): Promise<void>;
+    subscribeAdvertisement(listener: (event: RemoteScanAdvertisement) => void): () => void;
+    subscribeState(listener: (event: RemoteNativeState) => void): () => void;
+    startHidCapture(options?: {
+        consume?: boolean;
+    }): Promise<void>;
+    stopHidCapture(): Promise<void>;
+    subscribeHidVolume(listener: (event: RemoteHidVolumeEvent) => void): () => void;
+}
+
+declare const MATCH_PERSISTENCE_SCHEMA_VERSION: 1;
+interface StoredMatchRow {
+    readonly matchId: string;
+    readonly schemaVersion: number;
+    readonly snapshotJson: string;
+    readonly snapshotSequence: number;
+    readonly status: MatchSnapshot["status"];
+    readonly updatedAt: number;
+}
+interface StoredMatchEventRow {
+    readonly matchId: string;
+    readonly sequence: number;
+    readonly eventId: string;
+    readonly schemaVersion: number;
+    readonly eventJson: string;
+    readonly createdAt: number;
+}
+interface MatchPersistenceTransaction {
+    getMatch(matchId: string): Promise<StoredMatchRow | null>;
+    getEvents(matchId: string): Promise<readonly StoredMatchEventRow[]>;
+    insertMatch(row: StoredMatchRow): Promise<void>;
+    insertEvent(row: StoredMatchEventRow): Promise<void>;
+    updateSnapshot(matchId: string, expectedSequence: number, row: Pick<StoredMatchRow, "schemaVersion" | "snapshotJson" | "snapshotSequence" | "status" | "updatedAt">): Promise<boolean>;
+    setActiveMatch(matchId: string | null): Promise<void>;
+    clearActiveMatch(matchId: string): Promise<void>;
+}
+interface MatchPersistenceDriver {
+    migrate(): Promise<void>;
+    transaction<T>(work: (transaction: MatchPersistenceTransaction) => Promise<T>): Promise<T>;
+    readMatch(matchId: string): Promise<{
+        readonly match: StoredMatchRow | null;
+        readonly events: readonly StoredMatchEventRow[];
+    }>;
+    getActiveMatchId(): Promise<string | null>;
+    readActiveMatch(): Promise<{
+        readonly activeMatchId: string | null;
+        readonly match: StoredMatchRow | null;
+        readonly events: readonly StoredMatchEventRow[];
+    }>;
+    readMatchList(): Promise<{
+        readonly matches: readonly StoredMatchRow[];
+        readonly activeMatchId: string | null;
+    }>;
+    getRemoteBinding?(): Promise<RemoteBinding | null>;
+    setRemoteBinding?(binding: RemoteBinding | null): Promise<void>;
+}
+interface PersistedMatch {
+    readonly snapshot: MatchSnapshot;
+    readonly events: readonly MatchEvent[];
+}
+interface MatchSummary {
+    readonly id: string;
+    readonly sequence: number;
+    readonly status: MatchSnapshot["status"];
+    readonly updatedAt: number;
+    readonly isActive: boolean;
+}
+type MatchPersistenceErrorCode = "not_found" | "already_exists" | "conflict" | "corrupt_data" | "unsupported_schema" | "sequence_mismatch" | "snapshot_mismatch" | "storage_failure";
+declare class MatchPersistenceError extends Error {
+    readonly code: MatchPersistenceErrorCode;
+    readonly name = "MatchPersistenceError";
+    readonly recoverable = true;
+    readonly retryable: boolean;
+    constructor(code: MatchPersistenceErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+
+declare const MATCH_SQL_SCHEMA_VERSION: 2;
+declare const MATCH_SQL_MIGRATIONS: readonly ["CREATE TABLE IF NOT EXISTS match_aggregates (\n    match_id TEXT PRIMARY KEY NOT NULL,\n    schema_version INTEGER NOT NULL CHECK (schema_version = 1),\n    snapshot_json TEXT NOT NULL,\n    snapshot_sequence INTEGER NOT NULL CHECK (snapshot_sequence >= 0),\n    status TEXT NOT NULL CHECK (status IN ('inProgress', 'completed', 'ended')),\n    updated_at INTEGER NOT NULL\n  )", "CREATE TABLE IF NOT EXISTS match_events (\n    match_id TEXT NOT NULL,\n    sequence INTEGER NOT NULL CHECK (sequence >= 0),\n    event_id TEXT NOT NULL UNIQUE,\n    schema_version INTEGER NOT NULL CHECK (schema_version = 1),\n    event_json TEXT NOT NULL,\n    created_at INTEGER NOT NULL,\n    PRIMARY KEY (match_id, sequence),\n    FOREIGN KEY (match_id) REFERENCES match_aggregates(match_id) ON DELETE RESTRICT\n  )", "CREATE TABLE IF NOT EXISTS match_active_pointer (\n    slot INTEGER PRIMARY KEY NOT NULL CHECK (slot = 1),\n    match_id TEXT NOT NULL UNIQUE,\n    FOREIGN KEY (match_id) REFERENCES match_aggregates(match_id) ON DELETE RESTRICT\n  )", "CREATE INDEX IF NOT EXISTS match_aggregates_recent\n    ON match_aggregates(updated_at DESC)", "CREATE TRIGGER IF NOT EXISTS match_events_no_update\n    BEFORE UPDATE ON match_events\n    BEGIN SELECT RAISE(ABORT, 'match events are immutable'); END", "CREATE TRIGGER IF NOT EXISTS match_events_no_delete\n    BEFORE DELETE ON match_events\n    BEGIN SELECT RAISE(ABORT, 'match events are immutable'); END", "CREATE TABLE IF NOT EXISTS remote_binding (\n    slot INTEGER PRIMARY KEY NOT NULL CHECK (slot = 1),\n    device_id TEXT NOT NULL CHECK (length(trim(device_id)) > 0),\n    label TEXT\n  )"];
+
+interface MemoryState {
+    migrationVersion: number;
+    remoteBinding: RemoteBinding | null;
+    activeMatchId: string | null;
+    matches: StoredMatchRow[];
+    events: StoredMatchEventRow[];
+    nextOrdinal: number;
+    ordinals: Record<string, number>;
+}
+declare class MemoryMatchPersistenceDriver implements MatchPersistenceDriver {
+    private state;
+    private eventInsertFailure;
+    private snapshotUpdateFailure;
+    private transactionTail;
+    migrate(): Promise<void>;
+    getRemoteBinding(): Promise<{
+        deviceId: string;
+        label?: string;
+    } | null>;
+    setRemoteBinding(binding: RemoteBinding | null): Promise<void>;
+    getMigrationVersion(): number;
+    transaction<T>(work: (transaction: MatchPersistenceTransaction) => Promise<T>): Promise<T>;
+    readMatch(matchId: string): Promise<{
+        match: StoredMatchRow | null;
+        events: StoredMatchEventRow[];
+    }>;
+    getActiveMatchId(): Promise<string | null>;
+    readActiveMatch(): Promise<{
+        activeMatchId: null;
+        match: null;
+        events: never[];
+    } | {
+        activeMatchId: string;
+        match: StoredMatchRow | null;
+        events: StoredMatchEventRow[];
+    }>;
+    readMatchList(): Promise<{
+        matches: StoredMatchRow[];
+        activeMatchId: string | null;
+    }>;
+    inspect(): MemoryState;
+    failNextSnapshotUpdate(error: Error): void;
+    failNextEventInsert(error: Error): void;
+    corruptSnapshotJson(matchId: string, snapshotJson: string): void;
+    corruptEventJson(matchId: string, sequence: number, eventJson: string): void;
+    corruptEventSchema(matchId: string, sequence: number, schemaVersion: number): void;
+    corruptEventSequence(matchId: string, sequence: number): void;
+    duplicateEventRow(matchId: string, sequence: number): void;
+    removeEventRow(matchId: string, sequence: number): void;
+    private mutateMatch;
+    private mutateEvent;
+}
+
+interface SqlRunResult {
+    readonly changes: number;
+    readonly lastInsertRowId: number;
+}
+interface SqlExecutor {
+    runAsync(sql: string, ...params: unknown[]): Promise<SqlRunResult>;
+    getFirstAsync<T>(sql: string, ...params: unknown[]): Promise<T | null>;
+    getAllAsync<T>(sql: string, ...params: unknown[]): Promise<T[]>;
+}
+interface ExpoSqliteDatabaseLike extends SqlExecutor {
+    execAsync(sql: string): Promise<void>;
+}
+/**
+ * Serializes adapters sharing this exact connection object. Separate
+ * connections to the same file rely on SQLite locking plus busy_timeout.
+ */
+declare function createExpoSqliteMatchDriver(database: ExpoSqliteDatabaseLike): MatchPersistenceDriver;
+
+interface MatchEventStoreOptions {
+    readonly now?: () => number;
+}
+declare class MatchEventStore {
+    private readonly driver;
+    private initialized;
+    private readonly now;
+    constructor(driver: MatchPersistenceDriver, options?: MatchEventStoreOptions);
+    initialize(): Promise<void>;
+    getRemoteBinding(): Promise<RemoteBinding | null>;
+    setRemoteBinding(binding: RemoteBinding | null): Promise<void>;
+    createMatch(input: MatchCreateInput, source?: MatchInputSource): Promise<PersistedMatch>;
+    appendEvent(currentSnapshot: MatchSnapshot, event: MatchEvent): Promise<PersistedMatch>;
+    resumeActiveMatch(): Promise<PersistedMatch | null>;
+    resumeMatch(matchId: string): Promise<PersistedMatch | null>;
+    listMatches(): Promise<readonly MatchSummary[]>;
+    archiveMatch(matchId: string): Promise<void>;
+}
+
+declare function createDefaultMatchEventStore(_databaseName?: string): Promise<MatchEventStore>;
+
+type AnnouncementKind = "score" | "serviceChange" | "gamePoint" | "gameWon" | "courtSwitch" | "matchWon";
+type FallbackVoiceToken = `number-${number}` | "number-mot" | "number-lam" | `score-deu-${number}` | "score-deu-mot" | "score-deu-lam" | "server-1" | "server-2" | "court-left" | "court-right" | "service-change" | "game-point" | "game-won" | "court-switch" | "match-won" | "test-speaker";
+interface AnnouncementPlan {
+    readonly kind: AnnouncementKind;
+    readonly text: string;
+    readonly score?: readonly [number, number];
+    readonly fallbackTokens: readonly FallbackVoiceToken[];
+}
+type VoiceAudioRoute = "system" | "bluetoothA2DP" | "bluetoothHFP" | "speaker" | "headphones" | "unknown";
+type VoiceDisconnectReason = "oldDeviceUnavailable" | "becomingNoisy" | "unknown";
+interface VoiceRouteState {
+    readonly route: VoiceAudioRoute;
+    readonly interrupted: boolean;
+    readonly disconnectedReason: VoiceDisconnectReason | null;
+}
+type VoiceAudioMode = "offline" | "live";
+interface AudioPlayback {
+    configure(mode: VoiceAudioMode): Promise<void>;
+    play(source: string): Promise<void>;
+    stop(): Promise<void>;
+    dispose(): Promise<void>;
+    getRouteState(): VoiceRouteState;
+    subscribeToRouteChanges?(listener: (state: VoiceRouteState) => void): () => void;
+}
+type NeuralVoiceAvailability = "available" | "unavailable";
+interface NeuralVoiceEngine {
+    availability(): Promise<NeuralVoiceAvailability>;
+    prewarm(commonPhrases: readonly string[]): Promise<void>;
+    synthesize(text: string, signal: AbortSignal): Promise<string>;
+    cancel(): Promise<void>;
+    release?(filePath: string): Promise<void>;
+    dispose(): Promise<void>;
+}
+/** Cloud TTS endpoint the SDK posts announcement text to (see apps/proxy /voice/tts). */
+interface VoiceTtsOptions {
+    readonly url: string;
+    /** Extra request headers, e.g. partner bearer tokens. Re-evaluated per request. */
+    readonly headers?: () => Readonly<Record<string, string>> | Promise<Readonly<Record<string, string>>>;
+    readonly voiceName?: string;
+    readonly languageCode?: string;
+    readonly requestTimeoutMs?: number;
+}
+type VoiceErrorCode = "engine_unavailable" | "network_unavailable" | "synthesis_failed" | "storage_failure" | "playback_failed";
+declare class VoiceError extends Error {
+    readonly code: VoiceErrorCode;
+    readonly name = "VoiceError";
+    constructor(code: VoiceErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+interface MatchVoiceService {
+    readonly audioState: VoiceRouteState;
+    readonly lastError?: Error | null;
+    initialize(): Promise<void>;
+    subscribe(listener: () => void): () => void;
+    announce(previous: MatchSnapshot, current: MatchSnapshot, event: MatchEvent): void;
+    replayAnnouncement(): Promise<void>;
+    testSpeaker(): Promise<void>;
+    configureAudioMode?(mode: VoiceAudioMode): Promise<void>;
+    dispose(): Promise<void>;
+}
+
+interface PickleballMatchStore {
+    initialize(): Promise<void>;
+    createMatch(input: MatchCreateInput, source?: MatchInputSource): Promise<PersistedMatch>;
+    appendEvent(currentSnapshot: MatchSnapshot, event: MatchEvent): Promise<PersistedMatch>;
+    resumeMatch(matchId: string): Promise<PersistedMatch | null>;
+    resumeActiveMatch(): Promise<PersistedMatch | null>;
+    listMatches(): Promise<readonly MatchSummary[]>;
+    archiveMatch(matchId: string): Promise<void>;
+    getRemoteBinding?(): Promise<RemoteBinding | null>;
+    setRemoteBinding?(binding: RemoteBinding | null): Promise<void>;
+}
+declare class NoActiveMatchError extends Error {
+    readonly name = "NoActiveMatchError";
+    readonly code = "NO_ACTIVE_MATCH";
+    constructor();
+}
+/**
+ * State-changing actions reject with NoActiveMatchError when no match is loaded.
+ * Commands the engine deems ineligible are ignored and resolve the current snapshot.
+ */
+interface PickleballMatchContextValue {
+    readonly snapshot: MatchSnapshot | null;
+    readonly events: readonly MatchEvent[];
+    readonly loading: boolean;
+    readonly error: Error | null;
+    readonly voiceError: Error | null;
+    readonly audioState: VoiceRouteState;
+    readonly remoteState: RemoteState;
+    createMatch(input: MatchCreateInput, source?: MatchInputSource): Promise<MatchSnapshot>;
+    resumeMatch(matchId?: string): Promise<MatchSnapshot | null>;
+    awardRallyToSide(side: CourtSide, source?: MatchInputSource): Promise<MatchSnapshot>;
+    undo(source?: MatchInputSource): Promise<MatchSnapshot>;
+    correctState(correction: MatchCorrection, source?: MatchInputSource): Promise<MatchSnapshot>;
+    confirmCourtSwitch(source?: MatchInputSource): Promise<MatchSnapshot>;
+    endMatch(reason: string, source?: MatchInputSource): Promise<MatchSnapshot>;
+    testSpeaker(): Promise<void>;
+    replayAnnouncement(): Promise<void>;
+    setVoiceAudioMode(mode: VoiceAudioMode): Promise<void>;
+    bindRemote(binding: RemoteBinding): Promise<void>;
+    unbindRemote(): Promise<void>;
+    startRemoteScan(): Promise<void>;
+    stopRemoteScan(): Promise<void>;
+    startHidCapture(): Promise<void>;
+    stopHidCapture(): Promise<void>;
+}
+interface PickleballMatchProviderProps {
+    readonly children?: ReactNode;
+    /** Fixed for this provider instance. Remount to use a different local store. */
+    readonly store?: PickleballMatchStore;
+    /** Fixed for this provider instance. Remount to use a different factory. */
+    readonly storeFactory?: () => Promise<PickleballMatchStore>;
+    /** Resumes the active local match on mount. Disable for hosts that resume explicitly. */
+    readonly autoResume?: boolean;
+    readonly onError?: (error: Error) => void | Promise<void>;
+    /** Fixed for this provider instance. Primarily useful for custom storage and tests. */
+    readonly voiceService?: MatchVoiceService;
+    /** Initial audio session mode. Defaults to live so mounting never disables capture. */
+    readonly voiceAudioMode?: VoiceAudioMode;
+    /** Cloud TTS endpoint for announcements. Without it only bundled WAVs play. Fixed for this provider instance. */
+    readonly voiceTts?: VoiceTtsOptions;
+    /** Fixed for this provider instance. Primarily useful for tests and custom native bridges. */
+    readonly remoteService?: RemoteService;
+    /** Foreground silence before a bound remote becomes outOfRange. */
+    readonly remoteOutOfRangeTimeoutMs?: number;
+    readonly remoteInputMode?: RemoteInputMode;
+    readonly remoteActionMapping?: Partial<RemoteActionMapping>;
+    /** Optional single/double/hold recognizer for one calibrated HID volume button. */
+    readonly hidGestureMapping?: RemoteHidGestureMapping;
+    readonly consumeHidVolumeKeys?: boolean;
+}
+declare function PickleballMatchProvider({ children, store, storeFactory, autoResume, onError, voiceService, voiceAudioMode, voiceTts, remoteService, remoteOutOfRangeTimeoutMs, remoteInputMode, remoteActionMapping, hidGestureMapping, consumeHidVolumeKeys, }: PickleballMatchProviderProps): React.JSX.Element;
+declare function usePickleballMatch(): PickleballMatchContextValue;
+
+type BTHomeRemoteParseErrorCode = "wrong_uuid" | "unsupported_version" | "encrypted" | "truncated" | "unknown_object" | "invalid_button_event" | "no_button";
+declare class BTHomeRemoteParseError extends Error {
+    readonly code: BTHomeRemoteParseErrorCode;
+    readonly name = "BTHomeRemoteParseError";
+    constructor(code: BTHomeRemoteParseErrorCode, message: string);
+}
+interface BTHomeAdvertisementInput {
+    readonly deviceId: string;
+    readonly serviceUuid: string;
+    /** FCD2 service data only. The first byte must be BTHome device-info, not UUID bytes. */
+    readonly serviceData: Uint8Array;
+}
+interface ParsedBTHomeRemoteAdvertisement {
+    readonly deviceId: string;
+    readonly version: 2;
+    readonly encrypted: false;
+    readonly triggerBased: boolean;
+    readonly packetId?: number;
+    readonly button: {
+        readonly action: RemoteButtonAction;
+        readonly objectIndex: number;
+        readonly rawEvent: number;
+    };
+    readonly fingerprint: string;
+}
+declare function parseBTHomeV2Advertisement(input: BTHomeAdvertisementInput): ParsedBTHomeRemoteAdvertisement;
+
+interface RemoteDeduplicationKey {
+    readonly packetId?: number;
+    readonly fingerprint: string;
+}
+interface BTHomeRemoteDeduplicatorOptions {
+    readonly fingerprintWindowMs?: number;
+}
+declare class BTHomeRemoteDeduplicator {
+    private readonly devices;
+    private readonly fingerprintWindowMs;
+    constructor(options?: BTHomeRemoteDeduplicatorOptions);
+    get trackedDeviceCount(): number;
+    accept(deviceId: string, key: RemoteDeduplicationKey, now?: number): boolean;
+    forget(deviceId: string): void;
+    clear(): void;
+}
+
+declare function decodeBase64Bytes(value: string): Uint8Array;
+
+interface HidVolumeGestureRecognizerOptions extends Pick<RemoteHidGestureMapping, "direction" | "settleMs" | "holdEventCount"> {
+    readonly onGesture: (gesture: RemoteHidGesture) => void;
+}
+declare class HidVolumeGestureRecognizer {
+    private readonly options;
+    private count;
+    private resolved;
+    private lastTimestamp;
+    private timer;
+    constructor(options: HidVolumeGestureRecognizerOptions);
+    push(event: RemoteHidVolumeEvent): void;
+    dispose(): void;
+    private finishBurst;
+    private clearTimer;
+    private reset;
+}
+
+/** Pure phrase selection from the state before and after one committed event. */
+declare function buildVietnameseAnnouncement(previous: MatchSnapshot, current: MatchSnapshot, event: MatchEvent): AnnouncementPlan;
+declare function planBundledFallback(plan: AnnouncementPlan): readonly string[];
+
+interface LatestAnnouncementSchedulerOptions {
+    readonly engine: NeuralVoiceEngine;
+    readonly audio: AudioPlayback;
+    readonly onError?: (error: Error) => void;
+}
+declare class LatestAnnouncementScheduler {
+    private readonly options;
+    private static readonly MAX_CACHE_ENTRIES;
+    private generation;
+    private activeController;
+    private lastPlan;
+    private readonly neuralCache;
+    private readonly operations;
+    private readonly prewarmControllers;
+    private lifecycle;
+    private disposePromise;
+    constructor(options: LatestAnnouncementSchedulerOptions);
+    prewarm(commonPhrases?: readonly string[]): Promise<void>;
+    enqueue(plan: AnnouncementPlan): Promise<void>;
+    private performEnqueue;
+    replayLast(): Promise<void>;
+    testSpeaker(): Promise<void>;
+    private performSpeakerTest;
+    dispose(): Promise<void>;
+    clearCache(): Promise<void>;
+    private cacheFile;
+    private touchCachedFile;
+    private track;
+    private report;
+}
+
+interface ExpoAudioPlayer {
+    play(): void;
+    pause(): void;
+    remove(): void;
+    addListener(event: "playbackStatusUpdate", listener: (status: {
+        readonly didJustFinish?: boolean;
+        readonly isLoaded?: boolean;
+        readonly isBuffering?: boolean;
+        readonly error?: unknown;
+        readonly playbackState?: string;
+    }) => void): {
+        remove(): void;
+    };
+}
+interface ExpoAudioBindings {
+    setAudioModeAsync(options: {
+        readonly allowsRecording: boolean;
+        readonly playsInSilentMode: boolean;
+    }): Promise<void>;
+    createAudioPlayer(source: unknown): ExpoAudioPlayer;
+}
+interface ExpoAudioPlaybackOptions {
+    readonly load?: () => ExpoAudioBindings;
+    readonly loadNativeAudio?: () => NativeAudioSessionBindings;
+    readonly resolveSource?: (source: string) => unknown;
+    readonly playbackTimeoutMs?: number;
+}
+interface NativeAudioSessionBindings {
+    captureAudioSessionState(): Promise<void>;
+    configureAudioSession(mode: VoiceAudioMode): Promise<VoiceRouteState>;
+    getAudioRouteState(): VoiceRouteState | Promise<VoiceRouteState>;
+    addListener(event: "onAudioRouteChanged", listener: (state: VoiceRouteState) => void): {
+        remove(): void;
+    };
+    disposeAudioSession(): Promise<void>;
+}
+declare function createExpoAudioPlayback(options?: ExpoAudioPlaybackOptions): AudioPlayback;
+
+/** Minimal file operations the engine needs; defaults to expo-file-system. */
+interface GeneratedAudioFileSystem {
+    writeFile(path: string, bytes: Uint8Array): Promise<void>;
+    removeFile(path: string): Promise<void>;
+}
+interface GeminiVoiceEngineOptions extends VoiceTtsOptions {
+    /** Directory that receives generated WAV files. */
+    readonly generatedRoot: string;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly fileSystem?: GeneratedAudioFileSystem;
+}
+/**
+ * Cloud announcement voice: posts the phrase to the partner proxy, which calls
+ * Vertex AI Gemini TTS and returns a WAV body. Failures surface as VoiceError
+ * so the scheduler drops to the bundled WAV fallback.
+ */
+declare function createGeminiVoiceEngine(options: GeminiVoiceEngineOptions): NeuralVoiceEngine;
+/** Placeholder engine used when no TTS endpoint is configured: always falls back. */
+declare function createUnavailableVoiceEngine(): NeuralVoiceEngine;
+
+declare function resolveBundledVoiceAsset(source: string): string;
+
+interface DefaultMatchVoiceServiceOptions {
+    /** Cloud TTS endpoint. Without it, announcements always use the bundled WAVs. */
+    readonly tts?: VoiceTtsOptions;
+    readonly audioMode?: VoiceAudioMode;
+    /** Exact cache directory for generated WAVs. Primarily useful for tests. */
+    readonly generatedRoot?: string;
+    /** Primarily useful for tests. Defaults to expo-file-system removal. */
+    readonly removeGeneratedDirectory?: (path: string) => Promise<void>;
+    /** Primarily useful for native integration tests. */
+    readonly audio?: AudioPlayback;
+    /** Primarily useful for native integration tests. */
+    readonly engine?: NeuralVoiceEngine;
+}
+declare function createDefaultMatchVoiceService(options?: DefaultMatchVoiceServiceOptions): MatchVoiceService;
+
+type ExpoSdkErrorCode = SdkErrorCode | "CONFIGURATION_ERROR" | "UNSUPPORTED_RUNTIME" | "INVALID_RESPONSE" | "TIMEOUT";
+declare class PickleballExpoError extends Error {
+    readonly code: ExpoSdkErrorCode;
+    constructor(message: string, code: ExpoSdkErrorCode, options?: ErrorOptions);
+}
+declare const PermissionDeniedError_base: {
+    new (message?: string, options?: ErrorOptions): {
+        readonly code: ExpoSdkErrorCode;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class PermissionDeniedError extends PermissionDeniedError_base {
+}
+declare const NetworkUnavailableError_base: {
+    new (message?: string, options?: ErrorOptions): {
+        readonly code: ExpoSdkErrorCode;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class NetworkUnavailableError extends NetworkUnavailableError_base {
+}
+declare const TokenExpiredError_base: {
+    new (message?: string, options?: ErrorOptions): {
+        readonly code: ExpoSdkErrorCode;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class TokenExpiredError extends TokenExpiredError_base {
+}
+declare const UnsupportedSdkError_base: {
+    new (message?: string, options?: ErrorOptions): {
+        readonly code: ExpoSdkErrorCode;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class UnsupportedSdkError extends UnsupportedSdkError_base {
+}
+declare const UnsupportedRuntimeError_base: {
+    new (message?: string, options?: ErrorOptions): {
+        readonly code: ExpoSdkErrorCode;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class UnsupportedRuntimeError extends UnsupportedRuntimeError_base {
+}
+declare const SessionConflictError_base: {
+    new (message?: string, options?: ErrorOptions): {
+        readonly code: ExpoSdkErrorCode;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class SessionConflictError extends SessionConflictError_base {
+}
+declare const RecordingFailureError_base: {
+    new (message?: string, options?: ErrorOptions): {
+        readonly code: ExpoSdkErrorCode;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class RecordingFailureError extends RecordingFailureError_base {
+}
+declare const ConsentRequiredError_base: {
+    new (message?: string, options?: ErrorOptions): {
+        readonly code: ExpoSdkErrorCode;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class ConsentRequiredError extends ConsentRequiredError_base {
+}
+declare const SdkDisabledError_base: {
+    new (message?: string, options?: ErrorOptions): {
+        readonly code: ExpoSdkErrorCode;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class SdkDisabledError extends SdkDisabledError_base {
+}
+declare const ExpoSdkConfigurationError_base: {
+    new (message?: string, options?: ErrorOptions): {
+        readonly code: ExpoSdkErrorCode;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class ExpoSdkConfigurationError extends ExpoSdkConfigurationError_base {
+}
+declare const InvalidResponseError_base: {
+    new (message?: string, options?: ErrorOptions): {
+        readonly code: ExpoSdkErrorCode;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class InvalidResponseError extends InvalidResponseError_base {
+}
+declare const ExpoSdkTimeoutError_base: {
+    new (message?: string, options?: ErrorOptions): {
+        readonly code: ExpoSdkErrorCode;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class ExpoSdkTimeoutError extends ExpoSdkTimeoutError_base {
+}
+declare const UnknownSdkError_base: {
+    new (message?: string, options?: ErrorOptions): {
+        readonly code: ExpoSdkErrorCode;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class UnknownSdkError extends UnknownSdkError_base {
+}
+declare function errorFromCode(code: string, message?: string): PickleballExpoError;
+declare function normalizeError(error: unknown): PickleballExpoError;
+
+interface RoomConnection {
+    serverUrl: string;
+    participantToken: string;
+    microphoneEnabled: boolean;
+    /** false: vào phòng nhưng chưa publish track (trạng thái standby). */
+    publish?: boolean;
+}
+type RoomEvent = {
+    type: "reconnecting";
+} | {
+    type: "reconnected";
+} | {
+    type: "disconnected";
+    reason?: string;
+} | {
+    type: "media-error";
+    error: unknown;
+}
+/** Lệnh điều khiển từ dashboard qua LiveKit data channel ({"type":"cmd"}). */
+ | {
+    type: "command";
+    action: string;
+};
+interface RoomAdapter {
+    /** Bật/tắt publish track khi đã ở trong phòng (standby ↔ live). */
+    setPublishing?(enabled: boolean): Promise<void>;
+    setCaptureOrientation?(orientation: CaptureOrientation): Promise<void>;
+    listCameras?(): Promise<CameraDeviceInfo[]>;
+    selectCamera?(deviceId: string, facing: CameraDeviceInfo["facing"]): Promise<void>;
+    preparePreview(quality: 720 | 1080): Promise<unknown>;
+    connect(input: RoomConnection): Promise<void>;
+    disconnect(stopTracks?: boolean): Promise<void>;
+    switchCamera(): Promise<void>;
+    setMicrophoneEnabled(enabled: boolean): Promise<void>;
+    subscribe(listener: (event: RoomEvent) => void): () => void;
+    dispose(): Promise<void>;
+}
+interface SdkRuntime {
+    assertSupported(): void;
+    requestPermissions(): Promise<boolean>;
+    activateKeepAwake(): void | Promise<void>;
+    deactivateKeepAwake(): void | Promise<void>;
+}
+interface SdkStorage {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+interface SdkNetwork {
+    isOnline(): boolean;
+    subscribe(listener: (online: boolean) => void): () => void;
+}
+interface TelemetrySink {
+    send(credentials: SdkTelemetryCredentials, events: readonly SdkTelemetryEvent[]): Promise<void>;
+    dispose?(): void;
+}
+interface EngineDependencies {
+    sessionProvider: LivestreamSessionProvider;
+    bootstrapInput: BootstrapInput;
+    roomFactory: () => RoomAdapter;
+    runtime: SdkRuntime;
+    storage: SdkStorage;
+    network: SdkNetwork;
+    telemetry?: TelemetrySink;
+    /** Thu chỉ số thiết bị; gọi mỗi nhịp heartbeat khi đang phát. */
+    deviceMetrics?: () => Promise<DeviceMetricsSample | null>;
+    now?: () => number;
+}
+type CaptureOrientation = "portrait" | "landscape";
+interface CameraDeviceInfo {
+    deviceId: string;
+    label: string;
+    facing: "front" | "environment" | "unknown";
+}
+/** Chỉ số thiết bị gửi kèm heartbeat (trường trùng schema deviceMetrics). */
+interface DeviceMetricsSample {
+    batteryPct?: number;
+    batteryTempC?: number;
+    thermal?: number;
+    ramFreeMb?: number;
+    ramTotalMb?: number;
+    storageFreeGb?: number;
+    netType?: string;
+    linkMbps?: number;
+    rssi?: number;
+    connQuality?: string;
+    charging?: boolean;
+}
+interface LivestreamSnapshot {
+    state: LivestreamState;
+    error: PickleballExpoError | null;
+    config: SdkRemoteConfig | null;
+    sessionId: string | null;
+    previewTrack: unknown;
+    isMicrophoneEnabled: boolean;
+    isCameraFront: boolean;
+    /** Explicit pre-live choice; null follows the window orientation. */
+    captureOrientation: CaptureOrientation | null;
+    /** Mẫu chỉ số thiết bị mới nhất (cập nhật mỗi heartbeat khi live). */
+    deviceMetrics: DeviceMetricsSample | null;
+    /** Cameras reported by the platform after preview was prepared. */
+    cameras: CameraDeviceInfo[];
+    /** Explicitly chosen camera; null when following facing (front/back). */
+    selectedCameraId: string | null;
+    elapsedMs: number;
+    isOnline: boolean;
+}
+declare const PENDING_END_KEY = "@pickleball/expo-sdk/pending-end";
+declare const LEGAL_LIVESTREAM_TRANSITIONS: Readonly<Record<LivestreamState, readonly LivestreamState[]>>;
+declare class LivestreamEngine {
+    private readonly dependencies;
+    private room?;
+    private readonly now;
+    private snapshot;
+    private listeners;
+    private preparePromise?;
+    private startPromise?;
+    private stopPromise?;
+    private retryPromise?;
+    private credentialRefreshPromise?;
+    private pendingReplayPromise?;
+    private startupRecoveryPromise?;
+    private startupRecovered;
+    private pendingReplayError?;
+    private ownedSessionId?;
+    private commandTail;
+    private commandCount;
+    private roomUnsubscribe;
+    private networkUnsubscribe;
+    private networkSubscribed;
+    private latestAppState;
+    private backgroundTimer?;
+    private standbyTimer?;
+    private reconnectTimer?;
+    private heartbeatTimer?;
+    private elapsedTimer?;
+    private tokenRefreshTimer?;
+    private maxSessionTimer?;
+    private grant?;
+    private startedAt?;
+    /** Đang publish track (live) hay chỉ ngồi trong phòng (standby). */
+    private publishing;
+    /** Tổng thời gian đã phát trước lần tạm dừng gần nhất. */
+    private pausedElapsedMs;
+    private sessionDeadline?;
+    private refreshRetryAttempt;
+    private operationGeneration;
+    private liveTimersStarted;
+    private keepAwakeActive;
+    private telemetryInFlight?;
+    private pendingCriticalTelemetry?;
+    private readonly sessionTerminations;
+    private disposePromise?;
+    private disposed;
+    constructor(dependencies: EngineDependencies);
+    getSnapshot: () => LivestreamSnapshot;
+    subscribe: (listener: () => void) => () => boolean;
+    initialize(): Promise<void>;
+    prepare(): Promise<void>;
+    private doPrepare;
+    start(input: StartLivestreamInput, options?: {
+        autoPublish?: boolean;
+    }): Promise<void>;
+    private doStart;
+    stop(reason?: EndReason): Promise<void>;
+    private doStop;
+    retry(): Promise<void>;
+    private doRetry;
+    switchCamera(): Promise<void>;
+    /** Chọn một ống kính cụ thể từ snapshot.cameras. */
+    selectCamera(deviceId: string): Promise<void>;
+    /** Chọn kiểu quay trước khi live; không đổi khi phiên đang hoạt động. */
+    setCaptureOrientation(orientation: CaptureOrientation): Promise<void>;
+    setMicrophoneEnabled(enabled: boolean): Promise<void>;
+    handleRoomEvent(event: RoomEvent): void;
+    handleAppState(state: "active" | "background" | "inactive"): void;
+    private ensureBackgroundGraceTimer;
+    dispose(): Promise<void>;
+    private replayPendingEnd;
+    private doReplayPendingEnd;
+    private recoverStartupSession;
+    private ensurePendingEndResolved;
+    private readPendingEnd;
+    private ownsInMemorySession;
+    private startTimers;
+    private clearTimers;
+    private clearReconnectTimer;
+    /** Heartbeat kèm chỉ số thiết bị (nếu collector được cung cấp). */
+    private sendHeartbeat;
+    private sendTelemetry;
+    private startTelemetrySend;
+    private refreshCredentials;
+    private transition;
+    private startStandbyTimer;
+    private clearStandbyTimer;
+    private fail;
+    private recordError;
+    private update;
+    private ensureState;
+    private ensureNotDisposed;
+    private ensureRoom;
+    private ensureNetworkSubscription;
+    private requireRoom;
+    private releaseRoom;
+    private enqueueLifecycle;
+    private scheduleTokenRefresh;
+    private scheduleMaxSessionDuration;
+    private restartHeartbeat;
+    private enterSession;
+    /** Bắt đầu phát khi đang standby (từ nút trên app hoặc lệnh dashboard). */
+    startPublishing(): Promise<void>;
+    /** Tạm dừng phát: ngắt kết nối LiveKit hoàn toàn về standby, KHÔNG kết thúc phiên. */
+    stopPublishing(): Promise<void>;
+    private ensureSessionTermination;
+    private abandonGrant;
+    private isOperationCurrent;
+    private ensureOperation;
+}
+
+type Fetch = typeof globalThis.fetch;
+type HeadersInput = Record<string, string>;
+interface HttpSessionProviderPaths {
+    bootstrap: string;
+    sessions: string;
+    refresh(sessionId: string): string;
+    end(sessionId: string): string;
+    publish(sessionId: string): string;
+    unpublish(sessionId: string): string;
+}
+interface HttpSessionProviderOptions {
+    /** Base URL of the partner-owned mobile proxy. Never the Pickleball API URL. */
+    baseUrl: string;
+    fetch?: Fetch;
+    headers?: HeadersInput | (() => HeadersInput | Promise<HeadersInput>);
+    timeoutMs?: number;
+    paths?: Partial<HttpSessionProviderPaths>;
+}
+declare function createHttpSessionProvider(options: HttpSessionProviderOptions): LivestreamSessionProvider;
+
+interface LocalTrackLike {
+    kind: string;
+    stop(): void;
+    mute?(): Promise<unknown>;
+    unmute?(): Promise<unknown>;
+    /** livekit-client LocalVideoTrack restart; deterministic facing switch. */
+    restartTrack?(options: {
+        facingMode?: "user" | "environment";
+        deviceId?: string;
+        resolution?: {
+            width: number;
+            height: number;
+            frameRate: number;
+        };
+    }): Promise<unknown>;
+    mediaStreamTrack?: {
+        readyState?: string;
+        /**
+         * react-native-webrtc: đổi thiết bị/facing TẠI CHỖ trên cùng track native
+         * (mediaStreamTrackApplyConstraints) — preview và sender giữ nguyên.
+         */
+        applyConstraints?(constraints: {
+            facingMode?: "user" | "environment";
+            deviceId?: string;
+            width?: number;
+            height?: number;
+            frameRate?: number;
+        }): Promise<void>;
+        /** react-native-webrtc native camera flip; blind front/back toggle. */
+        _switchCamera?(): void;
+    };
+}
+interface RoomLike {
+    state: string;
+    localParticipant: {
+        publishTrack(track: LocalTrackLike, options?: unknown): Promise<unknown>;
+        unpublishTrack?(track: LocalTrackLike, stopOnUnpublish?: boolean): Promise<unknown> | unknown;
+    };
+    connect(serverUrl: string, token: string, options?: unknown): Promise<void>;
+    disconnect(stopTracks?: boolean): Promise<void>;
+    on(event: string, listener: (...args: unknown[]) => void): unknown;
+    off(event: string, listener: (...args: unknown[]) => void): unknown;
+}
+interface NativeLiveKitBindings {
+    registerGlobals(): void;
+    createRoom(): RoomLike;
+    createLocalTracks(options: {
+        audio: true;
+        video: {
+            facingMode?: "user" | "environment";
+            deviceId?: string;
+            resolution: {
+                width: number;
+                height: number;
+                frameRate: number;
+            };
+        };
+    }): Promise<LocalTrackLike[]>;
+    startAudioSession(): Promise<void> | void;
+    stopAudioSession(): Promise<void> | void;
+    /** Current window orientation; capture dimensions follow it. */
+    isLandscape?(): boolean;
+    /** Physical/virtual cameras reported by the platform. */
+    listCameras?(): Promise<CameraDeviceInfo[]>;
+    cameraSource?: unknown;
+    events: {
+        reconnecting: string;
+        reconnected: string;
+        disconnected: string;
+        mediaDevicesError: string;
+        /** LiveKit RoomEvent.DataReceived — nhận lệnh điều khiển từ dashboard. */
+        dataReceived?: string;
+    };
+}
+interface LocalPreviewReference {
+    videoTrack: unknown;
+    trackRef?: {
+        participant: RoomLike["localParticipant"];
+        publication: unknown;
+        source?: unknown;
+    };
+}
+declare class LiveKitRoomAdapter implements RoomAdapter {
+    private readonly bindings;
+    private readonly room;
+    private readonly listeners;
+    private tracks;
+    private videoTrack?;
+    private audioTrack?;
+    private preview?;
+    private isFront;
+    private orientationOverride;
+    private deviceOverride;
+    private published;
+    private disposed;
+    private quality;
+    private readonly nativeListeners;
+    constructor(bindings: NativeLiveKitBindings);
+    preparePreview(quality: 720 | 1080): Promise<LocalPreviewReference | undefined>;
+    connect(input: RoomConnection): Promise<void>;
+    /** Bật/tắt publish track khi đã trong phòng — standby ↔ live. */
+    setPublishing(enabled: boolean): Promise<void>;
+    disconnect(stopTracks?: boolean): Promise<void>;
+    private captureResolution;
+    setCaptureOrientation(orientation: "portrait" | "landscape"): Promise<void>;
+    /**
+     * livekit-client restart() chỉ giữ deviceId/facingMode khi gọi getUserMedia
+     * (vứt width/height/frameRate) nên track mới rơi về format mặc định
+     * 640x480. Native applyConstraints thì ngược lại: chỉ xử lý
+     * width/height/frameRate. Sau mỗi restartTrack phải nắn lại format trên
+     * track mới bằng applyConstraints.
+     */
+    private reapplyCaptureFormat;
+    switchCamera(): Promise<void>;
+    listCameras(): Promise<CameraDeviceInfo[]>;
+    selectCamera(deviceId: string, facing: CameraDeviceInfo["facing"]): Promise<void>;
+    setMicrophoneEnabled(enabled: boolean): Promise<void>;
+    subscribe(listener: (event: RoomEvent) => void): () => boolean;
+    dispose(): Promise<void>;
+    private releaseTracks;
+    private ensurePreparedTracks;
+    private emit;
+    private ensureNotDisposed;
+}
+
+declare function createNativeLiveKitBindings(): NativeLiveKitBindings;
+declare function createDefaultRuntime(): SdkRuntime;
+declare function createDefaultStorage(): SdkStorage;
+declare function createDefaultNetwork(): SdkNetwork;
+declare function createDefaultTelemetry(fetchImplementation?: typeof fetch, timeoutMs?: number): TelemetrySink;
+declare function createDefaultRoomFactory(): EngineDependencies["roomFactory"];
+/**
+ * Thu chỉ số thiết bị cho heartbeat. Mỗi nguồn là optional — thiếu package
+ * (expo-battery/expo-device/expo-file-system) thì bỏ qua trường đó thay vì lỗi.
+ */
+declare function createDefaultDeviceMetrics(): NonNullable<EngineDependencies["deviceMetrics"]>;
+
+interface LivestreamTheme {
+    background: string;
+    foreground: string;
+    accent: string;
+    danger: string;
+    /** Chữ phụ mờ nhất (labels, chú thích). */
+    muted: string;
+    overlay: string;
+    radius: number;
+    /** Token FintechX — đồng bộ với dashboard web. */
+    surface: string;
+    elevated: string;
+    hairline: string;
+    /** Màu chữ đặt trên nền accent. */
+    ink: string;
+    textSecondary: string;
+    radiusSm: number;
+    fontFamily?: string;
+    fontFamilyBold?: string;
+    displayFontFamily?: string;
+}
+/** FintechX design tokens — trùng bộ token trong apps/web/globals.css. */
+declare const defaultLivestreamTheme: LivestreamTheme;
+interface PickleballLiveProviderProps {
+    children?: ReactNode;
+    sessionProvider: LivestreamSessionProvider;
+    bootstrapInput: BootstrapInput;
+    runtime?: SdkRuntime;
+    storage?: SdkStorage;
+    network?: SdkNetwork;
+    telemetry?: TelemetrySink;
+    roomFactory?: () => RoomAdapter;
+    deviceMetrics?: EngineDependencies["deviceMetrics"];
+    theme?: Partial<LivestreamTheme>;
+    locale?: "vi" | "en";
+    onError?: (error: PickleballExpoError) => void;
+}
+interface LivestreamContextValue extends LivestreamSnapshot {
+    locale: "vi" | "en";
+    theme: LivestreamTheme;
+    prepare(): Promise<void>;
+    start(input: StartLivestreamInput, options?: {
+        autoPublish?: boolean;
+    }): Promise<void>;
+    /** Bắt đầu phát khi đang standby. */
+    startPublishing(): Promise<void>;
+    /** Tạm dừng phát về standby (không kết thúc phiên). */
+    stopPublishing(): Promise<void>;
+    stop(reason?: EndReason): Promise<void>;
+    retry(): Promise<void>;
+    switchCamera(): Promise<void>;
+    setMicrophoneEnabled(enabled: boolean): Promise<void>;
+    setCaptureOrientation(orientation: "portrait" | "landscape"): Promise<void>;
+    selectCamera(deviceId: string): Promise<void>;
+}
+declare function PickleballLiveProvider(props: PickleballLiveProviderProps): React.JSX.Element;
+declare function useLivestream(): LivestreamContextValue;
+
+type RenderState = ReturnType<typeof useLivestream>;
+interface LivestreamScreenProps {
+    input: StartLivestreamInput;
+    style?: ViewStyle;
+    /**
+     * Hướng máy vật lý (từ cảm biến, ví dụ expo-sensors DeviceMotion). Khi được
+     * cung cấp, nút bắt đầu phát bị chặn nếu máy đang cầm lệch với khung
+     * 9:16/16:9 đã chọn. Bỏ trống để tắt kiểm tra.
+     */
+    physicalOrientation?: "portrait" | "landscape" | null;
+    /**
+     * Tự kết nối vào phòng khi mở màn hình nếu consent đã được lưu từ trước
+     * (mặc định bật) — dashboard điều khiển được ngay từ lúc app bật.
+     */
+    autoConnect?: boolean;
+    renderPreview?: (state: RenderState) => ReactNode;
+    renderHeader?: (state: RenderState) => ReactNode;
+    renderControls?: (state: RenderState) => ReactNode;
+    renderError?: (state: RenderState) => ReactNode;
+    onEnded?: () => void;
+}
+declare function LivestreamScreen(props: LivestreamScreenProps): React.JSX.Element;
+
+export { type AnnouncementKind, type AnnouncementPlan, type AudioPlayback, BTHOME_SERVICE_UUID, type BTHomeAdvertisementInput, BTHomeRemoteDeduplicator, type BTHomeRemoteDeduplicatorOptions, BTHomeRemoteParseError, type BTHomeRemoteParseErrorCode, type BootstrapInput, type CameraDeviceInfo, type CaptureOrientation, ConsentRequiredError, type CourtSide, type CourtSwitchConfirmedEvent, DEFAULT_REMOTE_ACTION_MAPPING, type DefaultMatchVoiceServiceOptions, type DeviceMetricsSample, type EndLivestreamInput, type EndReason, type EngineDependencies, type ExpoAudioBindings, type ExpoAudioPlaybackOptions, type ExpoAudioPlayer, ExpoSdkConfigurationError, type ExpoSdkErrorCode, ExpoSdkTimeoutError, type ExpoSqliteDatabaseLike, type FallbackVoiceToken, type GameSnapshot, type GeminiVoiceEngineOptions, type GeneratedAudioFileSystem, HidVolumeGestureRecognizer, type HidVolumeGestureRecognizerOptions, type HttpSessionProviderOptions, type HttpSessionProviderPaths, InvalidResponseError, LEGAL_LIVESTREAM_TRANSITIONS, LatestAnnouncementScheduler, type LatestAnnouncementSchedulerOptions, LiveKitRoomAdapter, type LivestreamContextValue, LivestreamEngine, LivestreamScreen, type LivestreamScreenProps, type LivestreamSessionProvider, type LivestreamSnapshot, type LivestreamState, type LivestreamTheme, type LocalPreviewReference, MATCH_PERSISTENCE_SCHEMA_VERSION, MATCH_SQL_MIGRATIONS, MATCH_SQL_SCHEMA_VERSION, type MatchCorrectedEvent, type MatchCorrection, type MatchCreateInput, type MatchCreatedEvent, type MatchCreation, type MatchEndedEvent, type MatchEvent, MatchEventStore, type MatchEventUndoneEvent, type MatchFormat, type MatchInputSource, type MatchPersistenceDriver, MatchPersistenceError, type MatchPersistenceErrorCode, type MatchPersistenceTransaction, type MatchPlayer, type MatchScoringMode, type MatchSnapshot, type MatchSummary, type MatchTeam, type MatchTeamId, type MatchVoiceService, MemoryMatchPersistenceDriver, type NativeAudioSessionBindings, type NativeLiveKitBindings, NetworkUnavailableError, type NeuralVoiceAvailability, type NeuralVoiceEngine, NoActiveMatchError, PENDING_END_KEY, type ParsedBTHomeRemoteAdvertisement, type PendingCourtSwitch, PermissionDeniedError, type PersistedMatch, PickleballExpoError, PickleballLiveProvider, type PickleballLiveProviderProps, type PickleballMatchContextValue, PickleballMatchProvider, type PickleballMatchProviderProps, type PickleballMatchStore, type RallyAwardedEvent, RecordingFailureError, type RemoteActionMapping, type RemoteBinding, type RemoteButtonAction, type RemoteCandidate, type RemoteDeduplicationKey, RemoteError, type RemoteErrorCode, type RemoteHidGesture, type RemoteHidGestureMapping, type RemoteHidVolumeEvent, type RemoteInputMode, type RemoteMappedAction, type RemoteNativeState, type RemotePermissionStatus, type RemoteScanAdvertisement, type RemoteService, type RemoteState, type RemoteStatus, type RoomAdapter, type RoomConnection, type RoomEvent, SDK_TELEMETRY_EVENT_NAMES, type SdkBootstrap, SdkDisabledError, type SdkError, type SdkErrorCode, type SdkNetwork, type SdkRemoteConfig, type SdkRuntime, type SdkSessionGrant, type SdkSessionRefresh, type SdkStorage, type SdkTelemetryCredentials, type SdkTelemetryEvent, type SdkTelemetryEventName, type ServeState, SessionConflictError, type StartLivestreamInput, type StoredMatchEventRow, type StoredMatchRow, type TeamScore, type TelemetrySink, TokenExpiredError, UnknownSdkError, UnsupportedRuntimeError, UnsupportedSdkError, type VoiceAudioMode, type VoiceAudioRoute, type VoiceDisconnectReason, VoiceError, type VoiceErrorCode, type VoiceRouteState, type VoiceTtsOptions, applyMatchEvent, awardRally, buildVietnameseAnnouncement, compareSemver, confirmCourtSwitch, correctMatch, createDefaultDeviceMetrics, createDefaultMatchEventStore, createDefaultMatchVoiceService, createDefaultNetwork, createDefaultRoomFactory, createDefaultRuntime, createDefaultStorage, createDefaultTelemetry, createExpoAudioPlayback, createExpoSqliteMatchDriver, createGeminiVoiceEngine, createHttpSessionProvider, createMatch, createNativeLiveKitBindings, createUnavailableVoiceEngine, decodeBase64Bytes, defaultLivestreamTheme, endMatch, errorFromCode, isSdkRemoteConfig, isSdkVersionSupported, normalizeError, parseBTHomeV2Advertisement, planBundledFallback, replayMatchEvents, resolveBundledVoiceAsset, undoLastMatchEvent, useLivestream, usePickleballMatch };