@mega-yfue/eufy-sdk 0.5.0-beta.6 → 0.5.0-beta.61

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,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 +237,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/camera.d.ts

@@ -8,6 +8,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. */
@@ -271,6 +273,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
@@ -435,25 +445,29 @@ 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 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

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,10 @@ 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 { 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 +298,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;
@@ -421,6 +427,8 @@ 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;
     /** Smart Display (read-only): `battery`. No display write is captured. */
@@ -516,7 +524,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, };
 /**
  * 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.
@@ -545,6 +553,7 @@ 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/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/motion.d.ts

@@ -271,6 +271,10 @@ export declare const MOTION_MEMBERS: {
      * The raw sensitivity an indoor camera reports, on the one id whose write takes a `1700` control
      * payload carrying an index rather than the `1350` envelope its siblings use — a frame-shape
      * difference `sensitivityCommand` resolves from the scale. `unexposed` like its three siblings.
+     *
+     * Some devices report 6041 as a base64 JSON list of per-sensor entries
+     * (`{"list":[{"sensor_id":…,"sensitivity":…}]}`) rather than a scalar. That value is stored verbatim
+     * and this getter answers `undefined` for it: only the scalar form is confirmed to be this step.
      */
     readonly indoorSensitivity: {
         readonly param: 6041;
@@ -279,6 +283,7 @@ export declare const MOTION_MEMBERS: {
         readonly provenance: "verified";
         readonly unexposed: true;
         readonly description: "Raw sensitivity an indoor camera reports (verified: param 6041).";
+        readonly decode: (raw: unknown) => number | undefined;
     };
     /**
      * The raw sensitivity on the INVERTED seven-step camera scale — a HIGHER number is LESS sensitive, so

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

@@ -0,0 +1,230 @@
+import { type Surface } from "./members.js";
+import type { CapabilityModule } from "./types.js";
+/**
+ * Robot-mower Tuya **DP ids** — the E15's Tuya product schema (`thing.m.device.ref.info.list` v5.4,
+ * `schemaInfo.schema`, product `bvxrcjxom787vnit`), each id also reported by a live E15. The product
+ * is built on Tuya's robot-vacuum template, so ids below 101 carry that template's codes; the mower's
+ * own data points are 101-146.
+ *
+ * Only scalar data points are named here. The Raw ones (`robot_status` 107, `battery_status` 108,
+ * `map_info` 113, the `*_control` commands 103-106, …) are protobuf messages whose field layout no
+ * source in hand states, and 102 (`device_infomation`) and 142 (`gps_info`) carry the device's network
+ * identity and position.
+ * @internal
+ */
+export declare const MOWER_DP: {
+    readonly BATTERY: 8;
+    readonly VOLUME: 26;
+    readonly CHILD_LOCK: 47;
+    readonly RAIN_AUTO_RETURN: 101;
+    readonly WIFI_SIGNAL: 109;
+    readonly MOW_HEIGHT: 110;
+    readonly SAVE_MAP_PROGRESS: 118;
+    readonly STATION_USED_TIME: 125;
+    readonly BLADE_USED_TIME: 126;
+    readonly EDGE_TRIM: 128;
+    readonly WORK_ANGLE_ENABLED: 130;
+    readonly WORK_ANGLE: 131;
+    readonly SMART_NO_GO_ZONES: 132;
+    readonly BIRD_VIEW_CAPTURE: 133;
+    readonly NETWORK: 134;
+    readonly CELLULAR_ENABLED: 137;
+    readonly EDGE_DISTANCE: 139;
+    readonly GPS_ANTI_THEFT: 140;
+    readonly SPARSE_LAWN_OPTIMIZATION: 141;
+};
+/** The `net_media_type` (DP 134) range, as the schema lists it. */
+export declare const MOWER_NETWORKS: readonly ["None", "Wifi", "Cellular"];
+/** The mower's network link (DP 134). */
+export type MowerNetwork = (typeof MOWER_NETWORKS)[number];
+/**
+ * Every `mower` read, declared once.
+ *
+ * All read-only. Several of these data points are `rw` in the schema, but no write has been captured
+ * against a mower, and the vendor app drives the mower through named pass-through commands rather than
+ * by publishing these DPs, so no setter is installed.
+ *
+ * Exported but NOT published: each entry states its wire id, which the reference site does not carry.
+ * @internal
+ */
+export declare const MOWER_MEMBERS: {
+    /** Charge percentage (DP 8, `battery_percentage`). */
+    readonly battery: {
+        readonly param: 8;
+        readonly type: "number";
+        readonly unit: "%";
+        readonly kind: "percent";
+        readonly provenance: "mega";
+        readonly description: "Battery level 0-100 (DP 8, battery_percentage). Read-only.";
+    };
+    /** Speaker volume (DP 26, `volume_set`). */
+    readonly volume: {
+        readonly param: 26;
+        readonly type: "number";
+        readonly unit: "%";
+        readonly kind: "percent";
+        readonly provenance: "mega";
+        readonly description: "Speaker volume 0-100 (DP 26, volume_set). Read-only.";
+    };
+    /** Whether the child lock is on (DP 47, `child_lock`). */
+    readonly childLock: {
+        readonly param: 47;
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "mega";
+        readonly description: "Child lock on (DP 47, child_lock). Read-only.";
+    };
+    /** Whether the mower returns to its station when it detects rain (DP 101, `rain_auto_return`). */
+    readonly rainAutoReturn: {
+        readonly param: 101;
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "mega";
+        readonly description: "Return to the station when rain is detected (DP 101, rain_auto_return). Read-only.";
+    };
+    /** Wi-Fi signal strength as a percentage (DP 109, `wifi_signal_strength`), not a dBm reading. */
+    readonly wifiSignal: {
+        readonly param: 109;
+        readonly type: "number";
+        readonly unit: "%";
+        readonly kind: "percent";
+        readonly provenance: "mega";
+        readonly description: "Wi-Fi signal strength 0-100 % (DP 109, wifi_signal_strength). Read-only.";
+    };
+    /** Cutting height in millimetres (DP 110, `mow_height`), 25-75. */
+    readonly cutHeight: {
+        readonly param: 110;
+        readonly type: "number";
+        readonly unit: "mm";
+        readonly kind: "millimetres";
+        readonly min: 25;
+        readonly max: 75;
+        readonly provenance: "mega";
+        readonly description: "Cutting height 25-75 mm (DP 110, mow_height). Read-only.";
+    };
+    /** Progress of saving the map (DP 118, `save_map_process`). */
+    readonly mapSaveProgress: {
+        readonly param: 118;
+        readonly type: "number";
+        readonly unit: "%";
+        readonly kind: "percent";
+        readonly provenance: "mega";
+        readonly description: "Map-save progress 0-100 % (DP 118, save_map_process). Read-only.";
+    };
+    /** Total base-station use in minutes (DP 125, `base_station_used_time`). */
+    readonly stationUsedTime: {
+        readonly param: 125;
+        readonly type: "number";
+        readonly unit: "min";
+        readonly kind: "minutes";
+        readonly provenance: "mega";
+        readonly description: "Base-station use in minutes (DP 125, base_station_used_time). Read-only.";
+    };
+    /** Total cutting-blade use in minutes (DP 126, `mow_blade_used_time`). */
+    readonly bladeUsedTime: {
+        readonly param: 126;
+        readonly type: "number";
+        readonly unit: "min";
+        readonly kind: "minutes";
+        readonly provenance: "mega";
+        readonly description: "Cutting-blade use in minutes (DP 126, mow_blade_used_time). Read-only.";
+    };
+    /** Whether edge trimming is on (DP 128, `edge_trim`). */
+    readonly edgeTrim: {
+        readonly param: 128;
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "mega";
+        readonly description: "Edge trimming on (DP 128, edge_trim). Read-only.";
+    };
+    /** Whether a fixed mowing angle is in use (DP 130, `enable_work_angle`); the angle is `workAngle`. */
+    readonly workAngleEnabled: {
+        readonly param: 130;
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "mega";
+        readonly description: "Fixed mowing angle in use (DP 130, enable_work_angle). Read-only.";
+    };
+    /** The mowing angle in degrees, -90 to 90 (DP 131, `work_angle`). */
+    readonly workAngle: {
+        readonly param: 131;
+        readonly type: "number";
+        readonly unit: "°";
+        readonly kind: "degrees";
+        readonly min: -90;
+        readonly max: 90;
+        readonly provenance: "mega";
+        readonly description: "Mowing angle -90 to 90 degrees (DP 131, work_angle). Read-only.";
+    };
+    /** Whether smart no-go zones are on (DP 132, `enable_smart_forbid_zone`). */
+    readonly smartNoGoZones: {
+        readonly param: 132;
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "mega";
+        readonly description: "Smart no-go zones on (DP 132, enable_smart_forbid_zone). Read-only.";
+    };
+    /** Whether bird's-eye-view capture is on (DP 133, `enable_bird_view_capture`). */
+    readonly birdViewCapture: {
+        readonly param: 133;
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "mega";
+        readonly description: "Bird's-eye-view capture on (DP 133, enable_bird_view_capture). Read-only.";
+    };
+    /**
+     * The network link in use (DP 134, `net_media_type`). Answers `undefined` for a value outside the
+     * schema's range.
+     */
+    readonly network: {
+        readonly param: 134;
+        readonly type: "string";
+        readonly provenance: "mega";
+        readonly decode: (raw: unknown) => MowerNetwork | undefined;
+        readonly decodedKind: "enum";
+        readonly decodedValues: readonly ["None", "Wifi", "Cellular"];
+        readonly description: "Network link: None, Wifi or Cellular (DP 134, net_media_type). Read-only.";
+    };
+    /** Whether the cellular link is enabled (DP 137, `enable_cellular`). */
+    readonly cellularEnabled: {
+        readonly param: 137;
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "mega";
+        readonly description: "Cellular link enabled (DP 137, enable_cellular). Read-only.";
+    };
+    /** Edge-following distance in millimetres (DP 139, `follow_edge_distance`), signed. */
+    readonly edgeDistance: {
+        readonly param: 139;
+        readonly type: "number";
+        readonly unit: "mm";
+        readonly kind: "millimetres";
+        readonly min: -10000;
+        readonly max: 10000;
+        readonly provenance: "mega";
+        readonly description: "Edge-following distance in mm, signed (DP 139, follow_edge_distance). Read-only.";
+    };
+    /** Whether GPS anti-theft is on (DP 140, `gps_location_check`). */
+    readonly gpsAntiTheft: {
+        readonly param: 140;
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "mega";
+        readonly description: "GPS anti-theft on (DP 140, gps_location_check). Read-only.";
+    };
+    /** Whether sparse-lawn optimisation is on (DP 141, `sparse_lawn_optimization`). */
+    readonly sparseLawnOptimization: {
+        readonly param: 141;
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "mega";
+        readonly description: "Sparse-lawn optimisation on (DP 141, sparse_lawn_optimization). Read-only.";
+    };
+};
+/**
+ * Bound mower reads — the object returned by `dev.mower()`. Each getter is present only once the
+ * mower has reported its data point.
+ */
+export type MowerActions = Surface<typeof MOWER_MEMBERS>;
+/** `mower` — robot-mower state from its Tuya data points. */
+export declare const MOWER: CapabilityModule;

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

@@ -15,7 +15,7 @@ export declare const SUCTION_DP: {
  * Suction levels — the app's `SuctionEnum` (`getSuctionEnumByValue`). This is a **fixed** value→label
  * map with **no model argument**: a given int means the same thing on every RoboVac. What varies per
  * model is only **availability** — a device's `get_product_data_point` range may expose a narrower
- * subset (the T2351 catalog lists 0-3) — so the `suction` property stays a raw int rather than being
+ * subset (the T2351 catalog lists `Quiet`–`Max`) — so the `suction` property stays a raw int rather than being
  * constrained per device, and {@link suctionLevelName} names a reported level.
  *
  * `BoostIQ` (4) is a real suction level in this scale. The separate `boostIq`
@@ -45,11 +45,11 @@ export declare function suctionLevelName(value: number): string | undefined;
 export type SuctionActions = Surface<typeof SUCTION_MEMBERS> & {
     /**
      * The suction levels this device supports, sourced from the per-SKU `get_product_data_point` catalog
-     * range for DP 158. Narrower than the full six {@link SuctionLevel} values on many models — a T2351
-     * reports `[0, 1, 2, 3]`.
+     * range for DP 158. Narrower than the full six {@link SuctionLevel} values on many models — a T2351's
+     * catalog lists `Quiet`, `Standard`, `Turbo` and `Max`, which answers `[0, 1, 2, 3]`.
      *
-     * `undefined` when the catalog is absent or does not cover DP 158. Only meaningful on devices where
-     * `setSuctionLevel` is installed (AIoT vacuums).
+     * `undefined` when the catalog is absent, does not cover DP 158, or lists only members outside the
+     * known scale. Only meaningful on devices where `setSuctionLevel` is installed (AIoT vacuums).
      */
     readonly supportedLevels?: readonly SuctionLevelValue[];
 };

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

@@ -247,6 +247,12 @@ export interface AvailabilityContext {
     homeBaseAttached?: boolean;
     /** Serial of the covering station, when the device record names one. */
     stationSerial?: string;
+    /**
+     * The vendor DeviceType of the station the device hangs off, when it is attached
+     * and the station's record states one. Answers which station family a command addressed to an
+     * attached device is carried through.
+     */
+    stationDeviceType?: number;
 }
 export interface CommandContext extends AvailabilityContext {
     /** Device channel (0 for standalone, `device_channel` on a HomeBase). */

package/dist/model/capabilities/vacuum-clean.d.ts

@@ -169,12 +169,11 @@ export declare const TUYA_CLEAN_TYPES: readonly ["Sweep", "SweepMop", "Mop"];
 /** @internal */
 export type TuyaCleanType = (typeof TUYA_CLEAN_TYPES)[number];
 /**
- * `ModeCtrlRequest.method` values for DP 152. Live-verified on T2351: START_AUTO_CLEAN → 0
- * (omitted from the wire when zero), START_GOHOME → 6, PAUSE_TASK → 13.
+ * `ModeCtrlRequest.method` values for DP 152. Live-verified on T2351: START_GOHOME → 6,
+ * PAUSE_TASK → 13. An auto clean is `START_AUTO_CLEAN` (0) with a payload — see
+ * {@link ModeCtrlParamMethod}.
  */
 export declare const ModeCtrlMethod: {
-    /** Live-verified on a T2351. Zero, so it is omitted from the wire per the proto3 default rule. */
-    readonly START_AUTO_CLEAN: 0;
     /** Live-verified on a T2351. */
     readonly START_GOHOME: 6;
     /** Live-verified on a T2351. */
@@ -202,9 +201,11 @@ export declare const ModeCtrlMethod: {
  * its argument in the signature: {@link VACUUM_CLEAN_MEMBERS.startScene},
  * {@link VACUUM_CLEAN_MEMBERS.cleanRooms} and {@link VACUUM_CLEAN_MEMBERS.cleanZones}.
  *
- * The outer frame these ride in is byte-verified on a live T2351, and `SCENE`, `SELECT_ROOMS` and
- * `SELECT_ZONES` have each since been RUN on a T2351 and did what they name — so their numbers rest on
- * observed behaviour rather than on the vendor's definition alone.
+ * The outer frame these ride in is byte-verified on a live T2351, and `AUTO`, `SCENE`, `SELECT_ROOMS`
+ * and `SELECT_ZONES` have each since been RUN on a T2351 and did what they name — so their numbers rest
+ * on observed behaviour rather than on the vendor's definition alone. `AUTO` is RUN with its payload:
+ * the vendor's definition calls `AutoClean.clean_times` valid only when non-zero, and the T2351 did
+ * not start on method 0 sent without it.
  *
  * That distinction is the whole point of checking, and this is the one place it is argued: an AIoT
  * data-point write is fire-and-forget, so a wrong number would be a different command arriving and
@@ -215,6 +216,11 @@ export declare const ModeCtrlMethod: {
  * scene id and a map id both arrive on DP 180.
  */
 export declare const ModeCtrlParamMethod: {
+    /** `START_AUTO_CLEAN` with an `AutoClean` payload — clean the whole floor. */
+    readonly AUTO: {
+        readonly method: 0;
+        readonly param: 3;
+    };
     /** `START_SELECT_ROOMS_CLEAN` — clean the named rooms of a named map. */
     readonly SELECT_ROOMS: {
         readonly method: 1;
@@ -274,17 +280,17 @@ export declare function encodeSelectZonesClean(mapId: number, zones: readonly Va
  * @internal
  */
 export declare function encodeSceneClean(sceneId: number): string;
+/**
+ * Build a whole-floor auto clean carrying an `AutoClean` payload of one pass.
+ * @internal
+ */
+export declare function encodeAutoClean(): string;
 /**
  * Encode a `ModeCtrlRequest` protobuf (DP 152) as a DP value: `varint(bodyLen) ++ {method:1, seq:2}`.
  *
  * Built on {@link RawDpWriter} rather than hand-rolled bytes. The frame is unchanged and the existing
  * byte-level test is what proves it — that test was written against a live T2351 capture, so it holds
  * the writer to the wire rather than to this function's own idea of the wire.
- *
- * Method 0 (START_AUTO_CLEAN) is omitted rather than written as an explicit zero, per the proto3
- * default-field rule and confirmed on that same capture. The writer deliberately does not apply that
- * rule itself: whether an explicit zero and an absent field mean the same thing is the
- * message's business, not the encoder's.
  * @internal
  */
 export declare function encodeModeCtrl(method: number, seq: number): string;
@@ -1955,7 +1961,7 @@ export declare const VACUUM_CLEAN_MEMBERS: {
         readonly provenance: "mega";
         readonly description: "Stop smart-follow mode (ModeCtrlRequest method 18 over DP 152). Method number not captured — unverified.";
     };
-    /** Start an auto-clean run via ModeCtrlRequest method 0 (DP 152). AIoT only — Tuya write unverified. */
+    /** Start an auto-clean run via ModeCtrlRequest method 0 with one `AutoClean` pass (DP 152). AIoT only — Tuya write unverified. */
     readonly startCleaning: import("./members.js").MethodMember<() => Promise<void>> & {
         available: (ctx: import("./types.js").CommandContext) => boolean;
     };

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

@@ -43,6 +43,10 @@ export declare const isOutdoorPanTilt: (ctx: FamilyContext) => boolean;
 export declare const isFloodLight: (ctx: FamilyContext) => boolean;
 /** HomeBase-family hub (has a speaker/alarm) — a station EXCLUDING the NVRs, per `HOMEBASE_TYPES`. */
 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/model/param-dictionary.d.ts

@@ -9,6 +9,7 @@
  *    `types.ts`.
  *  - CLEAN_PARAMS — RoboVac Tuya DP space (ids 1 and above), names from the cloud
  *    `get_product_data_point` data_point_list, hence provenance `mega`.
+ *  - MOWER_PARAMS — robot-mower Tuya DP space, names from the mower's Tuya product schema.
  *
  * Which models reported an id, and the capture that named it, are in the commit that adds the entry.
  */
@@ -50,3 +51,8 @@ export declare const CLEAN_PARAMS: Record<number, ParamDef>;
  * display settings screen, one control at a time, params diffed after each.
  */
 export declare const DISPLAY_PARAMS: Record<number, ParamDef>;
+/**
+ * Robot-mower Tuya DP space — names from the E15's Tuya product schema (`schemaInfo.schema`), each id
+ * also reported by a live E15. Only the scalar data points the `mower` capability reads are listed.
+ */
+export declare const MOWER_PARAMS: Record<number, ParamDef>;

package/dist/model/param-namespace.d.ts

@@ -14,7 +14,7 @@
 import type { Codec } from "./types.js";
 import { type ParamDef } from "./param-dictionary.js";
 /** The param id spaces this SDK models. */
-export type ParamNamespace = "security" | "clean" | "life" | "print" | "display";
+export type ParamNamespace = "security" | "clean" | "mower" | "life" | "print" | "display";
 /** Look up a param def in the given namespace. */
 export declare function paramDef(ns: ParamNamespace, paramType: number): ParamDef | undefined;
 /** The param namespace a device's ids live in, from its codec, via the module-local `NAMESPACE_BY_CODEC` table. */

package/dist/model/registry.d.ts

@@ -48,7 +48,8 @@ export declare function resolveDevice(rec: CloudRecord): ResolvedDevice;
  * The property manifest for a device, from its capabilities and the record's facts. The single place
  * an {@link AvailabilityContext} is built — so a family-gate (`available`) and a per-model enum
  * (`enumValuesFor`) are decided from the same truthful, session-free view on every path (initial
- * resolve and {@link Device.reresolve}). Populated only from what a record carries, never transport
- * fields a live session hasn't produced.
+ * resolve and {@link Device.reresolve}). Populated only from what a record carries: its cloud params and
+ * the params its device reported over realtime, the same evidence a bound getter is gated on. Never
+ * transport fields a live session hasn't produced.
  */
 export declare function resolveProperties(rec: CloudRecord, codec: Codec, capabilities: Capability[]): PropertySpec[];