@mega-yfue/eufy-sdk 0.5.0-beta.9 → 0.5.0-beta.90

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

@@ -76,10 +76,13 @@ export declare const ARMING_CMD: {
      * The ENCRYPTION LEVEL is the session's to pick (`"auto"`), not this command's: the T8030 the envelope
      * was captured on holds a level-2 key and seals it level-2, while an own-session camera that never
      * negotiates one carries the same envelope level-1. See `armingCommand`.
+     *
+     * A T8410C takes the mode as a direct frame instead of this envelope; see {@link DIRECT_ARMING_MODELS}.
      */
     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 +99,26 @@ 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. Home and away are replayed on a T8010;
+ * `custom1` (wire 3) is captured on a T8170, whose own params report it on 1148.
+ */
+export type DeviceNotificationMode = Extract<ArmingMode, "home" | "away" | "custom1">;
 /**
  * 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 +239,27 @@ 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 standalone camera answers from its own 1225/1239/1148 flags,
+     * for its own channel only. 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. A standalone camera is sent a one-entry `{mode_id, devices}` table built from its own flags,
+     * for its own channel only. Rejects, sending nothing, where the table does not list `channel`. A write
+     * builds on the last one sent for that mode until the device reports a table (`${mode}Action` on a
+     * standalone camera) 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/capabilities/battery.d.ts

@@ -122,6 +122,11 @@ export declare function cameraPowerTier(model: string | undefined, capabilities:
  * harvest to report either.
  */
 export declare const CELL_PARAMS: readonly number[];
+/**
+ * The app's charger-state decode: `charging = value ∉ {0,2}`. The app applies this one rule both to a
+ * camera's `BATTERY_STATUS` (2111) and to a keypad's `APP_CMD_KEYPAD_BATTERY_CHARGER_STATE` (1655).
+ */
+export declare function isChargingState(v: string | number | boolean): boolean;
 /**
  * Every `battery` feature, declared once — the property schema, the evidence-gated getters, the derived
  * setters, the intent routes and the descriptions all come out of this table. Order is schema order.
@@ -159,7 +164,7 @@ export declare const BATTERY_MEMBERS: {
         readonly type: "bool";
         readonly kind: "boolean";
         readonly provenance: "apk";
-        readonly coerce: (v: string | number | boolean) => boolean;
+        readonly coerce: typeof isChargingState;
         readonly description: string;
     };
     /**

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

@@ -1,3 +1,4 @@
+import { isCameraCodec } from "./access.js";
 import { type Surface } from "./members.js";
 import type { AvailabilityContext, CapabilityModule, CommandContext } from "./types.js";
 import { type Command, type MediaProvider } from "../../core/contracts.js";
@@ -8,6 +9,8 @@ import { type Command, type MediaProvider } from "../../core/contracts.js";
  * `transport/p2p/commands.ts`). Each entry notes its app `CommandType` name.
  */
 export declare const CAMERA_CMD: {
+    /** Camera-reported Wi-Fi signal (app `CMD_GET_WIFI_RSSI`). */
+    readonly WIFI_RSSI: 1142;
     /** Camera on/off. Read and write polarity depend on the family and topology. */
     readonly CAMERA_ENABLE: 1035;
     /** Wrapped T8410 power switch on HomeBase 3. */
@@ -46,6 +49,8 @@ export declare const CAMERA_CMD: {
      * (1013). (Some models omit full colour; enum in {@link NightVision}.)
      */
     readonly NIGHT_VISION_TYPE: 1277;
+    /** T8442 infrared night vision on/off: direct L1 int-string, hardware verified (0/1). */
+    readonly IC_NIGHT_VISION_TYPE: 1013;
     /**
      * Push-notification STYLE — how much a detection push carries: text alone, a thumbnail, or text
      * followed by a thumbnail. App `CMD_INDOOR_PUSH_NOTIFY_TYPE`, and the "indoor" is a misnomer: the
@@ -256,6 +261,8 @@ export type CameraActions = Surface<typeof CAMERA_MEMBERS> & {
     /** Power the camera off. */
     off(): Promise<void>;
 };
+/** T8442 has a binary night-vision wire, unlike cameras with the three-mode 1277 control. */
+declare function isT8442(ctx: AvailabilityContext): boolean;
 /**
  * Every `camera` feature, declared once. The property schema, the typed getters, the derived setters,
  * the intent routes, the media methods and the descriptions all come out of this table.
@@ -271,6 +278,14 @@ export type CameraActions = Surface<typeof CAMERA_MEMBERS> & {
  * @internal
  */
 export declare const CAMERA_MEMBERS: {
+    /** Reads the latest cached report and exposes no setter. */
+    readonly wifiRssi: {
+        readonly param: 1142;
+        readonly type: "number";
+        readonly kind: "scalar";
+        readonly provenance: "apk";
+        readonly description: "Camera-reported Wi-Fi signal; physical units and a quality scale are unspecified.";
+    };
     /**
      * The default READ is the *disable*-bit convention (1035 "0" ⇒ ON, 2001 direct); the WRITE polarity is
      * family-dependent — see `powerValue` / `isEnableBitPolarity`. Battery/solo cams report the state under
@@ -290,6 +305,7 @@ export declare const CAMERA_MEMBERS: {
         readonly type: "bool";
         readonly kind: "boolean";
         readonly provenance: "verified";
+        readonly available: typeof isCameraCodec;
         readonly invert: true;
         readonly invertFor: (ctx: AvailabilityContext) => false | undefined;
         readonly readAliases: readonly [{
@@ -324,6 +340,7 @@ export declare const CAMERA_MEMBERS: {
         readonly type: "bool";
         readonly kind: "boolean";
         readonly provenance: "apk";
+        readonly available: typeof isCameraCodec;
         readonly description: string;
         readonly write: (v: string | number | boolean, ctx: CommandContext) => Command;
     };
@@ -343,6 +360,7 @@ export declare const CAMERA_MEMBERS: {
             readonly 2: "Timestamp + Logo";
         };
         readonly provenance: "verified";
+        readonly available: typeof isCameraCodec;
         readonly description: string;
         readonly write: (v: string | number | boolean, ctx: CommandContext) => Command | undefined;
     };
@@ -356,6 +374,7 @@ export declare const CAMERA_MEMBERS: {
         readonly type: "bool";
         readonly kind: "boolean";
         readonly provenance: "verified";
+        readonly available: typeof isCameraCodec;
         readonly description: string;
         readonly write: (v: string | number | boolean, ctx: CommandContext) => Command;
     };
@@ -371,6 +390,7 @@ export declare const CAMERA_MEMBERS: {
         readonly type: "number";
         readonly kind: "scalar";
         readonly provenance: "verified";
+        readonly available: typeof isCameraCodec;
         readonly description: string;
         readonly write: (v: string | number | boolean, ctx: CommandContext) => Command | undefined;
     };
@@ -388,6 +408,7 @@ export declare const CAMERA_MEMBERS: {
             readonly 2: "All Sound";
         };
         readonly provenance: "verified";
+        readonly available: typeof isCameraCodec;
         readonly description: string;
         readonly write: (v: string | number | boolean, ctx: CommandContext) => Command | undefined;
     };
@@ -409,6 +430,7 @@ export declare const CAMERA_MEMBERS: {
             readonly 3: "Text First, Then Thumbnail";
         };
         readonly provenance: "verified";
+        readonly available: typeof isCameraCodec;
         readonly description: string;
         readonly write: (v: string | number | boolean, ctx: CommandContext) => Command | undefined;
     };
@@ -427,7 +449,17 @@ export declare const CAMERA_MEMBERS: {
             readonly 1: "Infrared";
             readonly 2: "Full Color";
         };
+        readonly enumValuesFor: (ctx: AvailabilityContext) => {
+            0: string;
+            1: string;
+        } | undefined;
         readonly provenance: "verified";
+        readonly available: typeof isCameraCodec;
+        readonly readAvailable: (ctx: AvailabilityContext) => boolean;
+        readonly readAliases: readonly [{
+            readonly paramType: 2002;
+            readonly available: typeof isT8442;
+        }];
         readonly description: string;
         readonly write: (v: string | number | boolean, ctx: CommandContext) => Command | undefined;
     };
@@ -435,25 +467,30 @@ export declare const CAMERA_MEMBERS: {
      * Live-view quality, the pair to {@link CAMERA_MEMBERS.recordingQuality} and a different setting on a
      * different wire: changing one leaves the other's parameter untouched.
      *
-     * The READ is 1020, which reports the resolved tier as a plain integer. 1020 is also the name the
-     * param dictionary already gives that id, and `Device` keys state by NAME — a member claiming 2730
-     * under this name would collide with it on a device reporting both.
+     * The READ is 1020, which reports the resolved tier as a plain integer, while the WRITE rides 2730's
+     * `1350` payload. They are two ids for one setting because 2730 carries a per-mode config and 1020
+     * carries the tier in force; the tier is what this property means. 1020 is also the name the param
+     * dictionary already gives that id, and `Device` keys state by NAME — a member claiming 2730 under
+     * this name would collide with it on a device reporting both.
      *
-     * `unverified: true` with no `write`: the app's 2730 frame is captured byte-exact, but replaying it
-     * from this SDK produced no observable change on a standalone T8171, where the recording sibling's
-     * 2731 write on the same envelope and the same session does land. The one difference the capture
-     * shows is that the app's frame carries no `mChannel`/`mValue3`, which this envelope always emits.
-     * Until a send is confirmed, the setter is absent — a control that silently does nothing is worse
-     * than none — and the read ships ahead of it, which verification per direction allows.
+     * `transaction` is part of the frame that was captured, so it is sent. The recording sibling's own
+     * confirmed frame carries no such field; neither is inferred from the other.
      */
     readonly streamingQuality: {
+        readonly accepts: StreamingQualityName;
         readonly param: 1020;
         readonly type: "number";
         readonly kind: "enum";
         readonly enumValues: Readonly<Record<number, string>>;
         readonly provenance: "verified";
-        readonly unverified: true;
+        readonly available: typeof isCameraCodec;
+        readonly args: readonly [{
+            readonly name: "quality";
+            readonly kind: "enum";
+            readonly description: "A tier, or the name it maps to. 0 is Auto.";
+        }];
         readonly description: string;
+        readonly write: (v: string | number | boolean, ctx: CommandContext) => Command | undefined;
     };
     /**
      * `type` is how the value is STORED, and 2731 stores the whole config — the ACTIVE tier is lifted out
@@ -465,6 +502,7 @@ export declare const CAMERA_MEMBERS: {
         readonly param: 2731;
         readonly type: "string";
         readonly provenance: "verified";
+        readonly available: typeof isCameraCodec;
         readonly decode: (raw: unknown) => number | undefined;
         readonly decodedKind: "enum";
         readonly decodedValues: number[];
@@ -486,6 +524,7 @@ export declare const CAMERA_MEMBERS: {
         readonly type: "bool";
         readonly kind: "boolean";
         readonly provenance: "apk";
+        readonly available: typeof isCameraCodec;
         readonly description: string;
         readonly requires: readonly [1015];
         readonly write: (v: string | number | boolean, ctx: CommandContext) => Command;
@@ -503,6 +542,7 @@ export declare const CAMERA_MEMBERS: {
         readonly kind: "boolean";
         readonly writeOnly: true;
         readonly provenance: "verified";
+        readonly available: typeof isCameraCodec;
         readonly description: "Privacy mode (PRIVACY_MODE 6250) — the multi-frame burst the sink plays.";
         readonly write: (v: string | number | boolean, ctx: CommandContext) => Command;
     };
@@ -516,6 +556,7 @@ export declare const CAMERA_MEMBERS: {
         readonly type: "bool";
         readonly kind: "boolean";
         readonly provenance: "verified";
+        readonly available: typeof isCameraCodec;
         readonly readAvailable: (ctx: AvailabilityContext) => boolean;
         readonly readAliases: readonly [{
             readonly paramType: 1716;
@@ -525,6 +566,7 @@ export declare const CAMERA_MEMBERS: {
         readonly description: "Camera status LED. Video doorbells report the same state under their button-ring LED parameter.";
         readonly write: (v: string | number | boolean, ctx: CommandContext) => Command;
     };
+    readonly views: import("./members.js").ProvidedMember<"media", (() => readonly number[]) | undefined>;
     /**
      * Media is not a property: it returns DATA rather than moving state, its options are richer than a
      * value, and it exists only on a device bound to a provider. Each is declared once, with its
@@ -542,21 +584,21 @@ export declare const CAMERA_MEMBERS: {
      * The refusal REJECTS on the four that answer with a promise, and THROWS on
      * {@link CAMERA_MEMBERS.recordFragments}, which answers with a handle.
      */
-    readonly snapshotStored: import("./members.js").ProvidedMember<"media", (() => Promise<Buffer<ArrayBufferLike>>) | undefined>;
-    readonly snapshotLive: import("./members.js").ProvidedMember<"media", (opts?: Parameters<MediaProvider["snapshotLive"]>[0]) => Promise<{
+    readonly snapshotStored: import("./members.js").ProvidedMember<"media", false | (() => Promise<Buffer<ArrayBufferLike>>) | undefined>;
+    readonly snapshotLive: import("./members.js").ProvidedMember<"media", false | ((opts?: Parameters<MediaProvider["snapshotLive"]>[0]) => Promise<{
         jpeg: Buffer;
         width: number;
         height: number;
         retained?: true;
-    }>>;
+    }>)>;
     readonly live: import("./members.js").ProvidedMember<"media", (opts?: Parameters<MediaProvider["live"]>[0]) => Promise<import("../../core/contracts.js").LiveStreamConsumer>>;
-    readonly record: import("./members.js").ProvidedMember<"media", (seconds: number, opts?: {
+    readonly record: import("./members.js").ProvidedMember<"media", false | ((seconds: number, opts?: {
         timeoutMs?: number;
         skipKeyframes?: number;
-    } | undefined) => Promise<Buffer<ArrayBufferLike>>>;
-    readonly openReadable: import("./members.js").ProvidedMember<"media", ((opts?: Parameters<NonNullable<MediaProvider["openReadable"]>>[0]) => Promise<import("node:stream").Readable>) | undefined>;
-    readonly recordFragments: import("./members.js").ProvidedMember<"media", ((opts?: Parameters<NonNullable<MediaProvider["recordFragments"]>>[0]) => import("../../core/contracts.js").FragmentRecordingHandle) | undefined>;
-    readonly downloadRecording: import("./members.js").ProvidedMember<"media", ((opts: Parameters<NonNullable<MediaProvider["downloadRecording"]>>[0]) => Promise<import("../../core/contracts.js").RecordingDownload>) | undefined>;
+    } | undefined) => Promise<Buffer<ArrayBufferLike>>)>;
+    readonly openReadable: import("./members.js").ProvidedMember<"media", false | ((opts?: Parameters<NonNullable<MediaProvider["openReadable"]>>[0]) => Promise<import("node:stream").Readable>) | undefined>;
+    readonly recordFragments: import("./members.js").ProvidedMember<"media", false | ((opts?: Parameters<NonNullable<MediaProvider["recordFragments"]>>[0]) => import("../../core/contracts.js").FragmentRecordingHandle) | undefined>;
+    readonly downloadRecording: import("./members.js").ProvidedMember<"media", false | ((opts: Parameters<NonNullable<MediaProvider["downloadRecording"]>>[0]) => Promise<import("../../core/contracts.js").RecordingDownload>) | undefined>;
     /**
      * Push audio from the host to this camera's speaker. Gated on the **speaker** param specifically —
      * not the `audio` capability, which resolves on a microphone alone and would advertise a speaker the
@@ -567,3 +609,4 @@ export declare const CAMERA_MEMBERS: {
     readonly talkback: import("./members.js").ProvidedMember<"media", false | ((opts?: Parameters<NonNullable<MediaProvider["talkback"]>>[0]) => Promise<import("../../core/contracts.js").TalkbackHandle>) | undefined>;
 };
 export declare const CAMERA: CapabilityModule;
+export {};

package/dist/model/capabilities/dp-catalog.d.ts

@@ -15,10 +15,11 @@
 /** The parsed DP capability catalog for one product SKU. */
 export interface DpCatalog {
     /**
-     * For enum-type DPs: the valid integer values as declared in the catalog.
-     * Absent for non-enum DPs (bool, raw, integer, string).
+     * For enum-type DPs: the range members exactly as the catalog lists them, as strings — value names
+     * (`"Quiet"`) or numeric strings (`"0"`), whichever the SKU's catalog uses. What a member means is
+     * the reading capability's to decide. Absent for non-enum DPs (bool, raw, integer, string).
      */
-    readonly enumRanges: ReadonlyMap<number, readonly number[]>;
+    readonly enumRanges: ReadonlyMap<number, readonly string[]>;
 }
 /** Returned whenever the API call fails or the response shape is not recognised. */
 export declare const EMPTY_DP_CATALOG: DpCatalog;

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

@@ -42,8 +42,11 @@ import type { VacuumCleanActions } from "./vacuum-clean.js";
 import type { VacuumDockActions } from "./vacuum-dock.js";
 import type { DisplayActions } from "./display.js";
 import type { SuctionActions } from "./suction.js";
+import type { MowerActions } from "./mower.js";
 import type { LocateActions } from "./locate.js";
+import type { SmartDropActions } from "./smart-drop.js";
 import type { DeviceInfo } from "./info.js";
+import type { CusPushAlarmType } from "../push-events.js";
 /**
  * Look up the {@link CapabilityModule} for a capability, or `undefined` if none is registered.
  * @internal
@@ -296,9 +299,13 @@ export interface DeviceEventMap {
      * can be known about a value nothing pushes.
      */
     cameraEnabledChanged: PushSemanticEvent;
-    /** Station alarm lifecycle; `phase` says whether it fired or is counting down. */
+    /**
+     * Station alarm lifecycle; `phase` says whether it fired, is counting down, or was stopped. `type` is
+     * the push's alarm source or stop reason, absent when the push carried none.
+     */
     alarm: PushSemanticEvent & {
-        phase?: "triggered" | "delayed";
+        phase?: "triggered" | "delayed" | "stopped";
+        type?: CusPushAlarmType;
     };
     /** Lock (un)locked or a lock alarm fired. */
     lockState: PushSemanticEvent;
@@ -411,7 +418,7 @@ export interface DeviceActionMap {
     smoke: SmokeActions;
     /** CO-detector reads (read-only): `coDetected`, `lastSeen`. */
     co: CoActions;
-    /** Security-keypad reads (read-only): `rssi`. */
+    /** Security-keypad reads (read-only): `charging`, `rssi`. */
     keypad: KeypadActions;
     /** RTSP publish for a NAS/NVR: `publish`/`withdraw` + `published`, `requireAuth`/`allowAnonymous`, `recordingMode`/`setRecordingMode`. One camera at a time per station. */
     rtsp: RtspActions;
@@ -421,8 +428,12 @@ export interface DeviceActionMap {
     vacuumDock: VacuumDockActions;
     /** RoboVac suction: `level`, `boostIq`, `supportedLevels`; `setSuctionLevel`, `setBoostIq`. */
     suction: SuctionActions;
+    /** Robot mower (read-only): `battery`, `cutHeight`, `network`, `wifiSignal`, wear timers and settings. No write is captured. */
+    mower: MowerActions;
     /** RoboVac locate (find-robot beep): `locating`; `locate(on?)`. */
     locate: LocateActions;
+    /** SmartDrop parcel box: `openLid()`. */
+    smartDrop: SmartDropActions;
     /** Smart Display (read-only): `battery`. No display write is captured. */
     display: DisplayActions;
     /** Identity metadata (read-only): `{ manufacturer, model, serialNumber, name, deviceType?, firmwareVersion?, hardwareVersion? }`. */
@@ -516,7 +527,7 @@ export type { ActionSpec } from "./types.js";
  * `undefined` for an action nothing describes.
  */
 export { actionSpecOf } from "./access.js";
-export type { PtzActions, LightActions, SmartLightActions, RgbColor, CameraActions, LockActions, SirenActions, ArmingActions, BatteryActions, MotionActions, ContactActions, LeakActions, SmokeActions, CoActions, KeypadActions, RtspActions, VacuumCleanActions, SuctionActions, LocateActions, };
+export type { PtzActions, LightActions, SmartLightActions, RgbColor, CameraActions, LockActions, SirenActions, ArmingActions, BatteryActions, MotionActions, ContactActions, LeakActions, SmokeActions, CoActions, KeypadActions, RtspActions, VacuumCleanActions, SuctionActions, MowerActions, LocateActions, SmartDropActions, };
 /**
  * The member table each `*Actions` type is DERIVED from (`LockActions = Surface<typeof LOCK_MEMBERS>`),
  * so the type names the table and the table is part of the published surface.
@@ -541,10 +552,12 @@ export { MOTION_MEMBERS } from "./motion.js";
 export { PTZ_MEMBERS } from "./ptz.js";
 export { RTSP_MEMBERS } from "./rtsp.js";
 export { SIREN_MEMBERS } from "./siren.js";
+export { SMART_DROP_MEMBERS } from "./smart-drop.js";
 export { SMART_LIGHT_MEMBERS } from "./smart-light.js";
 export { SMOKE_MEMBERS } from "./smoke.js";
 export { DISPLAY_MEMBERS, type DisplayActions } from "./display.js";
 export { SUCTION_MEMBERS } from "./suction.js";
+export { MOWER_MEMBERS } from "./mower.js";
 export { VACUUM_CLEAN_MEMBERS } from "./vacuum-clean.js";
 export type { DeviceInfo } from "./info.js";
 export type { AutoSpotlightOptions } from "./light.js";

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

@@ -1,13 +1,12 @@
+import { isChargingState } from "./battery.js";
 import { type Surface } from "./members.js";
 import type { CapabilityModule } from "./types.js";
 /**
- * Every `keypad` feature, declared once. Only `rssi` is a verified read.
+ * Every `keypad` feature, declared once. `rssi` is a verified read and `charging` follows the app's own
+ * decode of the keypad's charger state.
  *
- * The battery pair is `unexposed`: both ids are placeholders, and the keypad's real battery state is
- * reported under model-specific params (`keypadBatteryCapState` / `keypadBatteryChargerState`, seen
- * live) whose low/charging semantics are not confirmed. They stay in the schema so a diagnosis can
- * reach them through `getProperty`, with no typed getter asserting a meaning this SDK cannot back.
- * A live probe of the fleet's T8960 confirms neither is reported at all today.
+ * `batteryLow` is `unexposed`: the app maps its param to the same low-battery field the entry and motion
+ * sensors feed, but its value decode is absent from the app's parser, so the polarity is not evidenced.
  *
  * Exported but NOT published: each entry states its wire id and the evidence it was confirmed on,
  * which the reference site does not carry.
@@ -15,36 +14,34 @@ import type { CapabilityModule } from "./types.js";
  */
 export declare const KEYPAD_MEMBERS: {
     /**
-     * `unexposed`, so it reaches a diagnosis through `getProperty` but gets no typed getter. 1103 is a
-     * placeholder AND a likely collision — the app's own param table names 1103 GET_CAMERA_INFO — so a
-     * getter here would be asserting a meaning nothing backs. The keypad's real battery state arrives
-     * under `keypadBatteryCapState`, whose low/charging semantics are not confirmed.
+     * `APP_CMD_KEYPAD_BATTERY_CAP_STATE` (1653). The app's sensor parser maps it to `sensor_is_low_power`,
+     * the field `APP_CMD_ENTRY_SENSOR_BAT_STATE` and `APP_CMD_MOTION_SENSOR_BAT_STATE` decode as a boolean,
+     * yet gives 1653 itself no decode case. `unexposed` until a device confirms which value means low; in
+     * the schema for `getProperty`, absent from the typed surface.
      */
     readonly batteryLow: {
-        readonly param: 1103;
+        readonly param: 1653;
         readonly type: "bool";
         readonly kind: "boolean";
-        readonly provenance: "guessed";
+        readonly provenance: "apk";
         readonly unexposed: true;
         readonly description: string;
     };
     /**
-     * The charging half of the battery pair, `unexposed` for the same reason as `batteryLow`: 1102 is a
-     * placeholder id, and the state the keypad actually reports (`keypadBatteryChargerState`) has no
-     * confirmed value space. In the schema for `getProperty`, absent from the typed surface.
+     * `APP_CMD_KEYPAD_BATTERY_CHARGER_STATE` (1655), decoded the way the app's sensor parser decodes it:
+     * `charging = value ∉ {0,2}` ({@link isChargingState}).
      */
     readonly charging: {
-        readonly param: 1102;
+        readonly param: 1655;
         readonly type: "bool";
         readonly kind: "boolean";
-        readonly provenance: "guessed";
-        readonly unexposed: true;
-        readonly description: "Keypad charging flag. UNVERIFIED: placeholder id pending verification.";
+        readonly provenance: "apk";
+        readonly coerce: typeof isChargingState;
+        readonly description: string;
     };
     /**
-     * The keypad's link quality in dBm — the one verified read in this table, on the same param 1141 the
-     * other sub-1G sensors report signal strength on. Reported as the device measures it: raw dBm, never
-     * normalised to a bar count.
+     * The keypad's link quality in dBm, on the same param 1141 the other sub-1G sensors report signal
+     * strength on. Reported as the device measures it: raw dBm, never normalised to a bar count.
      */
     readonly rssi: {
         readonly param: 1141;
@@ -57,5 +54,5 @@ export declare const KEYPAD_MEMBERS: {
 };
 /** Bound keypad reads — the object returned by `dev.keypad()`. Read-only. */
 export type KeypadActions = Surface<typeof KEYPAD_MEMBERS>;
-/** `keypad` — security keypad. Battery low/charging and signal. Param ids here are placeholders apart from RSSI. */
+/** `keypad` — security keypad. Charging, battery-low and signal. */
 export declare const KEYPAD: CapabilityModule;

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

@@ -160,6 +160,9 @@ export declare const LIGHT_MEMBERS: {
      * This is the switch a user changes and expects to STAY changed. {@link isOn} is a different fact:
      * the lamp being lit right now, driven by whichever
      * client is streaming — the vendor app lights it for a live view and drops it on quitting.
+     *
+     * The T8423 write takes the session-chosen level; level-1 int+string was verified live on a standalone
+     * unit.
      */
     readonly spotlightEnabled: {
         readonly param: 1403;

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

@@ -1,6 +1,6 @@
 import { type Surface } from "./members.js";
 import type { AvailabilityContext, CapabilityModule, CommandContext } from "./types.js";
-import type { Command, AutoLockSnapshot } from "../../core/contracts.js";
+import type { Command, AutoLockSnapshot, MediaProvider } from "../../core/contracts.js";
 /**
  * Setting-id selectors for the compact `ff09-setting-toggle` write — this capability's OWN wire
  * vocabulary, named not inlined per the capability wire-id convention, so `setRainMode`
@@ -33,13 +33,19 @@ export declare const LOCK_SETTING_ID: {
 /**
  * Bound lock controls — the object returned by `dev.lock()`.
  *
- * Everything is DERIVED from `LOCK_MEMBERS`. `lock`/`unlock` and the setting toggles drive any
- * lock-family actuator — currently the T8531 video smart lock and the T85D0 garage door, which share one
- * actuation frame. This module emits ONE transport-neutral intent (identity fields only, no wire bytes,
- * no cipher, no routing key) and names no transport: the command sink routes P2P vs MQTT by the device's
- * topology, and the chosen transport's command router builds the frame + envelope and re-resolves its own
- * routing tail. Which pipe it is does not reach `dev.lock()` — its surface is identical either way,
- * the same way P2P-vs-cloud is hidden for live media.
+ * Everything is DERIVED from `LOCK_MEMBERS`. `lock`/`unlock` drive every lock-family actuator over the
+ * wire its family takes: the shared `ff09` frame on the T8531 video smart lock and the T85D0 garage door,
+ * the T8530 video lock's own `set-payload`, and the keyed-payload envelope on the classic Wi-Fi lock (the
+ * `T8520`-range unit that never negotiates a session key). The setting toggles ride `ff09` only. This
+ * module emits ONE transport-neutral intent per wire (identity fields only, no wire bytes, no cipher, no
+ * routing key) and names no transport: the command sink routes P2P vs MQTT by the device's topology, and
+ * the chosen transport's command router builds the frame + envelope and re-resolves its own routing tail.
+ * Which pipe it is does not reach `dev.lock()` — its surface is identical either way, the same way
+ * P2P-vs-cloud is hidden for live media.
+ *
+ * Classic Wi-Fi lock: `lock()` and `unlock()` are both confirmed on hardware — the bolt moved each way, the
+ * device answered result code 0, and the cloud status followed. That device answers every command, so on it
+ * the two reject on a refusal or an unanswered command as well as on missing identity.
  */
 export type LockActions = Surface<typeof LOCK_MEMBERS>;
 /**
@@ -96,8 +102,8 @@ export declare const LOCK_MEMBERS: {
         readonly description: "Lock battery level 0-100 (verified: param 1101, alias 6001).";
     };
     /**
-     * Link quality in dBm as the lock measures it, on the shared param 1141. Both actuation methods here
-     * are fire-and-forget, so a weak link is silent rather than an error.
+     * Link quality in dBm as the lock measures it, on the shared param 1141. On the `ff09` wire the
+     * actuations are fire-and-forget, so a weak link is silent rather than an error.
      */
     readonly rssi: {
         readonly param: 1141;
@@ -107,10 +113,20 @@ export declare const LOCK_MEMBERS: {
         readonly provenance: "verified";
         readonly description: "Lock signal strength (verified: param 1141 = RSSI).";
     };
-    /** Lock the deadbolt/door. Fire-and-forget — rejects only on missing member identity, never on a device timeout. */
-    readonly lock: import("./members.js").MethodMember<() => Promise<void>>;
-    /** Unlock the deadbolt/door. Fire-and-forget — rejects only on missing member identity. */
-    readonly unlock: import("./members.js").MethodMember<() => Promise<void>>;
+    /**
+     * Lock the deadbolt/door. Resolves after sending, without confirming physical state — except on the
+     * classic Wi-Fi lock, which answers: there it rejects on a device refusal or no reply as well.
+     */
+    readonly lock: import("./members.js").MethodMember<() => Promise<void>> & {
+        available: (ctx: CommandContext) => boolean;
+    };
+    /**
+     * Unlock the deadbolt/door. Resolves after sending, without confirming physical state — except on the
+     * classic Wi-Fi lock, which answers: there it rejects on a device refusal or no reply as well.
+     */
+    readonly unlock: import("./members.js").MethodMember<() => Promise<void>> & {
+        available: (ctx: CommandContext) => boolean;
+    };
     /**
      * Read-modify-write the auto-lock setting: the transport GETs the device's current settings, changes
      * only `enabled` (+ `delaySeconds` if given — otherwise the current delay is preserved), and writes the
@@ -120,7 +136,9 @@ export declare const LOCK_MEMBERS: {
      * **Unlike `lock`/`unlock` this can reject on a device TIMEOUT**, not just missing identity — the GET
      * step is a genuine precondition, so this one is not fire-and-forget.
      */
-    readonly setAutoLock: import("./members.js").MethodMember<(enabled: boolean, delaySeconds?: number) => Promise<void>>;
+    readonly setAutoLock: import("./members.js").MethodMember<(enabled: boolean, delaySeconds?: number) => Promise<void>> & {
+        available: (ctx: CommandContext) => boolean;
+    };
     /**
      * Toggle Rain Mode — a pure blind write, unlike `setAutoLock`: the compact frame carries only this one
      * field, so there is no GET pass and it is fire-and-forget. Confirmed on-device end-to-end in both
@@ -220,6 +238,14 @@ export declare const LOCK_MEMBERS: {
         readonly description: "One-touch rear locking (setting-id 11). Wire shape confirmed in the app's own JS, NOT captured.";
         readonly write: (v: string | number | boolean, ctx: CommandContext) => Command;
     };
+    /** Read the current device-reported state; undefined means no settled locked/unlocked state. */
+    readonly refreshStatus: {
+        readonly needs: "media";
+        readonly provided: (provider: MediaProvider, deps: import("./members.js").MemberDeps) => (() => Promise<boolean | undefined>) | undefined;
+        readonly description: string;
+        readonly requiredCapabilities?: readonly import("../types.js").Capability[];
+        readonly answers: true;
+    };
     /**
      * Read the device's current auto-lock settings via a live `GET_SETTINGS` round-trip — the SAME read
      * `setAutoLock` does internally, exposed standalone with no write attached. Works over BOTH transports.
@@ -230,7 +256,7 @@ export declare const LOCK_MEMBERS: {
      */
     readonly getAutoLockState: {
         readonly needs: "ff09Settings";
-        readonly provided: (provider: import("../../core/contracts.js").Ff09SettingsReader, deps: import("./members.js").MemberDeps) => () => Promise<AutoLockSnapshot>;
+        readonly provided: (provider: import("../../core/contracts.js").Ff09SettingsReader, deps: import("./members.js").MemberDeps) => (() => Promise<AutoLockSnapshot>) | undefined;
         readonly description: string;
         readonly requiredCapabilities?: readonly import("../types.js").Capability[];
         readonly answers: true;