@mega-yfue/eufy-sdk 0.5.0-beta.20 → 0.5.0-beta.22

package/dist/model/capabilities/arming.d.ts

@@ -79,7 +79,8 @@ export declare const ARMING_CMD: {
      */
     readonly SET_ARMING: 1224;
     /**
-     * The per-mode alarm/arm-delay configuration write. ✅ WIRE CAPTURED live on a T8030 (
+     * One guard mode's per-device action table (app `CMD_SET_ALL_ACTION`), which carries the alarm delays
+     * and each device's actions in that mode. ✅ WIRE CAPTURED live on a T8030 (
      * 2026-07-23, both directions): a **bare
      * JSON frame, no `1350`/`1700` envelope** — outer P2P cmd IS `1255` itself, station channel 255,
      * plaintext `{account_id, count_down_alarm:{channel_list,delay_time},
@@ -96,15 +97,23 @@ export declare const ARMING_CMD: {
      * corresponding GET command (`1310`/inner cmd `40003`, sent by the app right before editing) always
      * replied `{count:0,data:null}` in every capture — genuinely empty, not a decrypt failure (confirmed
      * via the same bidirectional decrypt this finding used) — so the app does NOT read the current
-     * config this way; how it does is still unknown. Without a working GET, safely PATCHING just one
-     * channel in or out of an existing list isn't possible without risking clobbering the rest — so
+     * config this way; a T8010 reports it on its own params instead, see below. Without a working GET,
+     * safely PATCHING just one channel in or out of an existing list isn't possible without risking
+     * clobbering the rest — so
      * this ships as a caller-supplies-everything write instead of guessing a merge.
      * `devices`/`siren_sensor_action` are even less understood (raw per-device action codes, meaning
      * unconfirmed) and MUST come from a value independently read/captured for the target mode —
      * see `AlarmDelayConfig`'s field docs.
+     *
+     * ✅ On a T8010 the app writes the same command for the Device Control screen: header channel 0, the
+     * whole table of the mode `{mode_id, devices, count_down_alarm, count_down_arm}`, acked by an all-zero
+     * 1255 reply. The T8010 reports each table on its own params, Home on 1157 and Away on 1158, and the
+     * reported table follows a write within 15 s. See {@link DEVICE_NOTIFY_FLAG}.
      */
-    readonly ALARM_DELAY_CONFIG: 1255;
+    readonly SET_ALL_ACTION: 1255;
 };
+/** The guard modes whose device notification is read and written: both replayed on a T8010. */
+export type DeviceNotificationMode = Extract<AlarmDelayMode, "home" | "away">;
 /**
  * Alarm-delay durations the app's OWN picker UI offers — `AlarmDelaySeconds` is both the const
  * value-object (`AlarmDelaySeconds.sec45`) and the union type of its values, so callers pass the
@@ -225,6 +234,24 @@ export declare const ARMING_MEMBERS: {
      * would be the same unverified guess `setMode` refuses.
      */
     readonly setAlarmDelayConfig: import("./members.js").MethodMember<(mode: AlarmDelayMode, config: AlarmDelayConfig) => Promise<void>>;
+    /**
+     * Whether the device on `channel` sends a push notification in `mode`: its {@link DEVICE_NOTIFY_FLAG}
+     * in the action table the station reports for that mode. `undefined` where the station reports no table
+     * or the table does not list `channel`. A device's channel is `EufyDevice.channel`.
+     */
+    readonly deviceNotification: import("./members.js").MethodMember<(mode: DeviceNotificationMode, channel: number) => boolean | undefined> & {
+        available: (ctx: CommandContext) => boolean;
+    };
+    /**
+     * Turn the push notification of the device on `channel` on or off in `mode` (cmd
+     * {@link ARMING_CMD.SET_ALL_ACTION}): the station's reported table written back with that one flag
+     * changed. Rejects, sending nothing, where the table does not list `channel`. A write builds on the last
+     * one sent for that mode until the station reports a table observed 15 s after it, so a second write does
+     * not revert it; a write whose dispatch rejects is not built on.
+     */
+    readonly setDeviceNotification: import("./members.js").MethodMember<(mode: DeviceNotificationMode, channel: number, on: boolean) => Promise<void>> & {
+        available: (ctx: CommandContext) => boolean;
+    };
 };
 /**
  * `arming` — guard/arming mode. `armingMode` (see {@link ARMING_CMD.SET_ARMING}) has a verified read/write

package/dist/model/classify.d.ts

@@ -56,8 +56,7 @@ export declare function codecForType(deviceType: number): Codec | undefined;
  *  - `T74xx` → **lock** (SmartSafe 7400-series).
  *  - `T80xx` / `T8001` / `T8002` / `T8010` / `T8030` / `T8023` / `T8025` → **station**
  *    (HomeBase / HomeBase 2 / 3 / Mini), `T9000` (the app's own model registry files it as family
- *    `STATION_9000`, the one station family outside the T8 band), and `T8N00` (NVR) / `T8E00` (PoE
- *    NVR) → station.
+ *    `STATION_9000`, the one station family outside the T8 band), and `T8N00` (NVR) → station.
  *  - `T89xx` (entry/motion/water/siren sensors, e.g. T8900/T8910/T8920) → **sensor**.
  *  - `T87xx` keypad (`T8960`) → **keypad**.
  *  - any other `T8…` security T-code → **camera** (the default security family).

package/dist/model/device-family.d.ts

@@ -45,6 +45,8 @@ export declare const isFloodLight: (ctx: FamilyContext) => boolean;
 export declare const isHomeBase: (ctx: FamilyContext) => boolean;
 /** HomeBase S1 Pro (`STATION_9000`), the station the app drives over its WebRTC control channel. */
 export declare const isStation9000: (ctx: FamilyContext) => boolean;
+/** T8N00 NVR, identified by its reported model. */
+export declare const isNvrT8N00: (ctx: FamilyContext) => boolean;
 /** Wired doorbell (DeviceType.DOORBELL). */
 export declare const isWiredDoorbell: (ctx: FamilyContext) => boolean;
 /**

package/dist/transport/p2p/command-router.d.ts

@@ -695,7 +695,7 @@ export declare class P2PCommandRouter {
      * **`set-json-raw` intent** — bare JSON, no envelope: outer P2P cmd = `outerCmd` itself, plaintext
      * exactly `{account_id,...data}` (`session.sendRawLevel2` with no wrapper). Reversed from a live
      * capture of the app's own SET_SNOOZE_TIME (1271) frame — see `param-dictionary.ts`'s `1271` entry
-     * (`snoozeTime`); the alarm-delay config (1255, `arming.ts`'s `ARMING_CMD.ALARM_DELAY_CONFIG`) reuses
+     * (`snoozeTime`); the alarm-delay config (1255, `arming.ts`'s `ARMING_CMD.SET_ALL_ACTION`) reuses
      * the same bare-JSON shape.
      */
     private sendJsonRaw;

package/dist/transport/p2p/p2p-session.d.ts

@@ -611,6 +611,18 @@ export declare class P2PSession extends EventEmitter {
         accountId?: string;
         channel?: number;
     }): void;
+    /**
+     * Read a date-ranged page of `history_record_info` from the station. The reply's `data` array groups
+     * recording rows with companion tables; each group retains its `table_name` and `payload`.
+     * `startTime` is `"0"` for the newest page or the oldest row's `yyyyMMddHHmmss` cursor for older rows.
+     */
+    queryRecordPage(opts: {
+        accountId?: string;
+        startDate: string;
+        endDate: string;
+        startTime?: string;
+        count?: number;
+    }): Promise<unknown[]>;
     /**
      * Query one on-station table and answer its rows, once the reply is whole.
      *
@@ -618,13 +630,15 @@ export declare class P2PSession extends EventEmitter {
      * several frames whose decrypted text is a fragment of one document, so the fragments are
      * accumulated here and scanned after each one. Answers that document's `data` rows. Rejects when
      * `signal` aborts, and when `timeoutMs` (default {@link DB_TABLE_TIMEOUT_MS}) elapses with no
-     * complete reply.
+     * complete reply, and when the station answers a non-zero `mIntRet`.
      *
      * One read at a time per session: while one is accumulating, every {@link queryDatabase} on the
      * session throws, so a second reply cannot land in this buffer.
      */
     readDatabase(table: string, opts?: {
         accountId?: string;
+        innerCmd?: number;
+        query?: Record<string, unknown>;
         timeoutMs?: number;
         signal?: AbortSignal;
     }): Promise<unknown[]>;

package/dist/transport/p2p/recording-download.d.ts

@@ -46,9 +46,10 @@ export declare function receiveRecording(session: P2PSession, request: {
     signal?: AbortSignal;
 }): RecordingTransfer;
 /**
- * Decode a recording's frames, in arrival order, into elementary streams. Keyframes go through one
- * {@link VideoFrameDecoder}, whose media key then opens the audio; a keyframe that does not open under
- * `eccPrivateKeyHex`, and every audio frame before the first media key, are dropped. Rejects with
+ * Decode a recording's frames, in arrival order, into elementary streams. Split pictures are assembled
+ * before they enter the output; an orphan continuation cannot become its own picture. Keyframes go
+ * through one {@link VideoFrameDecoder}, whose media key then opens the audio; a keyframe that does not
+ * open under `eccPrivateKeyHex`, and every audio frame before the first media key, are dropped. Rejects with
  * {@link RecordingDownloadError} `undecodable` when no video frame decodes.
  */
 export declare function decodeRecording(frames: readonly RecordingFrame[], eccPrivateKeyHex: string): RecordingDownload;

package/dist/transport/rtc/command-router.d.ts

@@ -1,6 +1,5 @@
 /**
- * RTC command router: drives a **HomeBase S1 Pro (T9000)** over the portal's WebRTC data channel instead
- * of P2P.
+ * RTC command router: drives a station over the portal's WebRTC data channel instead of P2P.
  *
  * The T9000 answers no P2P lookup, but it accepts the portal's control channel: sign → WS join → scall →
  * SDP answer → ICE over the relay the hub grants → DTLS → SCTP data channels, with commands riding
@@ -26,6 +25,10 @@ export interface RtcIdentity {
 }
 /** Where a command goes: the station's session, and whether it addresses the station or a device on it. */
 export interface RtcRoute {
+    /** The station's signaling exchange; defaults to compact SDP. */
+    signalingMode?: "call" | "scall";
+    /** Candidate policy used by the station's exchange; defaults to relay-only. */
+    iceTransportPolicy?: "relay" | "all";
     stationSn: string;
     /**
      * The station's `member.admin_user_id`, the account the session and the payload name; the logged-in

package/dist/transport/rtc/peer.d.ts

@@ -7,7 +7,7 @@
  * then audio, idr, video, notify, download). Every one carries PTCS-framed portal packets; which logical
  * channel a reassembled frame belongs to is the PTCS header's channel, not the data channel it rode on.
  *
- * ICE is relay-only. The hub grants a TURN allocation in its `scall 100` reply and completes DTLS only
+ * ICE defaults to relay-only. The T9000 grants a TURN allocation in its `scall 100` reply and completes DTLS only
  * over the relay pair; on a host pair ICE connects and the DTLS handshake never completes. The peer
  * plays the DTLS client (`active`) and opens its channels on the client's even SCTP stream ids, which
  * is what the hub pairs with.
@@ -28,6 +28,8 @@ export interface TurnConfig {
 export type NativePeerFactory = (name: string, config: RtcConfig) => PeerConnection;
 export interface RtcPeerOptions {
     createPeer?: NativePeerFactory;
+    /** Candidate policy for the station's exchange; the default is relay-only. */
+    iceTransportPolicy?: "relay" | "all";
     logger?: Logger;
 }
 export interface RtcPeerEvents {
@@ -51,6 +53,7 @@ export declare class RtcPeer extends EventEmitter<RtcPeerEvents> {
     private readonly wireTally;
     private commandOpen;
     private remoteSet;
+    private remoteMid;
     private handlingOffer;
     private channelsCreated;
     private gatheringDone;

package/dist/transport/rtc/session.d.ts

@@ -50,7 +50,7 @@ export declare class RtcSession extends EventEmitter<RtcSessionEvents> {
     constructor(opts: RtcSessionOptions);
     get isConnected(): boolean;
     /**
-     * Start the sequence; resolves once `scall` is sent. `connected` fires when the channel opens. A session
+     * Start the sequence; resolves once the call is sent. `connected` fires when the channel opens. A session
      * closed by the time the sign fetch or the auth completes rejects instead of opening the socket or
      * placing the call.
      */

package/dist/transport/rtc/signaling.d.ts

@@ -68,6 +68,8 @@ export interface SignalingSocketInit {
 }
 export type SignalingSocketFactory = (url: string, init: SignalingSocketInit) => SignalingSocket;
 export interface RtcSignalingOptions {
+    /** Full SDP (`call`) or compact SDP (`scall`, the default). */
+    signalingMode?: "call" | "scall";
     /** The mega session's auth token. */
     authToken: string;
     /** The `gtoken` header value the mega session's authed HTTP calls carry. */
@@ -124,8 +126,8 @@ export declare class RtcSignalingClient extends EventEmitter<RtcSignalingEvents>
     sendSession(dataType: string, payload?: Record<string, unknown>): void;
     sendCall(): void;
     sendAck(): void;
-    /** The SDP answer, as scall JSON text, in an `info`. */
-    sendInfoSdp(scallJson: string): void;
+    /** The SDP answer, encoded for the negotiated call format, in an `info`. */
+    sendInfoSdp(sdp: string): void;
     /** Trickle a candidate on the session's channel, like its SDP answer. An empty candidate ends them. */
     sendInfoCandidate(candidate: string): void;
     sendHangup(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mega-yfue/eufy-sdk",
-  "version": "0.5.0-beta.20",
+  "version": "0.5.0-beta.22",
   "description": "One typed TypeScript client for the Anker eufy v6 cloud — capability-driven devices, realtime events over P2P/MQTT/push, and live media",
   "license": "Apache-2.0",
   "author": "mega-yfue",