@pickleball/server-sdk 0.1.1 → 0.3.0

package/dist/index.cjs

@@ -26,6 +26,7 @@ __export(index_exports, {
   PickleballInvalidResponseError: () => PickleballInvalidResponseError,
   PickleballLiveError: () => PickleballLiveError,
   PickleballNetworkError: () => PickleballNetworkError,
+  PickleballPartnerApiError: () => PickleballPartnerApiError,
   PickleballTimeoutError: () => PickleballTimeoutError,
   PickleballWebhookVerificationError: () => PickleballWebhookVerificationError,
   SDK_TELEMETRY_EVENT_NAMES: () => SDK_TELEMETRY_EVENT_NAMES,
@@ -55,6 +56,15 @@ var PickleballApiError = class extends PickleballLiveError {
     this.name = "PickleballApiError";
   }
 };
+var PickleballPartnerApiError = class extends PickleballLiveError {
+  constructor(message, partnerCode, status, details = {}) {
+    super(message, "PARTNER_API_ERROR");
+    this.partnerCode = partnerCode;
+    this.status = status;
+    this.details = details;
+    this.name = "PickleballPartnerApiError";
+  }
+};
 var PickleballHttpError = class extends PickleballLiveError {
   constructor(status) {
     super(`Request failed with HTTP ${status}`, "HTTP_ERROR");
@@ -283,6 +293,49 @@ function validateGrant(value) {
     config: validateRemoteConfig(data.config)
   };
 }
+function validateCameraGrant(value) {
+  const data = record(value);
+  const base = validateGrant(data);
+  if (!/^rtmps?:\/\//i.test(base.serverUrl)) invalid();
+  if (data.status !== "scheduled" && data.status !== "live") invalid();
+  return {
+    ...base,
+    status: data.status,
+    matchRef: nullableString(data.matchRef),
+    courtRef: nullableString(data.courtRef),
+    watchUrl: nullableString(data.watchUrl),
+    convexUrl: nullableString(data.convexUrl),
+    issuedAt: finite(data.issuedAt),
+    expiresAt: finite(data.expiresAt)
+  };
+}
+function validateCameraSessionCreated(value) {
+  const data = record(value);
+  if (data.status !== "scheduled" && data.status !== "live" && data.status !== "ended") {
+    invalid();
+  }
+  if (data.visibility !== "public" && data.visibility !== "private") invalid();
+  if (typeof data.reused !== "boolean") invalid();
+  return {
+    id: nonblank(data.id),
+    status: data.status,
+    visibility: data.visibility,
+    quality: finite(data.quality),
+    deliveryMode: nonblank(data.deliveryMode),
+    matchRef: nullableString(data.matchRef),
+    courtRef: nullableString(data.courtRef),
+    playbackUrl: nullableString(data.playbackUrl),
+    whepUrl: nullableString(data.whepUrl),
+    watchUrl: nullableString(data.watchUrl),
+    reused: data.reused,
+    cameraGrant: validateCameraGrant(data.cameraGrant)
+  };
+}
+function validateLegacyEnd(value) {
+  const data = record(value);
+  if (data.ok !== true || data.status !== "ended") invalid();
+  return { status: "ended" };
+}
 function validateRefresh(value) {
   const data = record(value);
   return {
@@ -320,6 +373,7 @@ function validateSession(value) {
     matchRef: nullableString(data.matchRef),
     playbackUrl: nullableString(data.playbackUrl),
     watchUrl: nullableString(data.watchUrl),
+    whepUrl: nullableString(data.whepUrl),
     scheduledAt: nullableNumber(data.scheduledAt),
     startedAt: nullableNumber(data.startedAt),
     endedAt: nullableNumber(data.endedAt),
@@ -350,6 +404,29 @@ function validateRecordings(value, sessionId) {
   if (!Array.isArray(value)) invalid();
   return value.map((item) => validateRecording(item, sessionId));
 }
+function validateDeviceRegister(value) {
+  const data = record(value);
+  const heartbeatIntervalMs = finite(data.heartbeatIntervalMs);
+  if (heartbeatIntervalMs <= 0) invalid();
+  return {
+    deviceId: nonblank(data.deviceId),
+    heartbeatIntervalMs
+  };
+}
+function validateDeviceHeartbeat(value) {
+  const data = record(value);
+  if (data.controlSession === null || data.controlSession === void 0) {
+    return { controlSession: null };
+  }
+  const grant = record(data.controlSession);
+  return {
+    controlSession: {
+      id: nonblank(grant.id),
+      token: nonblank(grant.token),
+      convexUrl: nonblank(grant.convexUrl)
+    }
+  };
+}
 
 // src/contracts.ts
 var SDK_TELEMETRY_EVENT_NAMES = [
@@ -495,7 +572,23 @@ async function readBoundedResponseText(response) {
   }
   return new TextDecoder().decode(bytes);
 }
-async function decodeResponse(response, apiKey, validate) {
+function parsePartnerError(payload, status, apiKey) {
+  if (!isRecord(payload) || !("error" in payload)) {
+    return new PickleballInvalidResponseError();
+  }
+  if (isRecord(payload.error)) {
+    return parseSdkError(payload, status, apiKey);
+  }
+  if (typeof payload.error !== "string") return new PickleballInvalidResponseError();
+  const { error, code, ...details } = payload;
+  const safeMessage = apiKey === "" ? error : error.split(apiKey).join("[REDACTED]");
+  const partnerCode = typeof code === "string" && code.trim() !== "" ? code : `HTTP_${status}`;
+  return new PickleballPartnerApiError(safeMessage, partnerCode, status, details);
+}
+async function decodeResponse(response, apiKey, validate, options = {
+  errorStyle: "sdk",
+  envelope: "data"
+}) {
   if (response.status >= 300 && response.status < 400) {
     await response.body?.cancel().catch(() => void 0);
     throw new PickleballHttpError(response.status);
@@ -507,7 +600,10 @@ async function decodeResponse(response, apiKey, validate) {
   } catch {
     throw new PickleballInvalidResponseError();
   }
-  if (!response.ok) throw parseSdkError(payload, response.status, apiKey);
+  if (!response.ok) {
+    throw options.errorStyle === "v1" ? parsePartnerError(payload, response.status, apiKey) : parseSdkError(payload, response.status, apiKey);
+  }
+  if (options.envelope === "raw") return validate(payload);
   if (!isRecord(payload) || !("data" in payload)) {
     throw new PickleballInvalidResponseError();
   }
@@ -515,7 +611,15 @@ async function decodeResponse(response, apiKey, validate) {
 }
 function createPickleballLiveClient(options) {
   const baseUrl = validatedBaseUrl(options.baseUrl);
-  const appId = requiredNonblank(options.appId, "appId");
+  const configuredAppId = options.appId === void 0 ? null : requiredNonblank(options.appId, "appId");
+  const requireAppId = () => {
+    if (configuredAppId === null) {
+      throw new PickleballConfigurationError(
+        "appId is required for /api/v2/sdk operations (apps/sessions/devices)"
+      );
+    }
+    return configuredAppId;
+  };
   const apiKey = requiredNonblank(options.apiKey, "apiKey");
   const fetchImplementation = options.fetch ?? globalThis.fetch;
   if (typeof fetchImplementation !== "function") {
@@ -528,7 +632,9 @@ function createPickleballLiveClient(options) {
     path,
     body,
     retryPolicy,
-    validate
+    validate,
+    errorStyle = "sdk",
+    envelope = "data"
   }) {
     const retryLimit = retryPolicy === "transient" ? maxRetries : 0;
     for (let attempt = 0; attempt <= retryLimit; attempt += 1) {
@@ -549,14 +655,14 @@ function createPickleballLiveClient(options) {
           } : {
             accept: "application/json",
             "x-api-key": apiKey,
-            "x-pickleball-app-id": appId
+            ...configuredAppId === null ? {} : { "x-pickleball-app-id": configuredAppId }
           },
           ...body === void 0 ? {} : { body: JSON.stringify(body) },
           signal: controller.signal,
           redirect: "error"
         });
         try {
-          return await decodeResponse(response, apiKey, validate);
+          return await decodeResponse(response, apiKey, validate, { errorStyle, envelope });
         } catch (error) {
           if (isTransientStatus(response.status) && attempt < retryLimit && isRetryableResponseError(error)) {
             clearTimeout(timer);
@@ -568,7 +674,7 @@ function createPickleballLiveClient(options) {
           throw error;
         }
       } catch (error) {
-        if (error instanceof PickleballApiError || error instanceof PickleballHttpError || error instanceof PickleballInvalidResponseError) {
+        if (error instanceof PickleballApiError || error instanceof PickleballPartnerApiError || error instanceof PickleballHttpError || error instanceof PickleballInvalidResponseError) {
           throw error;
         }
         if (attempt < retryLimit) {
@@ -587,54 +693,115 @@ function createPickleballLiveClient(options) {
   const post = (path, body, retryPolicy, validate) => request({ method: "POST", path, body, retryPolicy, validate });
   const get = (path, validate) => request({ method: "GET", path, retryPolicy: "transient", validate });
   const sessionPath = (sessionId) => `/api/v2/sdk/sessions/${encodeURIComponent(sessionId)}`;
+  const v1SessionPath = (sessionId) => `/api/v1/live-sessions/${encodeURIComponent(sessionId)}`;
+  const postV1 = (path, body, retryPolicy, validate, envelope = "data") => request({ method: "POST", path, body, retryPolicy, validate, errorStyle: "v1", envelope });
+  const getV1 = (path, validate) => request({ method: "GET", path, retryPolicy: "transient", validate, errorStyle: "v1" });
   return {
     apps: {
-      bootstrap: (input) => post(
+      bootstrap: async (input) => post(
         "/api/v2/sdk/bootstrap",
-        { ...input, appId },
+        { ...input, appId: requireAppId() },
         "transient",
         validateBootstrap
       )
     },
     sessions: {
-      start: (input) => post(
+      start: async (input) => post(
         "/api/v2/sdk/sessions",
-        { ...input, appId },
+        { ...input, appId: requireAppId() },
         "transient",
         validateGrant
       ),
-      refresh: (sessionId, input) => post(
+      refresh: async (sessionId, input) => post(
         `${sessionPath(sessionId)}/refresh`,
-        { ...input, appId },
+        { ...input, appId: requireAppId() },
         "never",
         validateRefresh
       ),
       end: async (input) => {
         await post(
           `${sessionPath(input.sessionId)}/end`,
-          { ...input, appId },
+          { ...input, appId: requireAppId() },
           "transient",
           (value) => validateEnd(value, input.sessionId)
         );
       },
-      publish: (sessionId) => post(
+      publish: async (sessionId) => post(
         `${sessionPath(sessionId)}/publish`,
-        { sessionId, appId },
+        { sessionId, appId: requireAppId() },
         "transient",
         (value) => validatePublishState(value, sessionId)
       ),
-      unpublish: (sessionId) => post(
+      unpublish: async (sessionId) => post(
         `${sessionPath(sessionId)}/unpublish`,
-        { sessionId, appId },
+        { sessionId, appId: requireAppId() },
         "transient",
         (value) => validatePublishState(value, sessionId)
       ),
-      get: (sessionId) => get(sessionPath(sessionId), validateSession),
-      getRecordings: (sessionId) => get(
-        `${sessionPath(sessionId)}/recordings`,
+      get: async (sessionId) => {
+        requireAppId();
+        return get(sessionPath(sessionId), validateSession);
+      },
+      getRecordings: async (sessionId) => {
+        requireAppId();
+        return get(
+          `${sessionPath(sessionId)}/recordings`,
+          (value) => validateRecordings(value, sessionId)
+        );
+      }
+    },
+    liveSessions: {
+      createCameraSession: (input) => postV1(
+        "/api/v1/live-sessions",
+        {
+          title: input.title,
+          matchRef: input.matchRef,
+          cameraGrant: true,
+          deliveryMode: "device-rtmp",
+          ...input.visibility === void 0 ? {} : { visibility: input.visibility },
+          ...input.description === void 0 ? {} : { description: input.description },
+          ...input.quality === void 0 ? {} : { quality: input.quality },
+          ...input.courtRef === void 0 ? {} : { courtRef: input.courtRef }
+        },
+        // Idempotent theo (host, matchRef): gọi lại chỉ cấp grant mới, an toàn để retry.
+        "transient",
+        validateCameraSessionCreated
+      ),
+      cameraGrant: (sessionId) => postV1(
+        `${v1SessionPath(sessionId)}/camera-grant`,
+        {},
+        "transient",
+        validateCameraGrant
+      ),
+      end: (sessionId) => postV1(
+        `${v1SessionPath(sessionId)}/end`,
+        {},
+        "transient",
+        validateLegacyEnd,
+        "raw"
+      ),
+      get: (sessionId) => getV1(v1SessionPath(sessionId), validateSession),
+      getRecordings: (sessionId) => getV1(
+        `${v1SessionPath(sessionId)}/recordings`,
         (value) => validateRecordings(value, sessionId)
       )
     },
+    devices: {
+      register: async (input) => post(
+        "/api/v2/sdk/devices/register",
+        { ...input, appId: requireAppId() },
+        "transient",
+        validateDeviceRegister
+      ),
+      heartbeat: async (input) => post(
+        "/api/v2/sdk/devices/heartbeat",
+        { ...input, appId: requireAppId() },
+        // Heartbeat có side effect trao token 1 lần — không retry để tránh
+        // nhận token đã bị đánh dấu delivered ở lần trước
+        "never",
+        validateDeviceHeartbeat
+      )
+    },
     webhooks: { verify: verifyWebhook }
   };
 }
@@ -646,6 +813,7 @@ function createPickleballLiveClient(options) {
   PickleballInvalidResponseError,
   PickleballLiveError,
   PickleballNetworkError,
+  PickleballPartnerApiError,
   PickleballTimeoutError,
   PickleballWebhookVerificationError,
   SDK_TELEMETRY_EVENT_NAMES,

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 type SdkErrorCode = "PERMISSION_DENIED" | "NETWORK_UNAVAILABLE" | "TOKEN_EXPIRED" | "SDK_UPGRADE_REQUIRED" | "SESSION_CONFLICT" | "RECORDING_FAILED" | "CONSENT_REQUIRED" | "SDK_DISABLED" | "UNKNOWN";
-type ServerSdkErrorCode = SdkErrorCode | "CONFIGURATION_ERROR" | "TIMEOUT" | "NETWORK_ERROR" | "HTTP_ERROR" | "INVALID_RESPONSE" | "WEBHOOK_VERIFICATION_FAILED";
+type ServerSdkErrorCode = SdkErrorCode | "CONFIGURATION_ERROR" | "TIMEOUT" | "NETWORK_ERROR" | "HTTP_ERROR" | "INVALID_RESPONSE" | "PARTNER_API_ERROR" | "WEBHOOK_VERIFICATION_FAILED";
 declare class PickleballLiveError extends Error {
     readonly code: ServerSdkErrorCode;
     constructor(message: string, code: ServerSdkErrorCode, options?: ErrorOptions);
@@ -13,6 +13,19 @@ declare class PickleballApiError extends PickleballLiveError {
     /** Stable allowlisted code. Unknown server codes are normalized to UNKNOWN. */
     code: SdkErrorCode, status: number);
 }
+/**
+ * Lỗi của REST v1 (đường đối tác: /api/v1/live-sessions, camera grant). Thân
+ * lỗi là `{error, code, ...extra}` — `partnerCode` là mã máy đọc (VD
+ * COURT_HAS_DEVICE, CAPACITY, SESSION_EXPIRED), `details` là các field kèm
+ * (activeSessionId, deviceId, retryAfterMs, retryable…). Đối tác switch theo
+ * `partnerCode`, KHÔNG parse message.
+ */
+declare class PickleballPartnerApiError extends PickleballLiveError {
+    readonly partnerCode: string;
+    readonly status: number;
+    readonly details: Record<string, unknown>;
+    constructor(message: string, partnerCode: string, status: number, details?: Record<string, unknown>);
+}
 declare class PickleballHttpError extends PickleballLiveError {
     readonly status: number;
     constructor(status: number);
@@ -66,6 +79,13 @@ interface StartLivestreamInput {
      * "scheduled" và KHÔNG khởi động recording egress cho tới khi publish.
      */
     standby?: boolean;
+    /**
+     * Độ phân giải app THỰC SỰ quay, để server ghi đúng vào phiên. Chỉ app biết
+     * con số này: nó là lựa chọn local và app còn override `config.videoQuality`
+     * mà server trả về. Không khai thì server dùng mặc định của nó (1080) và bản
+     * ghi phiên nói dối.
+     */
+    quality?: 720 | 1080;
 }
 interface SdkTelemetryCredentials {
     endpoint: string;
@@ -96,6 +116,64 @@ interface SdkPublishState {
     sessionId: string;
     status: "scheduled" | "live";
 }
+type CameraGrantStatus = "scheduled" | "live";
+/**
+ * Camera grant — điện thoại của user ĐỐI TÁC lên sóng (ADR-0002). Backend đối
+ * tác nhận từ REST v1 (POST /api/v1/live-sessions {cameraGrant:true} hoặc
+ * POST /api/v1/live-sessions/{id}/camera-grant) và chuyển NGUYÊN TRẠNG cho app;
+ * app dùng `telemetry.token` làm Bearer với namespace /api/v2/camera/sessions.
+ *
+ * Superset nghiêm ngặt của SdkSessionGrant: `serverUrl` là RTMP ingest
+ * (`rtmp://host:1935/`), `participantToken` là stream key — SDK 0.2 đã nhận
+ * hình dạng này qua isSessionGrant nên không cần validator mới ở lớp engine.
+ */
+interface CameraGrant extends SdkSessionGrant {
+    /** Không bao giờ "ended" — endpoint trả 409 thay vì grant. */
+    status: CameraGrantStatus;
+    matchRef: string | null;
+    courtRef: string | null;
+    watchUrl: string | null;
+    /**
+     * Origin websocket Convex (https://<dep>.convex.cloud) để SDK subscribe lệnh
+     * thay vì poll HTTP 2s; null khi deployment không lộ origin chuẩn → SDK poll.
+     */
+    convexUrl: string | null;
+    issuedAt: number;
+    /**
+     * Hạn dùng của grant. Phiên chờ mà app CHƯA từng kết nối bị dọn sau 30 phút
+     * (RTMP_STANDBY_SILENT_MS) — xin grant đúng lúc user mở camera, đừng cấp sớm
+     * hàng giờ trước trận.
+     */
+    expiresAt: number;
+}
+/** Thân POST /api/v1/live-sessions với cameraGrant:true (phiên điện thoại đối tác). */
+interface CreateCameraSessionInput {
+    /** Định danh trận phía đối tác — phiên khoá theo trận, gọi lại cùng matchRef là idempotent. */
+    matchRef: string;
+    title: string;
+    visibility?: SessionVisibility;
+    description?: string;
+    /** Độ phân giải app sẽ quay; mặc định 720 cho điện thoại. */
+    quality?: 720 | 1080;
+    /** Đậu phiên vào sân giải để dùng match-start/match-end như camera cố định. */
+    courtRef?: string;
+}
+/** Phản hồi tạo phiên điện thoại: phiên + grant chuyển cho app. */
+interface CameraSessionCreated {
+    id: string;
+    status: SessionStatus;
+    visibility: SessionVisibility;
+    quality: number;
+    deliveryMode: string;
+    matchRef: string | null;
+    courtRef: string | null;
+    playbackUrl: string | null;
+    whepUrl: string | null;
+    watchUrl: string | null;
+    /** true = phiên cũ cùng matchRef còn sống được dùng lại (grant vẫn MỚI). */
+    reused: boolean;
+    cameraGrant: CameraGrant;
+}
 type SessionStatus = "scheduled" | "live" | "ended";
 type SessionVisibility = "public" | "private";
 type RecordingType = "clean" | "derived" | "device";
@@ -108,6 +186,11 @@ interface ApiLiveSession {
     playbackUrl: string | null;
     /** Link trang xem web (`/watch/{id}`); null nếu chưa cấu hình WEB_PUBLIC_BASE_URL. */
     watchUrl: string | null;
+    /**
+     * Endpoint WebRTC/WHEP độ trễ <1s — chỉ khác null khi phiên ĐANG live ở mode
+     * device-rtmp. Chết ngay khi phiên kết thúc, đừng lưu; null = dùng playbackUrl.
+     */
+    whepUrl: string | null;
     scheduledAt: number | null;
     startedAt: number | null;
     endedAt: number | null;
@@ -126,6 +209,46 @@ interface ApiRecording {
 type StartSdkSessionInput = BootstrapInput & StartLivestreamInput & {
     idempotencyKey: string;
 };
+/** Thông tin thiết bị kèm khi đăng ký (từ expo-device). */
+interface DeviceInfoInput {
+    appVersion?: string;
+    deviceName?: string;
+    deviceModel?: string;
+    osVersion?: string;
+}
+interface DeviceMetricsInput {
+    ramFreeMb?: number;
+    ramTotalMb?: number;
+    storageFreeGb?: number;
+    batteryPct?: number;
+    batteryTempC?: number;
+    thermal?: number;
+    netType?: string;
+    linkMbps?: number;
+    rssi?: number;
+    connQuality?: string;
+}
+interface DeviceRegisterResult {
+    deviceId: string;
+    heartbeatIntervalMs: number;
+}
+interface DeviceHeartbeatInput {
+    /** Trạng thái engine hiện tại (idle|standby|live|...). */
+    agentState?: string;
+    /** Id phiên live đang giữ — null = không có phiên (server clear link). */
+    currentSessionId?: string | null;
+    appVersion?: string;
+    metrics?: DeviceMetricsInput;
+}
+/** Kênh điều khiển được dashboard yêu cầu — app dùng token mở Convex websocket. */
+interface DeviceControlSessionGrant {
+    id: string;
+    token: string;
+    convexUrl: string;
+}
+interface DeviceHeartbeatResult {
+    controlSession: DeviceControlSessionGrant | null;
+}
 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 {
@@ -149,9 +272,20 @@ interface LivestreamSessionProvider {
     unpublish?(sessionId: string): Promise<void>;
 }
 type LivestreamState = "idle" | "preparing" | "preview" | "connecting" | "standby" | "live" | "reconnecting" | "ending" | "ended" | "error";
+/**
+ * Vì sao 409 SESSION_CONFLICT bị nhận trên namespace /api/v2/camera — mirror
+ * của packages/shared (type-test Equal ghim): superseded = grant bị grant mới
+ * thay (app dừng tại chỗ), ended = phiên đã kết thúc, expired = quá trần
+ * thời lượng credential (xin grant/phiên mới).
+ */
+type SdkConflictReason = "superseded" | "ended" | "expired";
 interface SdkError {
     code: SdkErrorCode;
     message: string;
+    /** Chỉ có ở 409 SESSION_CONFLICT của namespace /api/v2/camera. */
+    reason?: SdkConflictReason;
+    /** Chỉ có ở 429 — cùng số với header `Retry-After` (giây, làm tròn lên). */
+    retryAfterMs?: number;
 }
 
 type WebhookRawBody = string | Uint8Array;
@@ -178,7 +312,11 @@ declare function verifyWebhook<T extends WebhookPayload = WebhookPayload>(rawBod
 
 interface PickleballLiveClientOptions {
     baseUrl: string;
-    appId: string;
+    /**
+     * Chỉ cần cho các thao tác `/api/v2/sdk/*` (mô hình proxy cũ). Đường
+     * `liveSessions.*` (camera grant, REST v1) không dùng appId — bỏ trống được.
+     */
+    appId?: string;
     apiKey: string;
     fetch?: typeof globalThis.fetch;
     timeoutMs?: number;
@@ -186,21 +324,48 @@ interface PickleballLiveClientOptions {
 }
 interface PickleballLiveClient {
     apps: {
+        /** @deprecated Mô hình proxy SDK v2 — dùng `liveSessions.createCameraSession` (ADR-0002). */
         bootstrap(input: BootstrapInput): Promise<SdkBootstrap>;
     };
     sessions: {
+        /** @deprecated Mô hình proxy SDK v2 — dùng `liveSessions.createCameraSession` (ADR-0002). */
         start(input: StartSdkSessionInput): Promise<SdkSessionGrant>;
+        /** @deprecated Mô hình proxy SDK v2 — app tự refresh bằng Bearer grant ở /api/v2/camera. */
         refresh(sessionId: string, input: BootstrapInput): Promise<SdkSessionRefresh>;
+        /** @deprecated Mô hình proxy SDK v2 — dùng `liveSessions.end`. */
         end(input: EndLivestreamInput): Promise<void>;
+        /** @deprecated Mô hình proxy SDK v2 — app tự publish bằng Bearer grant ở /api/v2/camera. */
         publish(sessionId: string): Promise<SdkPublishState>;
+        /** @deprecated Mô hình proxy SDK v2 — app tự unpublish bằng Bearer grant ở /api/v2/camera. */
         unpublish(sessionId: string): Promise<SdkPublishState>;
         get(sessionId: string): Promise<ApiLiveSession>;
         getRecordings(sessionId: string): Promise<ApiRecording[]>;
     };
+    /**
+     * REST v1 — đường của backend đối tác (x-api-key), không cần appId.
+     * Camera grant (ADR-0002): tạo phiên theo matchRef rồi chuyển `cameraGrant`
+     * nguyên trạng cho app; app dùng @pickleball/expo-sdk nói thẳng với Picklive.
+     */
+    liveSessions: {
+        /** POST /api/v1/live-sessions {cameraGrant:true} — idempotent theo (host, matchRef). */
+        createCameraSession(input: CreateCameraSessionInput): Promise<CameraSessionCreated>;
+        /** POST /api/v1/live-sessions/{id}/camera-grant — cấp lại grant, thu hồi grant cũ. */
+        cameraGrant(sessionId: string): Promise<CameraGrant>;
+        /** POST /api/v1/live-sessions/{id}/end — kết thúc phiên từ backend đối tác. */
+        end(sessionId: string): Promise<{
+            status: "ended";
+        }>;
+        get(sessionId: string): Promise<ApiLiveSession>;
+        getRecordings(sessionId: string): Promise<ApiRecording[]>;
+    };
+    devices: {
+        register(input: BootstrapInput & DeviceInfoInput): Promise<DeviceRegisterResult>;
+        heartbeat(input: BootstrapInput & DeviceHeartbeatInput): Promise<DeviceHeartbeatResult>;
+    };
     webhooks: {
         verify<T extends WebhookPayload = WebhookPayload>(rawBody: WebhookRawBody, headers: WebhookHeaders, secret: string, options?: VerifyWebhookOptions): Promise<VerifiedWebhook<T>>;
     };
 }
 declare function createPickleballLiveClient(options: PickleballLiveClientOptions): PickleballLiveClient;
 
-export { type ApiLiveSession, type ApiRecording, type BootstrapInput, type EndLivestreamInput, type LivestreamSessionProvider, type LivestreamState, PickleballApiError, PickleballConfigurationError, PickleballHttpError, PickleballInvalidResponseError, type PickleballLiveClient, type PickleballLiveClientOptions, PickleballLiveError, PickleballNetworkError, PickleballTimeoutError, PickleballWebhookVerificationError, type RecordingType, SDK_TELEMETRY_EVENT_NAMES, type SdkBootstrap, type SdkError, type SdkErrorCode, type SdkPublishState, type SdkRemoteConfig, type SdkSessionGrant, type SdkSessionRefresh, type SdkTelemetryCredentials, type SdkTelemetryEvent, type SdkTelemetryEventName, type ServerSdkErrorCode, type SessionStatus, type SessionVisibility, type StartLivestreamInput, type StartSdkSessionInput, type VerifiedWebhook, type VerifyWebhookOptions, type WebhookHeaders, type WebhookPayload, type WebhookRawBody, createPickleballLiveClient, verifyWebhook };
+export { type ApiLiveSession, type ApiRecording, type BootstrapInput, type CameraGrant, type CameraGrantStatus, type CameraSessionCreated, type CreateCameraSessionInput, type DeviceControlSessionGrant, type DeviceHeartbeatInput, type DeviceHeartbeatResult, type DeviceInfoInput, type DeviceMetricsInput, type DeviceRegisterResult, type EndLivestreamInput, type LivestreamSessionProvider, type LivestreamState, PickleballApiError, PickleballConfigurationError, PickleballHttpError, PickleballInvalidResponseError, type PickleballLiveClient, type PickleballLiveClientOptions, PickleballLiveError, PickleballNetworkError, PickleballPartnerApiError, PickleballTimeoutError, PickleballWebhookVerificationError, type RecordingType, SDK_TELEMETRY_EVENT_NAMES, type SdkBootstrap, type SdkConflictReason, type SdkError, type SdkErrorCode, type SdkPublishState, type SdkRemoteConfig, type SdkSessionGrant, type SdkSessionRefresh, type SdkTelemetryCredentials, type SdkTelemetryEvent, type SdkTelemetryEventName, type ServerSdkErrorCode, type SessionStatus, type SessionVisibility, type StartLivestreamInput, type StartSdkSessionInput, type VerifiedWebhook, type VerifyWebhookOptions, type WebhookHeaders, type WebhookPayload, type WebhookRawBody, createPickleballLiveClient, verifyWebhook };