@pickleball/expo-sdk 0.2.0 → 1.0.0

package/dist/index.d.ts

@@ -1,35 +1,11 @@
-import { S as StartLivestreamInput, L as LivestreamSessionProvider } from './engine-CCSSqPbZ.js';
-export { B as BootstrapInput, C as CameraDeviceInfo, a as CaptureOrientation, b as ConsentRequiredError, D as DeviceMetricsSample, E as EndLivestreamInput, c as EndReason, d as ExpoSdkConfigurationError, e as ExpoSdkErrorCode, f as ExpoSdkTimeoutError, I as InvalidResponseError, g as LivestreamSnapshot, h as LivestreamState, N as NetworkUnavailableError, P as PermissionDeniedError, i as PickleballExpoError, R as RecordingFailureError, j as RoomAdapter, k as SDK_TELEMETRY_EVENT_NAMES, l as SdkBootstrap, m as SdkDisabledError, n as SdkError, o as SdkErrorCode, p as SdkNetwork, q as SdkRemoteConfig, r as SdkRuntime, s as SdkSessionGrant, t as SdkSessionRefresh, u as SdkStorage, v as SdkTelemetryCredentials, w as SdkTelemetryEvent, x as SdkTelemetryEventName, y as SessionConflictError, T as TelemetrySink, z as TokenExpiredError, U as UnknownSdkError, A as UnsupportedRuntimeError, F as UnsupportedSdkError, G as compareSemver, H as errorFromCode, J as isSdkRemoteConfig, K as isSdkVersionSupported, M as isSessionGoneError, O as normalizeError } from './engine-CCSSqPbZ.js';
-import { u as useLivestream } from './advanced-BXDrDl1h.js';
-export { L as LivestreamContextValue, a as LivestreamTheme, P as PickleballLiveProvider, b as PickleballLiveProviderProps, c as createDefaultStorage, d as defaultLivestreamTheme } from './advanced-BXDrDl1h.js';
-import React, { ReactNode } from 'react';
-import { ViewStyle } from 'react-native';
+import { L as LivestreamSessionProvider, b as SdkSessionGrant, C as CameraGrant, c as StartLivestreamInput, a as SdkStorage, d as SdkRemoteConfig } from './engine-BSvSdCSE.js';
+export { B as BootstrapInput, e as CameraDeviceInfo, f as CameraGrantStatus, g as CaptureOrientation, h as ConsentRequiredError, D as DeviceMetricsSample, E as EndLivestreamInput, i as EndReason, j as ExpoSdkConfigurationError, k as ExpoSdkErrorCode, l as ExpoSdkTimeoutError, I as InvalidResponseError, m as LivestreamSnapshot, n as LivestreamState, N as NetworkUnavailableError, P as PermissionDeniedError, o as PickleballExpoError, p as RecordingFailureError, R as RoomAdapter, q as SDK_TELEMETRY_EVENT_NAMES, r as SdkBootstrap, s as SdkConflictReason, t as SdkDisabledError, u as SdkError, v as SdkErrorCode, w as SdkNetwork, x as SdkRuntime, y as SdkSessionRefresh, z as SdkTelemetryCredentials, A as SdkTelemetryEvent, F as SdkTelemetryEventName, G as SessionCommandAction, H as SessionCommandChannel, J as SessionCommandPollResult, K as SessionCommandRecord, S as SessionCommandSubscription, M as SessionConflictError, T as TelemetrySink, O as TokenExpiredError, U as UnknownSdkError, Q as UnsupportedRuntimeError, V as UnsupportedSdkError, W as compareSemver, X as errorFromCode, Y as isSdkRemoteConfig, Z as isSdkVersionSupported, _ as isSessionGoneError, $ as normalizeError } from './engine-BSvSdCSE.js';
+import { F as Fetch } from './advanced-DcbHBCGb.js';
+export { L as LivestreamContextValue, a as LivestreamTheme, P as PickleballLiveProvider, b as PickleballLiveProviderProps, c as createDefaultStorage, d as createRtmpRoomFactory, e as createRtmpRuntime, f as defaultLivestreamTheme, u as useLivestream } from './advanced-DcbHBCGb.js';
+export { A as AntiFlickerMode, C as CAMERA_SETTINGS_STORAGE_KEY, a as CameraCapabilities, b as CameraCapabilityRange, c as CameraSettings, d as CameraSettingsStore, e as CameraSettingsStoreOptions, D as DEFAULT_CAMERA_SETTINGS, f as applyAntiFlicker, g as cameraSettingsKey, h as createCameraSettingsStore, i as getCameraCapabilities, p as parseCameraSettings, r as requestNativePermissions, j as rtmpRoomFactoryFor, s as setExposureBias, k as setExposureLocked, l as setFocusLocked, m as setTorch, n as setZoom, u as useCameraSettings } from './camera-controls-rCBUGGPC.js';
 export { PICKLEBALL_EXPO_SDK_VERSION } from './version.js';
+import 'react';
 
-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;
-
-type Fetch = typeof globalThis.fetch;
 type HeadersInput = Record<string, string>;
 interface HttpSessionProviderPaths {
     bootstrap: string;
@@ -40,7 +16,11 @@ interface HttpSessionProviderPaths {
     unpublish(sessionId: string): string;
 }
 interface HttpSessionProviderOptions {
-    /** Base URL of the partner-owned mobile proxy. Never the Pickleball API URL. */
+    /**
+     * Base URL của proxy do đối tác host (mô hình cũ) hoặc namespace first-party
+     * `/api/v2/device-app` (app fleet). Không bao giờ là URL PickLive kèm API key.
+     * App đối tác dùng camera grant thì dùng createCameraGrantProvider thay vì đây.
+     */
     baseUrl: string;
     fetch?: Fetch;
     headers?: HeadersInput | (() => HeadersInput | Promise<HeadersInput>);
@@ -49,4 +29,307 @@ interface HttpSessionProviderOptions {
 }
 declare function createHttpSessionProvider(options: HttpSessionProviderOptions): LivestreamSessionProvider;
 
-export { type HttpSessionProviderOptions, type HttpSessionProviderPaths, LivestreamScreen, type LivestreamScreenProps, LivestreamSessionProvider, StartLivestreamInput, createHttpSessionProvider, useLivestream };
+/**
+ * Nhận lại phiên sau khi app bị kill/mở lại — phần PROVIDER.
+ *
+ * Kịch bản: máy đang phát, app biến mất (sụp nguồn, OEM giết, vuốt tắt). Server
+ * còn giữ phiên. Lần mở sau engine thấy dấu trên đĩa (adoptableSessionId) nhưng
+ * KHÔNG có grant trong bộ nhớ — phải hỏi server cấp lại credentials của đúng
+ * phiên đó rồi start bằng grant ấy thay vì tạo phiên mới. Link xem và VOD nhờ
+ * vậy liền một mạch.
+ */
+type ResumeAttempt = {
+    kind: "grant";
+    grant: SdkSessionGrant;
+    live: boolean;
+} | {
+    kind: "gone";
+} | {
+    kind: "retry";
+};
+interface ResumableSessionProvider extends LivestreamSessionProvider {
+    /** Đặt grant cho lượt start kế tiếp có externalSessionId `resume-<id>`. */
+    adoptResumeGrant(grant: SdkSessionGrant): void;
+    /** Hỏi server cấp lại grant cho phiên còn sống. */
+    resume(sessionId: string): Promise<ResumeAttempt>;
+}
+/**
+ * Bọc provider: `start()` ưu tiên grant nhận lại nếu khớp phiên, còn lại tạo phiên
+ * mới như thường. Grant chờ nằm trong closure (không biến module) nên hai provider
+ * trong cùng app không dẫm nhau.
+ */
+declare function withResume(provider: LivestreamSessionProvider, resume: (sessionId: string) => Promise<ResumeAttempt>): ResumableSessionProvider;
+/** Biến phản hồi refresh (đầy đủ) thành grant; méo → null để caller coi là retry. */
+declare function grantFromRefreshPayload(data: unknown): SdkSessionGrant | null;
+interface HttpResumeFetcherOptions {
+    /** URL endpoint refresh của phiên — namespace nào cũng được, miễn trả grant đầy đủ + status. */
+    url(sessionId: string): string;
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    fetch?: Fetch;
+    timeoutMs?: number;
+}
+/**
+ * Gọi endpoint refresh để dựng lại grant. Trả về PHÂN LOẠI chứ không phải
+ * null-cho-mọi-thứ (xem resume-policy): mất mạng/5xx/méo = retry, 404/409/410 =
+ * gone. Chỉ phát tiếp khi server xác nhận phiên ĐANG live — thiếu trường status
+ * coi như không phát: để camera tự lên sóng nhầm còn tệ hơn là chờ một lệnh nữa.
+ */
+declare function createHttpResumeFetcher(options: HttpResumeFetcherOptions): (sessionId: string) => Promise<ResumeAttempt>;
+
+/**
+ * Session provider cho ĐIỆN THOẠI ĐỐI TÁC (camera grant, ADR-0002).
+ *
+ *   App đối tác ──(auth riêng)──► Backend đối tác ──khoá API (chỉ server)──► PickLive REST v1
+ *   App đối tác ◄───────── CameraGrant nguyên trạng ◄──────────
+ *   SDK ──Bearer grant.telemetry.token──► PickLive /api/v2/camera/sessions/{id}/*
+ *
+ * App KHÔNG cầm API key, KHÔNG cấu hình URL PickLive: mọi endpoint suy từ
+ * `telemetry.endpoint` trong grant. Backend đối tác chỉ có đúng một việc — cấp grant.
+ *
+ * Handle phiên `{sessionId, base, token}` được LƯU trong sandbox app (expo-sqlite
+ * localStorage) duy nhất để nhận lại phiên sau khi app bị kill; token khoá theo
+ * một phiên và tự hết hạn. Đây là thay đổi so với lời hứa "token chỉ ở bộ nhớ"
+ * của mô hình proxy cũ — chủ ý, để resume hoạt động.
+ */
+declare const CAMERA_GRANT_STORAGE_KEY = "@pickleball/expo-sdk/camera-grant";
+/** Config local cho bước prepare (engine chỉ dùng enabled/minSdkVersion/videoQuality ở đây). */
+declare const DEFAULT_LOCAL_CONFIG: SdkRemoteConfig;
+type CameraGrantPhase = "start" | "refresh" | "resume";
+interface CameraGrantProviderOptions {
+    /**
+     * App đối tác gọi backend đối tác → backend gọi PickLive → trả grant nguyên
+     * trạng. Nhận StartLivestreamInput của engine (kèm `standby`, `quality`) để
+     * backend chuyển tiếp title/quality nếu muốn.
+     */
+    requestGrant(input: StartLivestreamInput): Promise<unknown>;
+    storage?: SdkStorage;
+    storageKey?: string;
+    fetch?: Fetch;
+    timeoutMs?: number;
+    /** Ghi đè config local của bước prepare (VD videoQuality theo cài đặt máy). */
+    localConfig?: Partial<SdkRemoteConfig>;
+    onGrant?(grant: CameraGrant, phase: CameraGrantPhase): void;
+}
+interface CameraGrantHandle {
+    sessionId: string;
+    base: string;
+    token: string;
+    tokenExpiresAt: number;
+    quality?: 720 | 1080;
+    savedAt: number;
+}
+interface CameraGrantProvider extends ResumableSessionProvider {
+    /** Grant đang cầm (null khi chưa có phiên). */
+    getActiveGrant(): CameraGrant | null;
+    subscribe(listener: () => void): () => void;
+    /** Có handle phiên trên đĩa → truyền vào `keepSessionOnRestart` của provider. */
+    hasResumableSession(): Promise<boolean>;
+    /** Quên phiên (logout/đổi user). Backend đối tác nên gọi end phiên đó. */
+    clearStoredSession(): Promise<void>;
+}
+declare function createCameraGrantProvider(options: CameraGrantProviderOptions): CameraGrantProvider;
+/** Grant hiện hành của provider, theo dõi bằng useSyncExternalStore. */
+declare function useCameraGrant(provider: CameraGrantProvider): CameraGrant | null;
+
+/**
+ * Luật quyết định khi nối lại một phiên server còn giữ cho máy này.
+ *
+ * Chuyển từ apps/device-streamer (src/resume-policy.ts) vào SDK để app đối tác
+ * không phải học lại từng cái bẫy đã đo được trên fleet.
+ *
+ * Vì sao cần tách riêng: bản đầu coi MỌI thất bại là "phiên đã chết" và bỏ cuộc
+ * vĩnh viễn sau đúng một lần thử. Hệ quả: máy khởi động lại lúc wifi chưa kịp
+ * lên là mất luôn cơ hội nối lại — đúng ca hay gặp nhất, vì máy vừa mở nguồn
+ * thì wifi luôn lên chậm hơn app.
+ *
+ * Phân biệt hai loại thất bại là toàn bộ giá trị của module này:
+ * - "gone": server nói phiên không còn. Thử lại bao nhiêu cũng vô ích.
+ * - "retry": mạng chưa lên, server trục trặc, phản hồi méo. Phiên có thể vẫn sống.
+ *
+ * Nghi ngờ thì chọn "retry": đoán nhầm thành "gone" là mất phiên vĩnh viễn (link
+ * xem đổi, VOD tách đôi); đoán nhầm thành "retry" chỉ tốn vài request, và đã có
+ * lưới server dọn phiên mồ côi.
+ */
+/** Phân loại phản hồi HTTP của endpoint refresh. */
+type ResumeVerdict = "ok" | "gone" | "retry";
+/**
+ * 404 = phiên biến mất hẳn. 409 = phiên đã kết thúc (mọi namespace trả
+ * SESSION_CONFLICT cho thao tác trên phiên ended, và grant bị thay cũng là 409).
+ * 410 = Gone theo chuẩn HTTP. Mọi mã khác — kể cả 401/403 — đều là "retry":
+ * token có thể được cấp lại ở nhịp sau, và một lỗi xác thực tạm thời không phải
+ * bằng chứng phiên đã chết.
+ */
+declare function classifyResumeStatus(status: number): ResumeVerdict;
+/**
+ * Nhịp thử lại. Nhịp đầu 1 giây vì ca điển hình là "app mở trước khi wifi lên" —
+ * chờ vài giây là xong. Trần 15 giây để một máy chết hẳn không nện server mãi;
+ * số lần thì KHÔNG giới hạn: thà thử mãi còn hơn mất phiên, và lưới server
+ * (1 giờ cho live, 30 phút cho standby) mới là thứ quyết định lúc nào bỏ cuộc.
+ */
+declare const RESUME_RETRY_DELAYS_MS: number[];
+declare function resumeRetryDelayMs(attempt: number): number;
+/**
+ * Bất kỳ ai định TẠO PHIÊN MỚI tự động (AutoTournament của fleet, useStandbySession
+ * của app đối tác) phải NHƯỜNG khi còn phiên chờ nhận lại — nhìn CẢ HAI nguồn.
+ *
+ * Bản đầu chỉ nhìn serverSession (heartbeat, về SAU vài giây); adoptableSessionId
+ * (dấu trên đĩa) có mặt ngay từ lúc engine khởi động xong. Khe hở vài giây đó là
+ * đủ để một lượt arm nổ súng trước AutoResume: hoặc đụng chốt marker (app đứng
+ * màn LỖI), hoặc tệ hơn — lách qua trong đúng cửa sổ race và tạo phiên chờ THỨ
+ * HAI đè phiên live cũ (đo thật đêm 18/08/2026).
+ */
+declare function resumeBlocksArm(input: {
+    adoptableSessionId: string | null;
+    serverSessionId: string | null;
+    engineSessionId: string | null;
+}): boolean;
+/** Quy ước externalSessionId của lượt start NHẬN LẠI — engine chỉ cho lượt này qua chốt marker. */
+declare function resumeExternalSessionId(sessionId: string): string;
+/**
+ * Grant nối lại chỉ được tiêu thụ cho ĐÚNG phiên nó được cấp. AutoResume có thể
+ * bắn nhiều lượt (retry, đổi nguồn); không kiểm khớp thì một grant cũ còn sót có
+ * thể bị lượt start của phiên khác nuốt — engine nối vào nhầm phiên, đúng loại lỗi
+ * âm thầm khó truy nhất.
+ */
+declare function resumeGrantMatches(externalSessionId: string | undefined, grantSessionId: string): boolean;
+
+/**
+ * Ba mảnh "tự động" chuyển từ apps/device-streamer vào SDK — mọi app RTMP cần
+ * chúng, không riêng máy fleet:
+ *
+ * - PickleballAutoPrepare: camera luôn bật (prepare khi idle/ended).
+ * - PickleballAutoResume: app mở lại thấy phiên còn sống → nhận lại đúng phiên.
+ * - useStandbySession: chế độ sân — arm một phiên chờ, server lật live bằng lệnh.
+ *
+ * Các bẫy đã đo trên fleet (18–19/08/2026) nằm nguyên trong đây: retry publish
+ * khi encoder chưa có SPS, thoát hố "error" khi còn phiên chờ nhận lại, và
+ * KHÔNG arm phiên mới khi còn phiên chờ nhận lại.
+ *
+ * Kỷ luật dependency: mọi effect ở đây chỉ phụ thuộc vào TRẠNG THÁI (state,
+ * sessionId, id phiên chờ, cờ enabled) — hành động của engine, props cấu hình
+ * (resumeInput, retryDelayMs, input) và callback đi qua ref. App đối tác thường
+ * truyền object/hàm inline mỗi lần render; đưa chúng vào deps là mỗi render
+ * huỷ lượt resume đang bay, bắn lượt mới ngay (spam refresh) và timer thử lại
+ * không bao giờ kịp nổ.
+ */
+type ResumeAttemptOutcome = ResumeAttempt["kind"] | "start_failed" | "publish_retry" | "reprepare";
+interface PickleballAutoResumeProps {
+    provider: ResumableSessionProvider;
+    /** Thông tin dựng lượt start nhận lại (title mặc định khi không biết tên phiên). */
+    resumeInput: {
+        consentVersion: string;
+        visibility?: "public" | "private";
+        metadata?: Record<string, string>;
+        titleFor?: (sessionId: string) => string;
+    };
+    /** false = tạm dừng (VD máy đang nghỉ). */
+    enabled?: boolean;
+    /**
+     * Nguồn thứ hai của id phiên còn sống (fleet: serverSession từ heartbeat).
+     * adoptableSessionId (dấu trên đĩa) luôn được ưu tiên vì có sớm hơn vài giây.
+     * Truyền CÙNG giá trị này vào `useStandbySession({resumeSessionId})` nếu app
+     * arm phiên chờ, để arm nhường đường nhận lại.
+     */
+    sessionIdHint?: string | null;
+    retryDelayMs?: (attempt: number) => number;
+    onAttempt?: (sessionId: string, outcome: ResumeAttemptOutcome) => void;
+}
+declare function PickleballAutoResume(props: PickleballAutoResumeProps): null;
+interface PickleballAutoPrepareProps {
+    enabled?: boolean;
+    /** Khung cố định (fleet: landscape). Bỏ trống = theo hướng máy như engine mặc định. */
+    captureOrientation?: "portrait" | "landscape";
+}
+/**
+ * Camera luôn sẵn: prepare khi idle và SAU KHI phiên kết thúc (thiếu nhánh
+ * `ended` là camera tối sau phiên đầu tiên). Không chạy khi đang lỗi — người
+ * dùng cần thấy lỗi, và AutoResume lo nhánh lỗi có phiên chờ.
+ */
+declare function PickleballAutoPrepare(props: PickleballAutoPrepareProps): null;
+interface UseStandbySessionOptions {
+    /** Lượt start chờ; đổi `externalSessionId` (trận kế) mới arm lại sau khi phiên trước kết thúc. */
+    input: StartLivestreamInput;
+    enabled?: boolean;
+    /**
+     * Id phiên còn sống theo nguồn NGOÀI đĩa (fleet: heartbeat; app đối tác: id
+     * backend trả về) — cùng giá trị truyền vào `PickleballAutoResume.sessionIdHint`.
+     * Có nó là arm NHƯỜNG: không tạo phiên chờ thứ hai trong lúc AutoResume đang
+     * nối lại phiên cũ.
+     */
+    resumeSessionId?: string | null;
+}
+/**
+ * Chế độ SÂN: điện thoại đứng chờ (standby) với grant đã cấp; trọng tài bấm
+ * match-start là server gửi lệnh `start` qua kênh lệnh và engine tự phát.
+ * Arm đúng một lần cho mỗi externalSessionId, và NHƯỜNG khi còn phiên chờ nhận
+ * lại (resumeBlocksArm) để không tạo phiên chờ thứ hai đè phiên cũ.
+ */
+declare function useStandbySession(options: UseStandbySessionOptions): {
+    armed: boolean;
+};
+
+/**
+ * Độ phân giải là lựa chọn LOCAL của máy — override `videoQuality` mà server trả
+ * trong bootstrap/start/refresh (engine truyền config.videoQuality vào
+ * room.preparePreview nên không cần sửa engine).
+ *
+ * Lúc TẠO phiên phải khai ngược lên server (`quality` trong StartLivestreamInput),
+ * nếu không bản ghi phiên nói dối: mặc định local 720 còn server 1080 — dashboard
+ * báo 1080 trong khi máy phát 720 suốt (18/08/2026). Chốt MỘT lần lúc start:
+ * gọi `resolution()` hai lần có thể ra hai giá trị khác nhau, khai một đằng dùng
+ * một nẻo thì tệ hơn là không khai.
+ */
+declare function withLocalVideoQuality<P extends LivestreamSessionProvider>(provider: P, resolution: () => 720 | 1080): P;
+
+/**
+ * Đo tốc độ TẢI LÊN — chiều duy nhất quan trọng với máy phát RTMP (root cause
+ * các ca đứng hình field day là uplink hụt). Chuyển từ apps/device-streamer/
+ * src/net-check.ts; bảng bitrate giờ là nguồn duy nhất (adapter RTMP import lại).
+ *
+ * Đích đo mặc định speed.cloudflare.com/__up (edge gần VN/SG): đo "sức uplink
+ * của đường mạng", không phải đường tới đúng VPS ingest — nghẽn thực tế nằm ở
+ * last-mile WiFi/4G nên xấp xỉ tốt, và không phải mở endpoint nào trên hạ tầng.
+ */
+/**
+ * Trần bitrate video theo mức chất lượng — trong khoảng TikTok khuyến nghị cho
+ * live (720p 3–6 Mbps, 1080p 6–9 Mbps). Thấp hơn là pickleball bể khối rất rõ.
+ */
+declare const VIDEO_BITRATE_BPS: Readonly<Record<720 | 1080, number>>;
+declare const AUDIO_BITRATE_BPS = 128000;
+interface UplinkCheckOptions {
+    resolution: 720 | 1080;
+    /** Đích POST khối dữ liệu; mặc định Cloudflare speed test. */
+    uploadUrl?: string;
+    /** HEAD để đo RTT (VD ingest của bạn). Bỏ trống = không đo ping. */
+    pingUrl?: string;
+    fetch?: typeof globalThis.fetch;
+    /** Đo tối thiểu chừng này thời gian sau warmup (mặc định 6s). */
+    measureMs?: number;
+    /** Trần cho cả bài đo (mặc định 25s). */
+    totalTimeoutMs?: number;
+    /** Cỡ mỗi khối POST (mặc định 2 MiB). */
+    chunkBytes?: number;
+    /** Trần cho khối warmup (mặc định 10s) — quá là mạng "low", không phải lỗi đo. */
+    warmupTimeoutMs?: number;
+}
+interface UplinkCheckResult {
+    uploadMbps: number;
+    /** RTT tới pingUrl, null nếu không đo/đo hỏng. */
+    pingMs: number | null;
+    /** Băng thông cần cho cấu hình (video trần + audio), Mbps. */
+    requiredMbps: number;
+    verdict: "good" | "ok" | "low";
+}
+declare const DEFAULT_UPLOAD_URL = "https://speed.cloudflare.com/__up";
+declare function requiredMbpsFor(settings: {
+    resolution: 720 | 1080;
+}): number;
+/**
+ * Verdict theo tỉ lệ đo/cần: ≥1.8× là dư (chịu được dao động), ≥1.25× tạm đủ
+ * (AIMD sẽ phải hạ bitrate lúc mạng chùng), dưới đó là thiếu — hạ cấu hình
+ * hoặc đổi mạng trước khi lên sóng.
+ */
+declare function verdictFor(uploadMbps: number, requiredMbps: number): UplinkCheckResult["verdict"];
+declare function runUplinkCheck(options: UplinkCheckOptions): Promise<UplinkCheckResult>;
+
+export { AUDIO_BITRATE_BPS, CAMERA_GRANT_STORAGE_KEY, CameraGrant, type CameraGrantHandle, type CameraGrantPhase, type CameraGrantProvider, type CameraGrantProviderOptions, DEFAULT_LOCAL_CONFIG, DEFAULT_UPLOAD_URL, type HttpResumeFetcherOptions, type HttpSessionProviderOptions, type HttpSessionProviderPaths, LivestreamSessionProvider, PickleballAutoPrepare, type PickleballAutoPrepareProps, PickleballAutoResume, type PickleballAutoResumeProps, RESUME_RETRY_DELAYS_MS, type ResumableSessionProvider, type ResumeAttempt, type ResumeAttemptOutcome, type ResumeVerdict, SdkRemoteConfig, SdkSessionGrant, SdkStorage, StartLivestreamInput, type UplinkCheckOptions, type UplinkCheckResult, type UseStandbySessionOptions, VIDEO_BITRATE_BPS, classifyResumeStatus, createCameraGrantProvider, createHttpResumeFetcher, createHttpSessionProvider, grantFromRefreshPayload, requiredMbpsFor, resumeBlocksArm, resumeExternalSessionId, resumeGrantMatches, resumeRetryDelayMs, runUplinkCheck, useCameraGrant, useStandbySession, verdictFor, withLocalVideoQuality, withResume };