@mega-yfue/eufy-sdk 0.0.4 → 0.1.0-beta.0

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

@@ -0,0 +1,208 @@
+import type { RawDpCodec } from "../../core/contracts.js";
+import type { ParamValue } from "../types.js";
+import { type Surface } from "./members.js";
+import type { AvailabilityContext, CapabilityModule } from "./types.js";
+/**
+ * The DP 169 property name the ROBOT's own readings borrow, and the id carrying it.
+ *
+ * `DeviceInfo` is one message spanning two capabilities: the dock's firmware sits at field 11 and the
+ * robot's MAC, SSID and IP sit beside it. The one-owner rule is per product line, so one of the two has
+ * to own the id — this capability does, because it claimed it first and because moving it would break a
+ * shipped surface. The clean capability names this pair to read the rest. Exported so the far side
+ * cites a constant rather than retyping a string and a number that must agree.
+ */
+export declare const VACUUM_DOCK_INFO_SOURCE: {
+    readonly property: "dockFirmwareVersion";
+    readonly param: 169;
+};
+/**
+ * Decode the DOCK's firmware version from `DeviceInfo` (DP 169).
+ *
+ * `undefined` covers every way it is not stated: no codec, a payload that does not decode, a robot not
+ * currently docked (no `station` block), or a dock that reports the block without a version. A
+ * length-delimited `string` arrives as bytes, so the value is read back as UTF-8.
+ * @internal
+ */
+export declare function decodeDockFirmware(raw: ParamValue | undefined, codec: RawDpCodec | undefined): string | undefined;
+/**
+ * Every value {@link DockActivity} can take — the read's declared domain, so the schema a caller reads
+ * and the type it compiles against are the same list rather than two that can drift.
+ *
+ * Published alongside {@link DockActivity} so the members are reachable as data at runtime, not only
+ * at compile time.
+ */
+export declare const DOCK_ACTIVITIES: readonly ["idle", "washing", "drying", "descaling", "emptyingDust", "addingWater", "recyclingWater", "makingDisinfectant", "cuttingHair", "unknown"];
+/**
+ * What the dock is doing — what `dev.vacuumDock()?.dockState` reports.
+ *
+ * A dock services several subsystems, so more than one can be busy at once; this answers the single
+ * most specific one — a subsystem that is running beats the mop system's own mode. `"unknown"` covers
+ * a state value outside the set the dock's own status message declares.
+ */
+export type DockActivity = (typeof DOCK_ACTIVITIES)[number];
+/**
+ * Decode a `StationResponse` (DP 173) Raw-DP value to the {@link DockActivity} the dock reports.
+ *
+ * Answers `undefined` for every way the dock has not stated an activity — an unbound device (no
+ * codec), a payload that does not decode, or one carrying no `status` message at all. That is distinct
+ * from `"idle"`, which is the dock actively saying it has nothing running, and from `"unknown"`, which
+ * is a state value this does not have a name for.
+ * @internal
+ */
+export declare function decodeDockActivity(raw: ParamValue | undefined, codec: RawDpCodec | undefined): DockActivity | undefined;
+/**
+ * Build a `StationRequest` carrying one manual dock command.
+ *
+ * Every one of these is the same two-level frame with a different inner field, so one builder serves
+ * them all and each member names only its command.
+ *
+ * **Reversed from the vendor's `station.proto`, NOT confirmed on a device.** Every member built on this
+ * carries `unverified`, so no setter is installed and the frame ships as documentation rather than as a
+ * callable control. An AIoT DP write is not refused by a router guard — it reaches the robot — and a
+ * fire-and-forget write that is wrong looks exactly like success, so the frame being plausible is not
+ * the bar. One `publishDps` capture per verb is what flips it.
+ * @internal
+ */
+export declare function encodeStationCommand(command: number): string;
+/**
+ * Every `vacuum_dock` feature, declared once.
+ *
+ * DP 173 is confirmed in the `get_product_data_point` catalog (raw, rw) as `baseStation`. The read
+ * side answers a typed {@link DockActivity} through {@link decodeDockActivity}. The write side
+ * (`StationRequest`) is a different message on the same DP and is not confirmed on a device — those
+ * members carry `unverified` with no `write` field, so no setter is installed and the intent path
+ * throws rather than guessing a frame.
+ * @internal
+ */
+export declare const VACUUM_DOCK_MEMBERS: {
+    /**
+     * The DOCK's firmware version (DP 169, `DeviceInfo.station.software`) — distinct from
+     * `info.firmwareVersion`, which is the robot's and comes off the cloud device record.
+     *
+     * `undefined` while the robot is not docked: the vendor only fills the station block when the robot
+     * is powered on at the dock, so an absent value is normal rather than a fault.
+     */
+    readonly dockFirmwareVersion: {
+        readonly param: 169;
+        readonly type: "string";
+        readonly kind: "text";
+        readonly provenance: "mega";
+        readonly decode: (raw: unknown, codec: RawDpCodec | undefined) => string | undefined;
+        readonly decodedKind: "text";
+        readonly description: string;
+    };
+    /**
+     * What the dock is doing (DP 173, `StationResponse`) — washing or drying mops, emptying the bin,
+     * moving water, or idle.
+     *
+     * `undefined` means the dock has not stated an activity: the payload carried no `status` message, or
+     * the device is not bound to a codec. That is not the same as `"idle"`, which is the dock saying it
+     * has nothing running.
+     */
+    readonly dockState: {
+        readonly param: 173;
+        readonly type: "string";
+        readonly provenance: "mega";
+        readonly decode: (raw: unknown, codec: RawDpCodec | undefined) => "addingWater" | "cuttingHair" | "descaling" | "drying" | "emptyingDust" | "idle" | "makingDisinfectant" | "recyclingWater" | "unknown" | "washing" | undefined;
+        readonly decodedKind: "enum";
+        readonly decodedValues: readonly ["idle", "washing", "drying", "descaling", "emptyingDust", "addingWater", "recyclingWater", "makingDisinfectant", "cuttingHair", "unknown"];
+        readonly description: string;
+    };
+    /**
+     * Empty the dust bin into the dock. Write side of DP 173 — `StationRequest.manual_cmd.go_collect_dust`.
+     *
+     * The frame is built and reviewable; the member stays `unverified`, so no setter is installed and
+     * the intent path refuses it. What is missing is a capture, not the message shape.
+     */
+    readonly emptyDust: {
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly writeOnly: true;
+        readonly unverified: true;
+        readonly write: () => import("../../core/contracts.js").Command;
+        readonly available: (ctx: AvailabilityContext) => boolean;
+        readonly provenance: "mega";
+        readonly description: "Empty the dust bin (DP 173 StationRequest.manual_cmd.go_collect_dust). Frame reversed from the vendor proto; unverified until captured on a device.";
+    };
+    /**
+     * Wash the mops in the dock — `StationRequest.manual_cmd.go_selfcleaning`. Same standing as
+     * {@link VACUUM_DOCK_MEMBERS.emptyDust}: frame built, not yet captured, so no setter is installed.
+     */
+    readonly washMops: {
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly writeOnly: true;
+        readonly unverified: true;
+        readonly write: () => import("../../core/contracts.js").Command;
+        readonly available: (ctx: AvailabilityContext) => boolean;
+        readonly provenance: "mega";
+        readonly description: "Wash the mops (DP 173 StationRequest.manual_cmd.go_selfcleaning). Frame reversed from the vendor proto; unverified until captured on a device.";
+    };
+    /**
+     * Dry the mops in the dock — `StationRequest.manual_cmd.go_dry`. Frame built, not yet captured.
+     */
+    readonly dryMops: {
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly writeOnly: true;
+        readonly unverified: true;
+        readonly write: () => import("../../core/contracts.js").Command;
+        readonly available: (ctx: AvailabilityContext) => boolean;
+        readonly provenance: "mega";
+        readonly description: "Dry the mops (DP 173 StationRequest.manual_cmd.go_dry). Frame reversed from the vendor proto; unverified until captured on a device.";
+    };
+    /**
+     * Run the dock's full deep self-clean cycle — `StationRequest.manual_cmd.self_maintain`.
+     *
+     * The longest-running of these — it occupies the dock for a while.
+     */
+    readonly selfMaintain: {
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly writeOnly: true;
+        readonly unverified: true;
+        readonly write: () => import("../../core/contracts.js").Command;
+        readonly available: (ctx: AvailabilityContext) => boolean;
+        readonly provenance: "mega";
+        readonly description: "Run the dock's full self-maintenance cycle (DP 173 StationRequest.manual_cmd.self_maintain). Frame reversed from the vendor proto; unverified until captured on a device.";
+    };
+    /**
+     * Run the descaling cycle — `StationRequest.manual_cmd.go_remove_scale`. Only docks that make their
+     * own cleaning solution have this; the `available` gate is family-wide, so a device without it will
+     * simply ignore the frame.
+     */
+    readonly removeScale: {
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly writeOnly: true;
+        readonly unverified: true;
+        readonly write: () => import("../../core/contracts.js").Command;
+        readonly available: (ctx: AvailabilityContext) => boolean;
+        readonly provenance: "mega";
+        readonly description: "Run the descaling cycle (DP 173 StationRequest.manual_cmd.go_remove_scale). Frame reversed from the vendor proto; unverified until captured on a device.";
+    };
+    /**
+     * Run the hair-cutting cycle on the brush — `StationRequest.manual_cmd.go_cut_hair`.
+     */
+    readonly cutHair: {
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly writeOnly: true;
+        readonly unverified: true;
+        readonly write: () => import("../../core/contracts.js").Command;
+        readonly available: (ctx: AvailabilityContext) => boolean;
+        readonly provenance: "mega";
+        readonly description: "Run the hair-cutting cycle (DP 173 StationRequest.manual_cmd.go_cut_hair). Frame reversed from the vendor proto; unverified until captured on a device.";
+    };
+};
+/**
+ * Bound Omni dock controls — the object returned by `dev.vacuumDock()`.
+ *
+ * `dockState` reads as a typed {@link DockActivity}. All write members (`emptyDust`, `washMops`,
+ * `dryMops`) are `unverified` with no `write` field: the `StationRequest` wire is not confirmed on a
+ * device, so no setter appears on the surface until it is. The surface will fill out as writes are
+ * confirmed.
+ */
+export type VacuumDockActions = Surface<typeof VACUUM_DOCK_MEMBERS>;
+/** `vacuum_dock` — Omni dock controls (auto-empty, mop wash, mop dry) for the RoboVac X10 Pro Omni (T2351). */
+export declare const VACUUM_DOCK: CapabilityModule;

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

@@ -0,0 +1,6 @@
+import type { CapabilityModule } from "./types.js";
+/**
+ * `video` — live/recorded streaming. Its value is *behaviour* (start/stop livestream,
+ * P2P media path), not reported state, so it contributes no state properties here.
+ */
+export declare const VIDEO: CapabilityModule;

package/dist/model/classify.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Device classifier — axis **B2** (command-codec family).
+ *
+ * ## What this module does
+ * Given a cloud device record, it answers one question: *which wire-protocol family
+ * does this device belong to?* — i.e. its {@link Codec} (`station | camera | sensor |
+ * lock | keypad`). It also exposes the baseline {@link Capability} set every member of a
+ * codec gets for free (before model rows / inference add device-specific extras).
+ *
+ * ## Why it is data-driven (no per-SKU table)
+ * eufy assigns every product a numeric **DeviceType** at the cloud, and that number — not
+ * the marketing model code — is the authoritative family discriminator. So the primary
+ * classifier ({@link codecForType}) is a small set of range / membership checks over the
+ * DeviceType space, with each group's DeviceType *names* spelled out in comments. A brand
+ * new camera SKU that ships with a DeviceType inside the camera range classifies correctly
+ * with zero code changes — that is the whole point of keeping this as data, not a wall of
+ * per-model predicates.
+ *
+ * The DeviceType groupings below are distilled from a third-party reverse-engineering
+ * project's device enum and its ~70 `isCamera`/`isStation`/`isSensor`/`isLock`/`isKeyPad`
+ * predicates, collapsed into a handful of numeric sets. That is a NAME/grouping source only —
+ * every behaviour keyed off a group is grounded in the V6 app or our own captures.
+ *
+ * ## Fallbacks
+ * When the cloud record has no DeviceType (older firmware, partial records), we fall back to
+ * a conservative regex over the model T-code ({@link codecFromModel}). {@link classify}
+ * chains the two and defaults to `"camera"` — the most common eufy-security device and a
+ * safe read-only default (a misrouted camera codec degrades to "video-ish" behaviour rather
+ * than, say, attempting lock actuation).
+ *
+ * @module model/classify
+ */
+import type { Codec, CloudRecord } from "./types.js";
+/**
+ * Map eufy's numeric **DeviceType** to a command {@link Codec}.
+ *
+ * Resolution order (first match wins): station → lock → sensor → keypad → camera. Anything
+ * that is a recognised security endpoint but not in the station/lock/sensor/keypad sets is
+ * treated as a **camera** (cameras, doorbells, floodlight/wall-light cams, garage cams,
+ * solocams, eufyCams, smart-drop, the LOCK_85V0 video-doorbell, etc.) — this is the large,
+ * fast-growing family, so it is the residual bucket rather than an explicit list.
+ *
+ * @param deviceType eufy DeviceType integer (e.g. `9` = CAMERA2, `54` = LOCK_8503 / R10).
+ * @returns the codec, or `undefined` for a genuinely unknown / non-finite input.
+ */
+export declare function codecForType(deviceType: number): Codec | undefined;
+/**
+ * Fallback classifier used when {@link CloudRecord.deviceType} is absent. Matches eufy
+ * product **T-codes** by family prefix. Deliberately conservative — it only claims a codec
+ * when the T-code range is a strong, unambiguous family signal; otherwise it returns
+ * `undefined` and lets {@link classify} apply the camera default.
+ *
+ * Known T-code families (case-insensitive):
+ *  - `T85xx` / `T852x` / `T850x` → **lock** (Smart Lock R-series, video lock, etc.),
+ *    EXCEPT `T8520`-prefixed which can be lock variants — still lock.
+ *  - `T74xx` → **lock** (SmartSafe 7400-series).
+ *  - `T80xx` / `T8001` / `T8002` / `T8010` / `T8030` / `T8023` / `T8025` → **station**
+ *    (HomeBase / HomeBase 2 / 3 / Mini), and `T8N00` (NVR) / `T8E00` (PoE 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).
+ *
+ * @param model product/model code (T-code), e.g. `"T8423"`. `undefined`/empty → `undefined`.
+ * @returns the inferred codec, or `undefined` when the code is unrecognised.
+ */
+export declare function codecFromModel(model: string | undefined): Codec | undefined;
+/**
+ * Resolve a {@link CloudRecord} to its command {@link Codec}.
+ *
+ * Strategy: trust the cloud-provided numeric DeviceType first ({@link codecForType}); if
+ * that is absent/unknown, fall back to the model T-code ({@link codecFromModel}); if both
+ * fail, default to `"camera"` — the most common eufy-security device and a safe read-only
+ * default. **Always** returns a concrete codec.
+ *
+ * @param rec the minimal cloud record slice (deviceType + model are what matter here).
+ * @returns the resolved codec (never `undefined`).
+ */
+export declare function classify(rec: CloudRecord): Codec;

package/dist/model/clean-record-detail.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The per-run detail blob a {@link CleanRecord} points at — map and statistics for one cleaning run.
+ *
+ * `get_device_clean_record_list` answers a list of runs, each carrying a `downloadUrl`. The bytes
+ * behind that URL are NOT a bare protobuf: they arrive inside the vendor's own container, with a magic
+ * header, a length, and a trailing checksum. This owns both halves — unwrapping the container and
+ * reading the message inside it — and neither fetches the URL nor decides whether it is safe to.
+ *
+ * Fetching stays with the caller on purpose: the host these URLs point at is unconfirmed, and this
+ * client's binary path is host-allowlisted with SSRF checks by design. Handing the SDK a URL to fetch
+ * would route around a control that exists for a reason.
+ *
+ * @module model/clean-record-detail
+ */
+import type { RawDpCodec } from "../core/contracts.js";
+/** Why a run ended, as the vendor's `finish_reason` reports it. */
+export declare const CLEAN_FINISH_REASONS: readonly ["completed", "manual", "lowPower", "exception"];
+export type CleanFinishReason = (typeof CLEAN_FINISH_REASONS)[number];
+/** One completed run's statistics, decoded from its detail blob. */
+export interface CleanRecordDetail {
+    /** When the run started, in unix SECONDS. */
+    readonly startTime: number;
+    /** When the run ended, in unix seconds. */
+    readonly endTime: number;
+    /** How long the run took, in seconds. */
+    readonly duration: number;
+    /** Area covered, in the unit the device reports it in (m² on every model seen so far). */
+    readonly area: number;
+    /** The cleaning type the run used, as the vendor's raw enum index. */
+    readonly cleanType: number;
+    /** Why the run ended. `undefined` when the device reported a value this version does not name. */
+    readonly finishReason: CleanFinishReason | undefined;
+}
+/**
+ * Unwrap the vendor's container and hand back the protobuf inside it, or `undefined`.
+ *
+ * The container is `0xAA 0x01`, a length, the message, then a two-byte big-endian checksum over every
+ * byte before it. **The width of the length field is not documented**, so rather than assume one, this
+ * tries the plausible widths and keeps the one whose checksum verifies — the checksum is the oracle,
+ * and a wrong guess about the length fails it rather than producing a plausible wrong message.
+ *
+ * That is the whole reason this validates instead of parsing optimistically: a run's statistics that
+ * are quietly wrong are worse than statistics a caller could not read.
+ */
+export declare function unwrapCleanRecordBlob(blob: Uint8Array): Uint8Array | undefined;
+/**
+ * Decode one run's detail blob into a {@link CleanRecordDetail}.
+ *
+ * `codec` is the same {@link RawDpCodec} the capabilities read DP payloads with — passed in rather
+ * than imported, because the implementation lives in the transport layer and this one does not reach
+ * across that line.
+ *
+ * Every field defaults to `0` when the message omits it: proto3 omits a zero, so a run that covered no
+ * area and one that said nothing about area are the same bytes, and `0` is the honest reading of both.
+ * `finishReason` is the exception — an index this version cannot name answers `undefined` rather than
+ * being flattened onto a neighbouring reason.
+ *
+ * Returns `undefined` when the container fails its checksum or the bytes inside are not a message —
+ * never throws, and never a partial read.
+ *
+ * **`Extra` is not decoded.** The message carries a nested `Extra { mode, mus, error_code, prompt_code }`
+ * whose own field number within `CleanRecordDesc` is not recorded in any source this SDK can point at.
+ * Reading it would mean picking a number, and a wrong one would silently report another field's bytes.
+ */
+export declare function parseCleanRecordDetail(blob: Uint8Array, codec: RawDpCodec): CleanRecordDetail | undefined;

package/dist/model/clean-records.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Cleaning-history records — the parsed result of a `get_device_clean_record_list` call.
+ *
+ * The vendor keeps one record per completed run: when it started, and a URL to a binary detail blob
+ * holding the run's map and statistics. This parses the LIST; the blob behind `downloadUrl` is not
+ * fetched here, because the host it points at has not been confirmed and the SDK's binary download
+ * path is host-allowlisted.
+ *
+ * Mirrors `capabilities/dp-catalog.ts`: the transport fetches the raw response and this owns the shape,
+ * so `model/` never learns how the call is signed and `transport/` never learns what a record means.
+ *
+ * @module model/clean-records
+ */
+/** One completed cleaning run, as the cloud lists it. */
+export interface CleanRecord {
+    /** The vendor's record id — what a delete call would name. */
+    readonly id: number;
+    /** When the run was recorded, in unix SECONDS (not milliseconds). */
+    readonly createTime: number;
+    /** When the record was last modified, in unix seconds. */
+    readonly updateTime: number;
+    /**
+     * URL of the run's binary detail blob — map and per-run statistics.
+     *
+     * Handed over rather than fetched: its host is unconfirmed, and the blob is a framed container
+     * rather than a bare protobuf, so decoding it needs evidence this SDK does not have yet.
+     */
+    readonly downloadUrl: string;
+    /** The vendor's storage path for the same blob. Empty when the response omits it. */
+    readonly filePath: string;
+    /**
+     * The vendor's opaque `extend` string, passed through verbatim.
+     *
+     * Its contents are not specified anywhere this SDK can point at, so it is deliberately NOT parsed —
+     * a guessed shape here would be a wire claim with no evidence behind it.
+     */
+    readonly extend: string;
+}
+/** A page of cleaning history, plus how many records exist in total. */
+export interface CleanRecordPage {
+    /** The page as the cloud ordered it. Nothing here re-sorts, so the order is the gateway's contract. */
+    readonly records: readonly CleanRecord[];
+    /**
+     * Total records the account holds for this device — page through with `page` until it is reached.
+     *
+     * Falls back to this page's own record count when the response states no total, which can UNDERSTATE
+     * if a malformed record was skipped. That is the safe direction: a caller pages until it reaches the
+     * total, so a low figure ends the walk early rather than looping for records that never arrive.
+     */
+    readonly total: number;
+}
+/** Returned whenever the call fails or the response shape is not recognised. */
+export declare const EMPTY_CLEAN_RECORD_PAGE: CleanRecordPage;
+/**
+ * Parse a `get_device_clean_record_list` response into a {@link CleanRecordPage}.
+ *
+ * `raw` is the response's `data` object, already unwrapped by the transport — so the array sits at the
+ * top level under `clean_record_list`, beside `total`.
+ *
+ * A record without a usable `id` is skipped rather than admitted with a fabricated one: the id is what
+ * identifies the run, and a record that cannot be named is not a record a caller can act on. Every
+ * other field degrades to a default, so one odd entry never costs the whole page.
+ *
+ * `user_id` and `device_sn` are present in the response and deliberately not surfaced — the caller
+ * already knows which device it asked about, and the account id is not this type's business.
+ *
+ * Returns {@link EMPTY_CLEAN_RECORD_PAGE} on any shape mismatch — never throws.
+ */
+export declare function parseCleanRecords(raw: unknown): CleanRecordPage;

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

@@ -0,0 +1,73 @@
+/** The evidence a family decision needs — a structural subset of `CommandContext`. */
+export interface FamilyContext {
+    /** eufy vendor DeviceType, when known (undefined ⇒ unknown ⇒ don't guess). */
+    deviceType?: number;
+    /** Model / T-code, when known. */
+    model?: string;
+    /**
+     * API category string — e.g. `"eufy_home"`, `"eufy_home_tuya"`, `"eufy_security"`. Supplied by
+     * the mega `get_devs_list` response; absent in unit-test contexts that build a minimal context
+     * without a real API record. Used as the PRIMARY transport discriminator for the clean line:
+     * `"eufy_home_tuya"` devices are on the ThingClips/Tuya Cloud platform, not Anker AIoT MQTT.
+     */
+    category?: string;
+}
+/** Indoor cams, incl. indoor pan/tilt + S350/E30/C-series + mini. */
+export declare const INDOOR_CAMERA_TYPES: ReadonlySet<number>;
+/** Indoor pan/tilt S350 family. */
+export declare const INDOOR_PT_S350_TYPES: ReadonlySet<number>;
+/** Outdoor pan/tilt + solo-PT. */
+export declare const OUTDOOR_PT_TYPES: ReadonlySet<number>;
+/** Floodlight cams. */
+export declare const FLOODLIGHT_TYPES: ReadonlySet<number>;
+/** Wall-light cams. */
+export declare const WALL_LIGHT_TYPES: ReadonlySet<number>;
+/**
+ * HomeBase-family hubs — the station-class devices with a built-in **speaker + alarm siren**, so
+ * they own the hub-audio surface (alarm / voice-prompt volume). A deliberate SUBSET of the `station`
+ * codec that EXCLUDES the NVRs (S4 Max, PoE NVR): those resolve to `station` for arming/storage but
+ * have no speaker, so they must NOT expose the hub-audio controls (they'd fire at nothing). The
+ * alarm/prompt wire is verified on HomeBase 3 (HB3); the other hubs share the hub hardware.
+ */
+export declare const HOMEBASE_TYPES: ReadonlySet<number>;
+/** Indoor camera (any indoor variant). */
+export declare const isIndoorCamera: (ctx: FamilyContext) => boolean;
+/** Indoor cost-down "mini" cam. */
+export declare const isIndoorCamMini: (ctx: FamilyContext) => boolean;
+/** Indoor pan/tilt S350 family. */
+export declare const isIndoorPanTiltS350: (ctx: FamilyContext) => boolean;
+/** Outdoor pan/tilt (+ solo-PT) family. */
+export declare const isOutdoorPanTilt: (ctx: FamilyContext) => boolean;
+/** Floodlight cam family. */
+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;
+/** Wired doorbell (DeviceType.DOORBELL). */
+export declare const isWiredDoorbell: (ctx: FamilyContext) => boolean;
+/**
+ * Whether a vacuum uses the **Anker AIoT MQTT** transport (modern DP 150–180 protobuf scheme).
+ *
+ * A **negative exclusion**: returns `false` only for the one confirmed non-AIoT platform
+ * (`"eufy_home_tuya"` — ThingClips/Tuya Cloud). Any absent, unknown, or unrecognised category
+ * defaults to `true`, matching the polarity of `routeCommand` which sends `aiot-dp` to MQTT
+ * unless `category === "eufy_home_tuya"`. The two gates agree: an unknown-category AIoT
+ * vacuum both routes to MQTT *and* has its setters installed.
+ *
+ * | `category`          | platform                           | returns |
+ * | ------------------- | ---------------------------------- | ------- |
+ * | `"eufy_home"`       | Anker AIoT MQTT ✅ confirmed       | `true`  |
+ * | `"eufy_home_tuya"`  | ThingClips/Tuya Cloud ✅ confirmed  | `false` |
+ * | absent / any other  | unknown — default to AIoT          | `true`  |
+ *
+ * Live-confirmed categories sourced from `get_devs_list` dumps: `"eufy_home_tuya"` from a T2266
+ * X8 Pro (2026-08-04). Additional category strings are added here as devices are captured.
+ */
+export declare const isAiotVacuum: (ctx: FamilyContext) => boolean;
+/**
+ * Whether a vacuum is on the **ThingClips/Tuya Cloud** platform (`"eufy_home_tuya"` category).
+ *
+ * The positive complement of the negative-exclusion {@link isAiotVacuum}: returns `true` only for
+ * the one confirmed non-AIoT platform. Used to extend capability `available` guards so Tuya
+ * vacuums receive the same write actions as AIoT ones, routed by the facade's `routeCommand`.
+ */
+export declare const isTuyaVacuum: (ctx: FamilyContext) => boolean;

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

@@ -0,0 +1,123 @@
+/**
+ * eufy **DeviceType** numbers — the single named definition of the vendor's product-type space.
+ *
+ * A `device_type` is an immutable vendor fact (like a command id), NOT capability logic. It is
+ * defined ONCE here and referenced wherever a numeric type would otherwise be a magic number:
+ * codec routing (`classify.ts`) and each capability's detection/wire tables (e.g. `pan-tilt.ts`
+ * `detection.deviceTypes`, `light.ts` switch-format tables). Capability *rules* stay in the
+ * modules; only the number→name mapping lives here.
+ *
+ * This is the **eufy security** DeviceType space (P2P). The RoboVac / clean line is a separate
+ * Tuya ecosystem with no eufy device_type — it's classified by category + T2xxx model code, not by
+ * a number here (see `classify.ts`). Light-cams live here (e.g. WALL_LIGHT_CAM); a hypothetical
+ * pure Tuya bulb would sit outside this space like the vacuum.
+ *
+ * Merged from a third-party reverse-engineering project's device enum + the app's own
+ * `DeviceTypeConstants` — the app is the authority wherever the two disagree.
+ * A `const` object (not a TS `enum`) to match the codebase's `CommandType`/`P2P_CMD` style.
+ *
+ * @module model/device-types
+ */
+export declare const DeviceType: {
+    readonly STATION: 0;
+    readonly CAMERA: 1;
+    readonly SENSOR: 2;
+    readonly FLOODLIGHT: 3;
+    readonly CAMERA_E: 4;
+    readonly DOORBELL: 5;
+    readonly BATTERY_DOORBELL: 7;
+    readonly CAMERA2C: 8;
+    readonly CAMERA2: 9;
+    readonly MOTION_SENSOR: 10;
+    readonly KEYPAD: 11;
+    readonly CAMERA2_PRO: 14;
+    readonly CAMERA2C_PRO: 15;
+    readonly BATTERY_DOORBELL_2: 16;
+    readonly HB3: 18;
+    readonly CAMERA3: 19;
+    readonly WATER_FREEZE_SENSOR_8920: 20;
+    readonly SIREN_SENSOR: 21;
+    readonly SMOKE_SENSOR: 22;
+    readonly CAMERA3C: 23;
+    readonly PROFESSIONAL_247: 24;
+    readonly MINIBASE_CHIME: 25;
+    readonly CAMERA3_PRO: 26;
+    readonly HOMEBASE_MINI: 28;
+    readonly INDOOR_CAMERA: 30;
+    readonly INDOOR_PT_CAMERA: 31;
+    readonly SOLO_CAMERA: 32;
+    readonly SOLO_CAMERA_PRO: 33;
+    readonly INDOOR_CAMERA_1080: 34;
+    readonly INDOOR_PT_CAMERA_1080: 35;
+    readonly FLOODLIGHT_CAMERA_8422: 37;
+    readonly FLOODLIGHT_CAMERA_8423: 38;
+    readonly FLOODLIGHT_CAMERA_8424: 39;
+    readonly INDOOR_OUTDOOR_CAMERA_1080P_NO_LIGHT: 44;
+    readonly INDOOR_OUTDOOR_CAMERA_2K: 45;
+    readonly INDOOR_OUTDOOR_CAMERA_1080P: 46;
+    readonly FLOODLIGHT_CAMERA_8425: 47;
+    readonly OUTDOOR_PT_CAMERA: 48;
+    readonly CAMERA_E40: 49;
+    readonly LOCK_BLE: 50;
+    readonly LOCK_WIFI: 51;
+    readonly LOCK_BLE_NO_FINGER: 52;
+    readonly LOCK_WIFI_NO_FINGER: 53;
+    readonly LOCK_8503: 54;
+    readonly LOCK_8530: 55;
+    readonly LOCK_85A3: 56;
+    readonly LOCK_8592: 57;
+    readonly LOCK_8504: 58;
+    readonly SOLO_CAMERA_SPOTLIGHT_1080: 60;
+    readonly SOLO_CAMERA_SPOTLIGHT_2K: 61;
+    readonly SOLO_CAMERA_SPOTLIGHT_SOLAR: 62;
+    readonly SOLO_CAMERA_SOLAR: 63;
+    readonly SOLO_CAMERA_C210: 64;
+    readonly FLOODLIGHT_CAMERA_8426: 87;
+    readonly SOLO_CAMERA_E30: 88;
+    readonly CAMERA_S4: 89;
+    readonly SMART_DROP: 90;
+    readonly BATTERY_DOORBELL_PLUS: 91;
+    readonly DOORBELL_SOLO: 93;
+    readonly BATTERY_DOORBELL_PLUS_E340: 94;
+    readonly BATTERY_DOORBELL_C30: 95;
+    readonly BATTERY_DOORBELL_C31: 96;
+    readonly SOLOCAM_E42: 98;
+    readonly INDOOR_COST_DOWN_CAMERA: 100;
+    readonly CAMERA_GUN: 101;
+    readonly CAMERA_SNAIL: 102;
+    readonly INDOOR_PT_CAMERA_S350: 104;
+    readonly INDOOR_PT_CAMERA_E30: 105;
+    readonly CAMERA_FG: 110;
+    readonly CAMERA_4G_S330: 111;
+    readonly SIREN_SENSOR_E20: 123;
+    readonly ENTRY_SENSOR_E20: 126;
+    readonly PIR_SENSOR_E20: 127;
+    readonly CAMERA_GARAGE_T8453_COMMON: 131;
+    readonly CAMERA_GARAGE_T8452: 132;
+    readonly CAMERA_GARAGE_T8453: 133;
+    readonly SMART_SAFE_7400: 140;
+    readonly SMART_SAFE_7401: 141;
+    readonly SMART_SAFE_7402: 142;
+    readonly SMART_SAFE_7403: 143;
+    readonly WALL_LIGHT_CAM: 151;
+    readonly SMART_TRACK_LINK: 157;
+    readonly SMART_TRACK_CARD: 159;
+    readonly TRACKER_87B4: 161;
+    readonly TRACKER_87B5: 162;
+    readonly LOCK_8502: 180;
+    readonly LOCK_8506: 184;
+    readonly LOCK_8531: 189;
+    readonly LOCK_85L0: 201;
+    readonly LOCK_85D0: 202;
+    readonly LOCK_85V0: 203;
+    readonly LOCK_85P0: 209;
+    readonly NVR_S4_MAX: 300;
+    readonly CAMERA_POE_S4: 301;
+    readonly WALL_LIGHT_CAM_81A0: 10005;
+    readonly INDOOR_8W11: 10006;
+    readonly INDOOR_PT_CAMERA_C220: 10008;
+    readonly INDOOR_PT_CAMERA_C210: 10009;
+    readonly INDOOR_PT_CAMERA_C220_V2: 10010;
+    readonly INDOOR_PT_CAMERA_C220_V3: 10011;
+    readonly CAMERA_C35: 10035;
+};