@mega-yfue/eufy-sdk 0.5.0-beta.7 → 0.5.0-beta.71

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/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,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;
@@ -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/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`
@@ -107,10 +107,14 @@ 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; does not confirm physical state. */
+    readonly lock: import("./members.js").MethodMember<() => Promise<void>> & {
+        available: (ctx: CommandContext) => boolean;
+    };
+    /** Unlock the deadbolt/door. Resolves after sending; does not confirm physical state. */
+    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 +124,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 +226,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 +244,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;

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/rtsp.d.ts

@@ -1,6 +1,6 @@
 import type { Command } from "../../core/contracts.js";
 import { type Surface } from "./members.js";
-import type { CapabilityModule, CommandContext } from "./types.js";
+import type { AvailabilityContext, CapabilityModule, CommandContext } from "./types.js";
 /** The state params this capability owns — its OWN vocabulary, used by no other capability. */
 export declare const RTSP_PARAM: {
     /**
@@ -93,6 +93,13 @@ export type RtspRecordingModeValue = (typeof RtspRecordingMode)[keyof typeof Rts
  * and the served effect on each endpoint with an RTSP `DESCRIBE`: 401 = challenged, 200 = open.
  */
 export type RtspActions = Surface<typeof RTSP_MEMBERS>;
+/**
+ * Whether the publish switch has a wire to this camera. A HomeBase S1 Pro (`STATION_9000`) carries an
+ * attached camera's commands over its WebRTC control channel, which takes only the `1350` and `1700`
+ * envelopes; the switch is a plain scalar, and no other frame for it is captured there. Gating the
+ * `published` member drops its read with its setter, since one availability decision covers both.
+ */
+declare function publishable(ctx: AvailabilityContext): boolean;
 /**
  * Every `rtsp` feature, declared once.
  *
@@ -127,6 +134,7 @@ export declare const RTSP_MEMBERS: {
             readonly publish: true;
             readonly withdraw: false;
         };
+        readonly available: typeof publishable;
     };
     /**
      * The device-reported RTSP URL — the full `rtsp://user:pass@host/path`, carrying the credentials the
@@ -179,9 +187,13 @@ export declare const RTSP_MEMBERS: {
         readonly description: string;
     };
     /** Persistently publish this camera's stream. The enabling caller owns withdrawing it when done. */
-    readonly publish: import("./members.js").MethodMember<() => Promise<void>>;
+    readonly publish: import("./members.js").MethodMember<() => Promise<void>> & {
+        available: (ctx: CommandContext) => boolean;
+    };
     /** Withdraw this camera's persistent publication; consumer retries do not ask the SDK to republish it. */
-    readonly withdraw: import("./members.js").MethodMember<() => Promise<void>>;
+    readonly withdraw: import("./members.js").MethodMember<() => Promise<void>> & {
+        available: (ctx: CommandContext) => boolean;
+    };
     /**
      * Store credentials and request authentication on this camera's stream. Served enforcement is
      * topology-dependent and must be verified with `DESCRIBE` (401 = challenged, 200 = open).
@@ -219,3 +231,4 @@ export declare const RTSP_MEMBERS: {
  * rather than a model table.
  */
 export declare const RTSP: CapabilityModule;
+export {};

package/dist/model/capabilities/smart-drop.d.ts

@@ -0,0 +1,20 @@
+import { type Surface } from "./members.js";
+import type { CapabilityModule } from "./types.js";
+/**
+ * Every `smart_drop` feature, declared once.
+ *
+ * Exported but NOT published: each entry states its wire id and the evidence it was confirmed on,
+ * which the reference site does not carry.
+ * @internal
+ */
+export declare const SMART_DROP_MEMBERS: {
+    /**
+     * Opens the lid with `SET_PAYLOAD` 2100 at level 2. Verified on a standalone T8790, whose cipher has
+     * only an RSA key: the frame sealed AES-128-ECB opened the lid, the same frame at level 1 did not.
+     */
+    readonly openLid: import("./members.js").MethodMember<() => Promise<void>>;
+};
+/** Bound SmartDrop controls — the object returned by `dev.smartDrop()`. */
+export type SmartDropActions = Surface<typeof SMART_DROP_MEMBERS>;
+/** `smart_drop` — a standalone SmartDrop (T8790) parcel box: open the lid. */
+export declare const SMART_DROP: 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[];
 };