@mega-yfue/eufy-sdk 0.2.0-beta.8 → 0.2.0-beta.9

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

@@ -2,27 +2,35 @@ import { type Surface } from "./members.js";
 import type { CapabilityModule, CommandContext } from "./types.js";
 import type { Command } from "../../core/contracts.js";
 /**
- * The guard modes `setMode` can SET — the four whose write is confirmed against a real station. Three are
- * byte-exact captures and `custom1` is a live confirmation; `ARMING_MODE_WIRE` carries the per-value
- * evidence. `ArmingMode` is both the const value-object (`ArmingMode.home`) and the union type of its
+ * The guard modes `setMode` can SET — every mode a station reports, all nine confirmed against real
+ * hardware. `ArmingMode` is both the const value-object (`ArmingMode.home`) and the union type of its
  * values, so callers pass the named constant: `setMode(ArmingMode.home)`.
  *
  * The domain of `setMode` (cmd 1224) alone. The alarm-delay write (cmd 1255) carries its own mode integer
- * on a separate wire and takes {@link AlarmDelayMode}.
+ * on a separate wire and takes {@link AlarmDelayMode}, which stays NARROWER — evidence for one command is
+ * not evidence for the other, and 1255 still has no capture beyond its byte-captured three.
  *
- * Deliberately NARROWER than the set a device may report. The remaining five modes are ones the app itself
- * defines and the `mode` read still names them, but no capture shows one being SENT — and
- * on a fire-and-forget wire a wrong one looks exactly like success. Leaving them out of this union is the
- * compile-time half of the refusal; `mode`'s published argument and the generated rejection are the
- * runtime half.
+ * A mode belongs here only once its write is confirmed against real hardware, because a fire-and-forget
+ * wire makes a wrong mode look exactly like success; `ARMING_MODE_WIRE` carries the per-value evidence.
+ * The union is also what `ARMING_MODE_WIRE` is keyed by, so the table cannot name a mode this does not.
  */
 export declare const ArmingMode: {
     /** Armed — full protection, nobody home (wire value 0). */
     readonly away: "away";
     /** Armed for occupancy — reduced/perimeter protection while home (wire value 1). */
     readonly home: "home";
+    /** Scheduled — the station follows the timetable configured in the app (wire value 2). */
+    readonly schedule: "schedule";
     /** Custom 1 — a user-defined posture configured in the app (wire value 3). */
     readonly custom1: "custom1";
+    /** Custom 2 — a user-defined posture configured in the app (wire value 4). */
+    readonly custom2: "custom2";
+    /** Custom 3 — a user-defined posture configured in the app (wire value 5). */
+    readonly custom3: "custom3";
+    /** Off — the station's alarm system is switched off entirely (wire value 6). */
+    readonly off: "off";
+    /** Geofenced — the station follows the app's location-based rules (wire value 47). */
+    readonly geo: "geo";
     /** Disarmed — no alarms; sensors still report state (wire value 63). */
     readonly disarmed: "disarmed";
 };
@@ -60,10 +68,10 @@ export declare const ARMING_CMD: {
      *
      * ⚠️ Only 3 of the 9 modes were exercised in that capture — `mode_type` 0 (away), 63 (disarmed), 1
      * (home), all confirmed byte-exact. Re-confirmed live 2026-08-05: each reported its own MODE_SWITCH push
-     * within ~5s of the write. `custom1` 3 joined {@link ArmingMode} on a live confirmation rather than a
-     * capture, making four settable in total. The remaining five are named by the app but never observed
-     * leaving it, so this capability reads them and refuses to send them. See `ARMING_MODE_WIRE` for the
-     * per-value breakdown.
+     * within ~5s of the write. The remaining six are live confirmations rather than captures — `custom1` 3
+     * first, then `schedule` 2, `custom2` 4, `custom3` 5, `off` 6 and `geo` 47 — each sent as this exact
+     * frame and each observed to bring MODE_SWITCH back, so all nine are settable. `ARMING_MODE_WIRE` has
+     * the per-value evidence and the dates.
      */
     readonly SET_ARMING: 1224;
     /**
@@ -164,11 +172,10 @@ export type ArmingActions = Surface<typeof ARMING_MEMBERS>;
  */
 export declare const ARMING_MEMBERS: {
     /**
-     * The one member whose write domain is NARROWER than its read: `enumValues` names all nine modes a
-     * station can report, and the argument's `values` publishes only the four whose write is confirmed. That
-     * argument IS the domain the derived setter enforces and the refusal names, so an unconfirmed mode is
-     * refused by naming the four that work — nine labels for the read and four for the write, off one
-     * declaration.
+     * Read and write are the same nine modes, so `enumValues` is the whole domain: `writeDomain` falls back
+     * to it, and the derived setter, the refusal message and the offered argument all read from that one
+     * declaration. A member states an `args` entry only where the two sides DIFFER. See
+     * {@link ARMING_MODE_WIRE} for the per-value evidence.
      *
      * `armingCommand` may also throw synchronously (missing account identity) and `bindMembers` turns that
      * into a rejection, so the builder stays plain.
@@ -188,11 +195,6 @@ export declare const ARMING_MEMBERS: {
         readonly kind: "enum";
         readonly enumValues: Record<number, string>;
         readonly provenance: "verified";
-        readonly args: readonly [{
-            readonly name: "mode";
-            readonly kind: "enum";
-            readonly values: readonly number[];
-        }];
         readonly description: string;
         readonly observation: {
             readonly event: "armingModeChanged";
@@ -221,9 +223,9 @@ export declare const ARMING_MEMBERS: {
     readonly setAlarmDelayConfig: import("./members.js").MethodMember<(mode: AlarmDelayMode, config: AlarmDelayConfig) => Promise<void>>;
 };
 /**
- * `arming` — guard/arming mode. `armingMode` (see {@link ARMING_CMD.SET_ARMING}) has a verified
- * read/write MECHANISM, but only 4 of the 9 modes it reports (away/home/custom1/disarmed, the
- * {@link ArmingMode} union) are confirmed as writes — see `ARMING_MODE_WIRE` for which 5 are still
- * unverified third-party integers, and which of the 4 is live-confirmed rather than byte-captured.
+ * `arming` — guard/arming mode. `armingMode` (see {@link ARMING_CMD.SET_ARMING}) has a verified read/write
+ * MECHANISM, and all 9 modes it reports are now confirmed as writes — the {@link ArmingMode} union is the
+ * whole set. See `ARMING_MODE_WIRE` for which three are byte-captured and which six are live-confirmed.
+ * The alarm-delay write (cmd 1255) is unaffected and keeps its narrower {@link AlarmDelayMode}.
  */
 export declare const ARMING: CapabilityModule;

package/package.json

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