@mega-yfue/eufy-sdk 0.6.0-beta.40 → 0.6.0-beta.42

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

@@ -21,6 +21,7 @@ export { unobservableMembers, unreflectedMembers } from "./members.js";
 export { Watermark, type WatermarkValue, NightVision, type NightVisionValue, RecordingQuality, type RecordingQualityName, RECORDING_QUALITY_TIERS, StreamingQuality, type StreamingQualityName, STREAMING_QUALITY_TIERS, resolveStreamingQuality, resolveStreamingQualityTier, resolveRecordingQuality, resolveRecordingQualityValue, resolveRecordingQualityTier, } from "./camera.js";
 export { WorkingMode, PowerSource, resolveWorkingMode, resolveWorkingModeValue, cameraPowerTier, WORKING_MODE_MAPS, type WorkingModeName, type PowerSourceName, } from "./battery.js";
 export { type DpCatalog, EMPTY_DP_CATALOG } from "./dp-catalog.js";
+export type { ThingAction, ThingBundle, ThingCondition, ThingConditions, ThingDescription, ThingEvent, ThingMember, ThingProperty, } from "./thing-description.js";
 import type { PtzActions } from "./ptz.js";
 import type { LightActions } from "./light.js";
 import type { RgbColor, SmartLightActions } from "./smart-light.js";

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

@@ -46,6 +46,14 @@ export interface ValueMember {
      * static `enumValues` (or none) in place.
      */
     enumValuesFor?: (ctx: AvailabilityContext) => Record<number, string> | undefined;
+    /**
+     * The product thing-description identifiers this value is, in the app's order of preference
+     * (`nightvision_type_new` before `nightvision_type`), each grounded in the products' settings bundles
+     * reading it from this member's param. For an enum member without an {@link enumValuesFor} answer, the
+     * first one the device's resolved description has gives the options: its members' wire values that
+     * {@link enumValues} names, or 0 and 1 for a `bool` property.
+     */
+    thing?: readonly string[];
     provenance?: PropertySpec["provenance"];
     invert?: boolean;
     /** Per-device read polarity; undefined retains the static default. */
@@ -536,9 +544,9 @@ export type Surface<M extends Members> = {
 /**
  * Resolve a member's enum options for a device, evaluating `enumValuesFor` at most once. Returns the
  * options and whether they came from the device context (`dynamic`), so the option set and the enum
- * `kind` both come from a single result. A context domain (`enumValuesFor(ctx)`) is
- * returned when present; absent that (or with no context) the static `enumValues`; a member with
- * neither yields no options.
+ * `kind` both come from a single result. A context domain — `enumValuesFor(ctx)`, else what the
+ * member's `thing` gives on the device — is returned when present; absent that (or with no context) the
+ * static `enumValues`; a member with neither yields no options.
  */
 export declare function resolvedEnum(m: ValueMember, ctx?: AvailabilityContext): {
     values?: Record<number, string>;
@@ -601,6 +609,13 @@ export declare function installs(m: {
     readAvailable?: ValueMember["readAvailable"];
     readAliases?: ValueMember["readAliases"];
 }, ctx: CommandContext): boolean;
+/**
+ * Whether a command of this kind can route over the device's primary transport. The client decides what
+ * a transport refuses — `ctx.refusedCommandKinds`, the kinds the device's primary transport cannot carry
+ * — so the model keeps no copy of the routing table: a kind absent from the set (and the whole set, the
+ * P2P default `undefined`) routes.
+ */
+export declare function kindRoutable(kind: Command["kind"], ctx: AvailabilityContext): boolean;
 /**
  * Bind the table: evidence-gated getters, derived setters, momentary actions.
  *

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

@@ -1,5 +1,5 @@
 import { type Surface } from "./members.js";
-import type { CapabilityModule, CommandContext } from "./types.js";
+import type { AvailabilityContext, CapabilityModule, CommandContext } from "./types.js";
 import type { Command } from "../../core/contracts.js";
 /**
  * The P2P **feature-command ids** this motion capability drives. Capability-owned wire vocabulary
@@ -125,6 +125,13 @@ export declare const MOTION_CMD: {
      * as a `1700` control payload carrying an index rather than the `1350` envelope its siblings take.
      */
     readonly INDOOR_SENSITIVITY_INDEX: 6041;
+    /**
+     * Motion detection on-off on a T8410 (app `CMD_INDOOR_DET_SET_MOTION_DETECT_ENABLE`). `1700` control
+     * payload `{"commandType":6040,"data":{"enable":0,"quality":0,"status":0|1,"value":0}}`.
+     *
+     * ⚠️ Replay + readback confirmed on a standalone and a HomeBase 3-attached T8410, NOT byte-captured.
+     */
+    readonly INDOOR_MOTION_ENABLE: 6040;
     /**
      * Detection sensitivity a solo camera REPORTS (app `SET_MOTION_DETECTION_SENSITIVITY_SOLO`). It does
      * not accept writes on this id — the write goes to {@link MOTION_SENSITIVITY}, which is why a scale
@@ -187,6 +194,8 @@ export declare function decodeAiDetectType(value: number): AiDetectFlags;
  * `ai_detect_type` field of the JSON object form. Answers `undefined` for any other shape.
  */
 declare function decodeAiDetectTypeParam(raw: unknown): number | undefined;
+/** A T8410, whose motion switch is {@link MOTION_CMD.INDOOR_MOTION_ENABLE} rather than {@link MOTION_CMD.CAMERA_PIR}. */
+declare function isT8410(ctx: AvailabilityContext): boolean;
 /**
  * Decode a `radar_wd_switch` (2706, loitering) read the way the app does:
  * `typeof v === "object" ? v.radar_wd_switch : v`. The device may store it as a JSON object
@@ -227,7 +236,12 @@ export declare const MOTION_MEMBERS: {
         readonly type: "bool";
         readonly kind: "boolean";
         readonly provenance: "verified";
-        readonly description: "Motion/PIR detection enabled (verified: param 1011 = CAMERA_PIR).";
+        readonly readAvailable: (ctx: AvailabilityContext) => boolean;
+        readonly readAliases: readonly [{
+            readonly paramType: 6040;
+            readonly available: typeof isT8410;
+        }];
+        readonly description: string;
         readonly write: (v: string | number | boolean, ctx: CommandContext) => Command;
         readonly writeAs: "setDetection";
     };

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 { AvailabilityContext, CapabilityModule, CommandContext } from "./types.js";
+import type { 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,13 +93,6 @@ 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.
  *
@@ -134,7 +127,6 @@ 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
@@ -231,4 +223,3 @@ export declare const RTSP_MEMBERS: {
  * rather than a model table.
  */
 export declare const RTSP: CapabilityModule;
-export {};

package/dist/model/capabilities/thing-description.d.ts

@@ -0,0 +1,137 @@
+/**
+ * A product's **thing description** — the per-product model the vendor's things service returns from
+ * `app/things/get_things_list` and the v6 app builds its device settings from.
+ *
+ * One description per product code. Its properties are the product's settings and states, keyed by a
+ * stable `identifier` (`nightvision_type`, `led_on_off`, …); its actions and events are keyed the same
+ * way. A property declares its access (`R` read-only, `RW` writable), its data type and, per type, its
+ * specs: an enum lists its members, an `int` its bounds, most types a default. Each enum member carries
+ * the app's UI value (`value`), its label (`desc`) and — for a member that maps onto the device's own
+ * wire — that wire value (`associatedValue`); a member without one is a named constant, not a mode.
+ *
+ * A property may exist in several **variants**: `identifier`, `identifier__v1`, `identifier__v2`, …, each
+ * gated by conditions on the device (`read_conditions`, `available_conditions`): its firmware
+ * (`device_version`), its station's serial and firmware (`parent_sn`, `parent_version`), its own serial
+ * (`device_sn`), another property's value (`associated_field`), the account's country (`user_country`)
+ * or the app's SDK version (`sdk_version`). A condition list is held here as data, exactly as listed.
+ *
+ * `profile` names the product's settings bundle: the app's own per-product code mapping each property
+ * to the commands it reads and writes. The vendor's member key is spelled `eunmList`; the parser reads
+ * that spelling.
+ *
+ * Everything is parsed defensively — a malformed entry is skipped, never thrown on — and held as plain
+ * null-prototype objects, so a description serialises as it is and a lookup never reaches a prototype.
+ *
+ * @module model/capabilities/thing-description
+ */
+/** One condition of a condition list: `type` compared by `qualifier` against `value`. */
+export interface ThingCondition {
+    /** What is compared: `device_version`, `parent_sn`, `parent_version`, `device_sn`, `associated_field`, `user_country`, `sdk_version`, … */
+    readonly type: string;
+    /** How: `=`, `<`, `<=`, `>=` (versions, values), `RE` (regular expression), `SE` (regular expression on the device serial). */
+    readonly qualifier: string;
+    readonly value: string;
+    /** For `associated_field`: the identifier of the property whose value is compared. */
+    readonly propId?: string;
+}
+/** A condition list as the description gives it: its entries, each a set of conditions. */
+export type ThingConditions = readonly (readonly ThingCondition[])[];
+/** One member of an enum property. */
+export interface ThingMember {
+    /** The app's UI value for this member. */
+    readonly value: string;
+    /** The value on the device's own wire (`associatedValue`); absent for a named constant. */
+    readonly wireValue?: string;
+    readonly desc: string;
+    readonly isDefault: boolean;
+}
+/** One property of a thing description. */
+export interface ThingProperty {
+    readonly identifier: string;
+    /** `R` read-only or `RW` writable, as declared. */
+    readonly accessMode: string;
+    /** `bool`, `int`, `string`, `text`, `enum`, `tenum`, `ienum`, … */
+    readonly type: string;
+    /** An enum's members in the listed order; empty for any other type. */
+    readonly members: readonly ThingMember[];
+    readonly defaultValue?: string;
+    readonly min?: number;
+    readonly max?: number;
+    readonly step?: number;
+    readonly unit?: string;
+    readonly readConditions: ThingConditions;
+    readonly writeConditions: ThingConditions;
+    readonly availableConditions: ThingConditions;
+}
+/** One action of a thing description; its input and output types, when declared. */
+export interface ThingAction {
+    readonly identifier: string;
+    readonly inputType?: string;
+    readonly outputType?: string;
+    readonly availableConditions: ThingConditions;
+}
+/** One event of a thing description; its output type and default (often a list of param ids), when declared. */
+export interface ThingEvent {
+    readonly identifier: string;
+    readonly eventType: string;
+    readonly outputType?: string;
+    readonly defaultValue?: string;
+    readonly availableConditions: ThingConditions;
+}
+/** A product's settings bundle, as `profile` names it. */
+export interface ThingBundle {
+    readonly id: string;
+    /** URL of the bundle's script. */
+    readonly path: string;
+    readonly zipId: string;
+    /** URL of the bundle's archive. */
+    readonly zipPath: string;
+}
+/** A product's thing description. */
+export interface ThingDescription {
+    readonly productCode: string;
+    readonly version: string;
+    /** Unix seconds of the last change, as the service states it — the value `code_time_map` sends back. */
+    readonly updateTime: number;
+    readonly largeVersion: number;
+    readonly largeVersionUpdateTime: number;
+    readonly bundle: ThingBundle;
+    readonly properties: Readonly<Record<string, ThingProperty>>;
+    readonly actions: Readonly<Record<string, ThingAction>>;
+    readonly events: Readonly<Record<string, ThingEvent>>;
+}
+/**
+ * What a device's conditions are evaluated against. `stationSerial` is the serial of the station the
+ * device is reached through — its own serial when it stands alone — and `stationFirmwareVersion` that
+ * station's firmware. An `associated_field` / `parent_associated_field` condition compares an empty
+ * string. `params` are the device's reported `param_type → value`, for `camera_info`.
+ */
+export interface ThingFacts {
+    readonly serial?: string;
+    readonly firmwareVersion?: string;
+    readonly stationSerial?: string;
+    readonly stationFirmwareVersion?: string;
+    readonly country?: string;
+    readonly params?: Readonly<Record<number, string>>;
+}
+/**
+ * Whether a condition list passes for a device, as the app decides it: an empty list passes; otherwise
+ * any entry passing is enough, and an entry passes when every one of its conditions does.
+ */
+export declare function conditionsPass(list: ThingConditions, facts: ThingFacts): boolean;
+/**
+ * A product's description **as one device sees it**, resolved the way the v6 app resolves each lookup.
+ * Properties are keyed by their base identifier and hold the variant this device uses: among the
+ * `identifier__vN` whose read conditions pass (a variant without read conditions is never chosen), the
+ * one with the most conditions, the first listed on a tie, else the base `identifier`. The chosen
+ * property's `identifier` keeps the variant's name. A property whose available conditions fail is left
+ * out, as are actions and events whose available conditions fail. A property whose write conditions fail
+ * is held as `R`.
+ */
+export declare function resolveThing(td: ThingDescription, facts: ThingFacts): ThingDescription;
+/**
+ * Parse an `app/things/get_things_list` reply into each listed product's {@link ThingDescription}, keyed
+ * by `profile.product_code`. `raw` is the reply's `data` object, holding `things_list`. An entry without a
+ * product code is skipped; any other shape mismatch yields an empty result — never throws.
+ */
+export declare function parseThingsList(raw: unknown): Readonly<Record<string, ThingDescription>>;

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

@@ -1,4 +1,5 @@
 import type { DpCatalog } from "./dp-catalog.js";
+import type { ThingDescription } from "./thing-description.js";
 /**
  * Capability-module contract — the extended shape each `capabilities/<cap>.ts` file implements.
  *
@@ -238,6 +239,12 @@ export interface AvailabilityContext {
      * `undefined` as an empty set — `ctx.paramIds?.has(dp) ?? false`.
      */
     paramIds?: ReadonlySet<number>;
+    /**
+     * The product's thing description, when the cloud returned one for its product code: which values each
+     * named property offers on this product. Absent when not fetched — fall back to static defaults rather
+     * than treating the device as incapable.
+     */
+    things?: ThingDescription;
     /**
      * Whether the device hangs off a HomeBase (a `parent_sn` other than its own) rather than standing
      * alone. A DEVICE fact, not a transport one — the same class of routing evidence as {@link hasP2p} —
@@ -247,6 +254,8 @@ export interface AvailabilityContext {
      * cannot do what its name promises there.
      */
     homeBaseAttached?: boolean;
+    /** The command kinds this device's primary transport REFUSES (a setter emitting one is withheld); `undefined` when it refuses none (the P2P default). Set by the client, which owns the routing. */
+    refusedCommandKinds?: ReadonlySet<Command["kind"]>;
     /** Serial of the covering station, when the device record names one. */
     stationSerial?: string;
     /**

package/dist/model/inspect.d.ts

@@ -14,6 +14,7 @@
  * @module model/inspect
  */
 import type { CloudRecord, PropertySource, PropertyValueType, RegistryEntry, ResolvedDevice } from "./types.js";
+import type { ThingDescription } from "./capabilities/thing-description.js";
 import { type ParamNamespace } from "./param-namespace.js";
 /** One reported param, cross-referenced against our dictionary. */
 export interface ParamInspection {
@@ -53,6 +54,8 @@ export interface DeviceInspection {
     registrySnippet: string;
     /** Paste-ready param-dictionary lines for the unknown params. */
     dictionarySnippet: string;
+    /** The product's thing description, as the record carries it. Absent when the cloud returned none for the product code. */
+    things?: ThingDescription;
 }
 /**
  * Inspect a cloud device record and produce the enrichment report. `rec.params` should be the

package/dist/model/types.d.ts

@@ -13,6 +13,7 @@
  *
  * This file is the integration contract: every other `src/model/*` module imports from here.
  */
+import type { ThingDescription } from "./capabilities/thing-description.js";
 /**
  * Command-codec families (axis B2). One per genuinely-different wire protocol.
  *
@@ -300,6 +301,8 @@ export interface CloudRecord {
      * evidence an availability gate on such a param is decided from.
      */
     dpParams?: Record<number, string>;
+    /** The product's thing description, when the cloud returned one for {@link model}. */
+    things?: ThingDescription;
 }
 /** The fully-resolved device shape produced by the 3-tier resolver. */
 export interface ResolvedDevice {

package/dist/transport/http/mega-client.d.ts

@@ -284,6 +284,8 @@ export declare class MegaHttpClient {
     } | undefined;
     /** The active region shard (e.g. `"eu-pr"`, `"us-pr"`), set after {@link login} or a region override. */
     get regionShard(): RegionShard;
+    /** The account's country code as configured (e.g. `"FR"`), the one logins are sent with. */
+    get countryCode(): string;
     /**
      * The shard the estimated domain names (`…-ie-…`/`…-ie.` → `ie-pr`), else {@link regionShard}. The
      * eu/us classification cannot name shards like `ie-pr`.
@@ -390,6 +392,16 @@ export declare class MegaHttpClient {
      * can adapt to the (not-yet-pinned) field layout.
      */
     getProductDataPoint<T = unknown>(code: string): Promise<T>;
+    /**
+     * Fetch the **thing descriptions** of the given product codes from the mega `things` service: per
+     * product, every named property with its type and offered values, its actions and events. The v6 app
+     * fetches the same list for the products an account holds and reads each setting's options from it.
+     * Product-level data, not account data. `codeTimeMap` names, per product code, the `update_time` of the
+     * description already held: a product whose description has not changed since comes back with that
+     * `update_time` and no properties, one that has (or is not named) comes back in full. Returns the raw
+     * `data`.
+     */
+    getThingsList<T = unknown>(productCodes: readonly string[], codeTimeMap?: Readonly<Record<string, number>>): Promise<T>;
     /**
      * Fetch the **live param list** from the mega `devicemanage` service. Body keys off a
      * `device_sns` ARRAY (a bare `device_sn` 400s with "type mismatch"). Each returned entry is

package/dist/transport/rtc/command-router.d.ts

@@ -71,6 +71,13 @@ export interface RtcCommandRouterDeps {
     ffmpegPath?: string;
     createSession?: (opts: RtcSessionOptions) => RtcSession;
 }
+/**
+ * The portal command kinds the RTC control channel frames — `set-payload` over the `1350` envelope,
+ * `set-json` over the `1700` one, and nothing else. The single source for both {@link
+ * RtcCommandRouter.dispatchCommand}'s guard and the client's portal-reach, so the two cannot disagree
+ * on what the channel carries.
+ */
+export declare const RTC_CONTROL_COMMAND_KINDS: ReadonlySet<Command["kind"]>;
 export declare class RtcCommandRouter {
     private readonly deps;
     private readonly sessions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mega-yfue/eufy-sdk",
-  "version": "0.6.0-beta.40",
+  "version": "0.6.0-beta.42",
   "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",
@@ -54,6 +54,7 @@
     "dev": "tsc -p tsconfig.build.json --watch",
     "typecheck": "tsc --noEmit",
     "typecheck:examples": "tsc -p examples/tsconfig.json",
+    "typecheck:scripts": "tsc -p scripts/tsconfig.json",
     "test": "vitest run --passWithNoTests",
     "test:watch": "vitest",
     "format": "prettier --write .",
@@ -65,7 +66,7 @@
     "guard:lines": "bash scripts/ci/guard-lines.sh",
     "check:esm": "node -e \"import('./dist/index.js').then(m=>console.log('ESM OK:',Object.keys(m).length,'exports'))\"",
     "check:snippets": "node scripts/ci/check-doc-snippets.mjs",
-    "verify": "npm run format:check && npm run typecheck && npm run guard:decorrelation && npm run guard:lines && npm run guard:docrefs && npm run guard:consumer-agnostic && npm run guard:capability-ownership && npm run build && npm run check:esm && npm run check:snippets && npm run typecheck:examples && npm test",
+    "verify": "npm run format:check && npm run typecheck && npm run guard:decorrelation && npm run guard:lines && npm run guard:docrefs && npm run guard:consumer-agnostic && npm run guard:capability-ownership && npm run build && npm run check:esm && npm run check:snippets && npm run typecheck:examples && npm run typecheck:scripts && npm test",
     "release": "bash scripts/release.sh"
   },
   "engines": {