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

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

@@ -0,0 +1,218 @@
+import { isHomeBase } from "../device-family.js";
+import { type Surface } from "./members.js";
+import type { AvailabilityContext, CapabilityModule, CommandContext } from "./types.js";
+import type { Command } from "../../core/contracts.js";
+/**
+ * The siren's **state-backed param ids** — each is a param the device reports (and some are also
+ * writable). Named `SIREN_PARAM` vs `SIREN_CMD` below (momentary triggers with no reported state) so
+ * the split the code implements is explicit. Surveyed + write-captured on a real T90R0
+ * (`SIREN_SENSOR_E20`, 2026-08-03).
+ */
+export declare const SIREN_PARAM: {
+    /** Whether the siren is sounding (app `APP_CMD_DEV_RING_STATUS`). 1 = sounding, 0 = silent. */
+    readonly RING_STATUS: 61008;
+    /** Alarm volume as a device level (app `APP_CMD_SIREN_SENSOR_SET_ALARM_VOL`). See {@link SirenVolume}. */
+    readonly ALARM_VOLUME: 1825;
+    /** Seconds an alarm sounds before stopping itself (app `APP_CMD_DEV_ALARM_TIMEOUT`). */
+    readonly ALARM_TIMEOUT: 61006;
+    /** Do-not-disturb (app `APP_CMD_SENSOR_NOT_DISTURB`). */
+    readonly NOT_DISTURB: 1828;
+};
+/**
+ * The siren's **write-only command ids**. Momentary actions install only when their family-specific
+ * reported evidence and topology gates hold.
+ */
+export declare const SIREN_CMD: {
+    /** Sound the siren briefly as a test (app `APP_CMD_SIREN_SENSOR_ALARM_TEST`). */
+    readonly ALARM_TEST: 1826;
+    /** Manually stop a sounding alarm (app `APP_CMD_SIREN_SENSOR_MANUAL_STOP_ALARM`). */
+    readonly MANUAL_STOP: 1871;
+    /** Station-family HomeBase duration alarm, verified live on T8010 (app `SET_TONE_FILE`). */
+    readonly HOMEBASE_TONE: 1201;
+    /** HomeBase alarm volume percentage (app `CMD_SET_HUB_SPK_VOLUME`). */
+    readonly HUB_SPK_VOLUME: 1235;
+    /** HomeBase alarm-tone selection (app `APP_CMD_HUB_ALARM_TONE`). */
+    readonly HUB_ALARM_TONE: 1281;
+    /** Attached-camera duration alarm, verified live on T8114 and T8210 (app `SET_DEVS_TONE_FILE`). */
+    readonly CAMERA_TONE: 1202;
+};
+/**
+ * Siren alarm volume — a small device level 1-3 (Low/Mid/High), NOT a percentage. Pass a value to
+ * `setVolume`.
+ */
+export declare const SirenVolume: {
+    readonly Low: 1;
+    readonly Mid: 2;
+    readonly High: 3;
+};
+/** A siren volume level — the value side of {@link SirenVolume}. */
+export type SirenVolumeValue = (typeof SirenVolume)[keyof typeof SirenVolume];
+/**
+ * The alarm-duration presets the app offers, in seconds (1/5/10/15 minutes). These are the only
+ * values captured, so `setAlarmDuration` accepts exactly these (rejecting others),
+ * the same way the arming capability makes its delay presets the parameter type.
+ */
+export declare const SirenAlarmDuration: {
+    readonly Min1: 60;
+    readonly Min5: 300;
+    readonly Min10: 600;
+    readonly Min15: 900;
+};
+/** A siren alarm duration in seconds — the value side of {@link SirenAlarmDuration}. */
+export type SirenAlarmDurationValue = (typeof SirenAlarmDuration)[keyof typeof SirenAlarmDuration];
+/** HomeBase alarm tone options, 1-indexed; both options were confirmed on a T8030. */
+export declare const HubAlarmTone: {
+    readonly Tone1: 1;
+    readonly Tone2: 2;
+};
+/** A HomeBase alarm tone option. */
+export type HubAlarmToneValue = (typeof HubAlarmTone)[keyof typeof HubAlarmTone];
+/**
+ * Bound siren controls — the object returned by `dev.siren()`.
+ *
+ * Everything is derived from `SIREN_MEMBERS`. Each optional member is installed only for the exact
+ * standalone-siren, HomeBase, or camera evidence that proves its wire contract.
+ */
+export type SirenActions = Surface<typeof SIREN_MEMBERS>;
+/** Whether this context belongs to the sensor codec used by standalone sirens. */
+declare function isSensorCodec(ctx: AvailabilityContext): boolean;
+/** Whether a sensor-codec device reports the combined standalone siren evidence. */
+declare function isEvidencedStandaloneSiren(ctx: CommandContext): boolean;
+/**
+ * Every audible alarm-output feature, declared once. Standalone sirens expose observed state,
+ * configuration, test, and stop; evidenced HomeBases expose alarm configuration plus trigger/stop;
+ * verified attached cameras expose trigger/stop only.
+ *
+ * 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 SIREN_MEMBERS: {
+    /**
+     * Authoritative sounding state reported by a standalone siren. HomeBase and camera command
+     * acknowledgements do not install or update this read.
+     */
+    readonly active: {
+        readonly param: 61008;
+        readonly property: "siren";
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "verified";
+        readonly available: typeof isSensorCodec;
+        readonly description: string;
+    };
+    /**
+     * Rejected, not clamped, outside the 1-3 set: the write is fire-and-forget, so an out-of-range level
+     * would look like it worked.
+     */
+    readonly volume: {
+        readonly param: 1825;
+        readonly property: "sirenVolume";
+        readonly type: "number";
+        readonly kind: "scalar";
+        readonly provenance: "verified";
+        readonly available: typeof isSensorCodec;
+        readonly requires: readonly [1825];
+        readonly enumValues: Record<number, string>;
+        readonly args: readonly [{
+            readonly name: "level";
+            readonly kind: "scalar";
+            readonly description: "A device level 1-3 (Low/Mid/High), not a percentage.";
+        }];
+        readonly description: string;
+        readonly write: (v: string | number | boolean, ctx: CommandContext) => Command | undefined;
+    };
+    /** Only the four captured presets are accepted: no capture supports an arbitrary duration. */
+    readonly alarmDuration: {
+        readonly param: 61006;
+        readonly type: "number";
+        readonly unit: "s";
+        readonly kind: "seconds";
+        readonly provenance: "verified";
+        readonly available: typeof isSensorCodec;
+        readonly requires: readonly [61006];
+        readonly enumValues: Record<number, string>;
+        readonly args: readonly [{
+            readonly name: "seconds";
+            readonly kind: "seconds";
+            readonly description: "One of the app's presets: 60/300/600/900.";
+        }];
+        readonly description: string;
+        readonly write: (v: string | number | boolean, ctx: CommandContext) => Command | undefined;
+    };
+    /**
+     * Read-only: `apk` provenance means the id comes from the disassembled app and the only live evidence
+     * is a T90R0 reporting 0, which fixes neither the polarity's other value nor a write frame. Typed
+     * `bool` on the app's own naming; do not add a setter until a toggle is captured.
+     */
+    readonly doNotDisturb: {
+        readonly param: 1828;
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "apk";
+        readonly available: typeof isSensorCodec;
+        readonly description: "Do-not-disturb (1828 APP_CMD_SENSOR_NOT_DISTURB). Observed 0 on a T90R0.";
+    };
+    /** HomeBase alarm volume is a percentage on a station-scalar wire, unlike standalone level 1-3. */
+    readonly alarmVolume: {
+        readonly param: 1235;
+        readonly type: "number";
+        readonly unit: "%";
+        readonly kind: "percent";
+        readonly writeOnly: true;
+        readonly provenance: "verified";
+        readonly available: typeof isHomeBase;
+        readonly requires: readonly [1281, 1282];
+        readonly min: 0;
+        readonly max: 100;
+        readonly description: "HomeBase alarm volume 0..100 (1235 CMD_SET_HUB_SPK_VOLUME). Verified audible on a T8030.";
+        readonly write: (v: string | number | boolean) => Command;
+    };
+    /** HomeBase alarm tone keeps its independently verified two-option domain. */
+    readonly alarmTone: {
+        readonly param: 1281;
+        readonly property: "hubAlarmTone";
+        readonly type: "number";
+        readonly kind: "enum";
+        readonly enumValues: Record<number, string>;
+        readonly provenance: "verified";
+        readonly available: typeof isHomeBase;
+        readonly requires: readonly [1281, 1282];
+        readonly args: readonly [{
+            readonly name: "tone";
+            readonly kind: "enum";
+            readonly description: "One of the app's alarm tones (1-indexed).";
+        }];
+        readonly description: string;
+        readonly write: (v: string | number | boolean, ctx: CommandContext) => Command | undefined;
+    };
+    /** Sound a standalone siren briefly using its dedicated installation-test wire. */
+    readonly test: {
+        readonly action: (ctx: CommandContext) => Command;
+        readonly available: typeof isEvidencedStandaloneSiren;
+        readonly description: "Sound the siren briefly as a test.";
+    };
+    /** Trigger a verified station-family HomeBase or evidenced attached-camera alarm for a bounded duration. */
+    readonly trigger: {
+        readonly method: (deps: import("./members.js").MemberDeps) => (seconds: number) => Promise<void>;
+        readonly description: string;
+        readonly available: ((ctx: CommandContext) => boolean) & ((ctx: CommandContext) => boolean);
+        readonly answers?: true;
+        readonly args: readonly [{
+            readonly name: "seconds";
+            readonly kind: "seconds";
+            readonly min: 1;
+            readonly description: "A positive whole-number duration.";
+        }];
+    };
+    /** Stop a verified alarm-output family through its own wire contract. */
+    readonly stop: import("./members.js").MethodMember<() => Promise<void>> & {
+        available: (ctx: CommandContext) => boolean;
+    };
+};
+/**
+ * `siren` — audible alarm output across independently verified standalone siren, HomeBase, and camera
+ * families. Member installation preserves each family's state evidence, units, and wire contract.
+ */
+export declare const SIREN: CapabilityModule;
+export {};

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

@@ -0,0 +1,172 @@
+import type { CapabilityModule } from "./types.js";
+import type { Command } from "../../core/contracts.js";
+import { type Surface } from "./members.js";
+/** Integer RGB input for `SmartLightActions.setColor`; each channel must be in 0..255. */
+export interface RgbColor {
+    red: number;
+    green: number;
+    blue: number;
+}
+/**
+ * Bound `smart_light` controls — the object returned by `dev.smartLight()`.
+ *
+ * The reads, their setters, the state request and the effect write are DERIVED from
+ * `SMART_LIGHT_MEMBERS`: one declaration per feature gives the getter, the setter, its argument
+ * type and its description. Only the no-argument power verbs are written out below.
+ */
+export type SmartLightActions = Surface<typeof SMART_LIGHT_MEMBERS> & {
+    /** Turn the light on. */
+    on(): Promise<void>;
+    /** Turn the light off. */
+    off(): Promise<void>;
+};
+/**
+ * Every `smart_light` feature, declared once. The property schema, the typed getters, the derived
+ * setters, the intent routes and the descriptions all come out of this table.
+ *
+ * Every read is `realtime`: this line has no pollable cloud param to gate a getter on — state arrives
+ * only over the light's own MQTT wire — so the capability's own detection is the evidence, and each
+ * getter reads `undefined` until the first report lands.
+ *
+ * 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_LIGHT_MEMBERS: {
+    /**
+     * On/off for the whole run of lights. `writeAs` names the setter `set` rather than `setPower`, and the
+     * `on`/`off` verbs beside it in `actions()` reach the same frame. `realtime` like every read here:
+     * there is no pollable cloud param, so the getter answers `undefined` until the first MQTT report —
+     * `refreshState` is how a caller populates it on demand. Note the READ tag (0xa1) and the WRITE tag
+     * (0xa3) differ; the two legs' tag maps are unrelated.
+     */
+    readonly power: {
+        readonly param: 161;
+        readonly property: "lightPower";
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "verified";
+        readonly realtime: true;
+        readonly description: "Power state, DP tag 0xa1. ✅ Source-confirmed in the app's own report parser, then live-decoded off a T8L02 status report.";
+        readonly write: (v: string | number | boolean) => Command;
+        readonly writeAs: "set";
+        readonly aliases: {
+            readonly on: true;
+            readonly off: false;
+        };
+    };
+    /**
+     * The CONFIGURED level, not the live output: it persists across an off, so reading a non-zero
+     * brightness says nothing about whether the lights are lit — pair it with `power`. 0 is a legal level
+     * here (unlike the camera spotlight's 1-100), and the write clamps into 0-100 rather than refusing.
+     * `realtime`, so `undefined` until the first report.
+     */
+    readonly brightness: {
+        readonly param: 162;
+        readonly property: "lightBrightness";
+        readonly type: "number";
+        readonly unit: "%";
+        readonly kind: "percent";
+        readonly provenance: "verified";
+        readonly realtime: true;
+        readonly min: 0;
+        readonly max: 100;
+        readonly description: string;
+        readonly write: (v: string | number | boolean) => Command;
+    };
+    /**
+     * How many individually addressable segments the installed run has — a physical fact of the strip,
+     * which is why it is read-only. A bare `scalar` with no unit: the wire says how many, not how long.
+     * `realtime`, so `undefined` until the first report.
+     */
+    readonly lightLength: {
+        readonly param: 163;
+        readonly type: "number";
+        readonly kind: "scalar";
+        readonly provenance: "verified";
+        readonly realtime: true;
+        readonly description: "Addressable segment count, DP tag 0xa3.";
+    };
+    /**
+     * The gallery effect SELECTED — an `identifier`, not an enum, because it names an entry in a catalog
+     * that only exists at runtime, so there is no option set to publish. Distinct from `cloudEffectId`,
+     * which is the one actually running. Written by `setEffect`, whose gate is the model rather than a
+     * value. `realtime`, so `undefined` until the first report.
+     */
+    readonly effectId: {
+        readonly param: 164;
+        readonly property: "lightEffectId";
+        readonly type: "number";
+        readonly kind: "identifier";
+        readonly provenance: "verified";
+        readonly realtime: true;
+        readonly description: "Selected gallery effect id, DP tag 0xa4.";
+    };
+    /**
+     * Whether the run blends between an effect's colours rather than stepping between them. Read-only:
+     * the report parser establishes the flag, but no write frame for it has been reversed, so no setter
+     * is offered. One of the two params surfaced as `"1"`/`"0"` so the `bool` narrowing reads it.
+     * `realtime`, so `undefined` until the first report.
+     */
+    readonly colorGradient: {
+        readonly param: 165;
+        readonly property: "lightColorGradient";
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "verified";
+        readonly realtime: true;
+        readonly description: "Colour-gradient switch, DP tag 0xa5.";
+    };
+    /**
+     * The effect actually RUNNING, `0` when none is — so this, not `effectId`, is the read that answers
+     * "is an effect playing". An `identifier` for the same reason as its sibling: the catalog it indexes
+     * is fetched at runtime. Read-only; `setEffect` drives the selection. `realtime`, so `undefined`
+     * until the first report.
+     */
+    readonly cloudEffectId: {
+        readonly param: 166;
+        readonly property: "lightCloudEffectId";
+        readonly type: "number";
+        readonly kind: "identifier";
+        readonly provenance: "verified";
+        readonly realtime: true;
+        readonly description: "Running gallery effect id (0 when off), DP tag 0xa6.";
+    };
+    /**
+     * Reported in every status frame, so it belongs in the schema and answers through `getProperty` — but
+     * given no typed getter: the app's own parser reads 0xa7 differently on the notify and on the
+     * get-reply, and no capture settles which value means what.
+     */
+    readonly lightEffectMode: {
+        readonly param: 167;
+        readonly type: "number";
+        readonly kind: "scalar";
+        readonly provenance: "apk";
+        readonly unexposed: true;
+        readonly description: string;
+    };
+    /**
+     * A request, not a state: reports are pushed on change with no periodic heartbeat, so this is how a
+     * caller populates the getters on demand. The reply arrives asynchronously and does not resolve here.
+     */
+    readonly refreshState: {
+        readonly action: () => Command;
+        readonly description: "Ask the device to report its current state; the reply refreshes the reads.";
+    };
+    /**
+     * Gated on the MODEL, not on a value, and carrying no description: it refuses off the confirmed list
+     * for a reason a generated message cannot give, and its id names an entry in a catalog that only
+     * exists at runtime, so a generated control would have no domain to offer. Neither is a property
+     * write, so it keeps its own signature.
+     */
+    readonly setEffect: import("./members.js").MethodMember<(lightId: number) => Promise<void>>;
+    /**
+     * Plain custom colour, distinct from the gallery-effect wire. The frame addresses every reported
+     * segment, so a current positive segment count is mandatory and no family-wide length is guessed.
+     * Completion acknowledges transport publication only; the device reports no authoritative RGB.
+     */
+    readonly setColor: import("./members.js").MethodMember<(color: RgbColor) => Promise<void>> & {
+        available: (ctx: import("./types.js").CommandContext) => boolean;
+    };
+};
+export declare const SMART_LIGHT: CapabilityModule;

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

@@ -0,0 +1,40 @@
+import { type Surface } from "./members.js";
+import type { CapabilityModule } from "./types.js";
+/**
+ * Every `smoke` feature, declared once — the property schema and the evidence-gated getters derive from here.
+ *
+ * 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 SMOKE_MEMBERS: {
+    /**
+     * The alarm flag itself — and the reason this capability is detected by model name rather than by a
+     * reported param. 1561 is a `guessed` placeholder: nothing captured from a smoke detector confirms the
+     * id or which value means alarming, so the evidence gate installs this getter only on a device that
+     * happens to report 1561. Promote it once a capture pins the id, not before.
+     */
+    readonly smokeDetected: {
+        readonly param: 1561;
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "guessed";
+        readonly description: "Smoke detected. UNVERIFIED: placeholder id pending capture verification.";
+    };
+    /**
+     * Unix seconds at which the detector last checked in — param 1551, the same last-seen id the other
+     * sensor capabilities read. A `timestamp` kind takes no `unit`: the number is an instant, not a
+     * duration, and declaring `unit: "s"` beside it fails the value-kind spec.
+     */
+    readonly lastSeen: {
+        readonly param: 1551;
+        readonly type: "number";
+        readonly kind: "timestamp";
+        readonly provenance: "verified";
+        readonly description: "Last-seen unix timestamp, seconds (verified: param 1551).";
+    };
+};
+/** Bound smoke-detector reads — the object returned by `dev.smoke()`. Read-only. */
+export type SmokeActions = Surface<typeof SMOKE_MEMBERS>;
+/** `smoke` — smoke detector. Alarm flag is a placeholder pending verification. */
+export declare const SMOKE: CapabilityModule;

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

@@ -0,0 +1,6 @@
+import type { CapabilityModule } from "./types.js";
+/**
+ * `snapshot` — still-image capture / thumbnail. Behaviour-only (a capture command);
+ * the resulting image is delivered out-of-band, not as a state param.
+ */
+export declare const SNAPSHOT: CapabilityModule;

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

@@ -0,0 +1,11 @@
+import type { CapabilityModule } from "./types.js";
+/**
+ * `storage` — on-device storage (SD card / eMMC / HDD).
+ *
+ * A station-codec baseline capability, since hubs own recordings. It contributes no state properties:
+ * no owned station reports a capacity or SD-card parameter, and the one id a table here could point at
+ * (1131) is `deviceStatus` in the param dictionary — reported by ten devices with an unrelated meaning,
+ * so a capacity getter over it would install widely and answer a device-status code as megabytes.
+ * Capacity earns a member when a station is captured reporting one.
+ */
+export declare const STORAGE: CapabilityModule;

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

@@ -0,0 +1,104 @@
+import type { AvailabilityContext, CapabilityModule } from "./types.js";
+import { type Surface } from "./members.js";
+/**
+ * RoboVac suction Tuya **DP ids** — this capability's own wire vocabulary (clean namespace, from the
+ * cloud `get_product_data_point` schema). Named like the P2P feature-command consts so a DP is
+ * referenced by meaning rather than a magic number.
+ */
+export declare const SUCTION_DP: {
+    /** Suction level (DP 158, Enum). */
+    readonly SUCTION: 158;
+    /** BoostIQ auto-suction on/off (DP 159, Bool). */
+    readonly BOOST_IQ: 159;
+};
+/**
+ * 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
+ * constrained per device, and {@link suctionLevelName} names a reported level.
+ *
+ * `BoostIQ` (4) is a real suction level in this scale. The separate `boostIq`
+ * boolean (DP 159) is the independent auto-suction toggle — a device may report both, and they don't
+ * contradict.
+ */
+export declare const SuctionLevel: {
+    readonly Quiet: 0;
+    readonly Standard: 1;
+    readonly Turbo: 2;
+    readonly Max: 3;
+    readonly BoostIQ: 4;
+    readonly MaxPro: 5;
+};
+export type SuctionLevelValue = (typeof SuctionLevel)[keyof typeof SuctionLevel];
+/**
+ * The label for a raw suction int, per the app's `SuctionEnum`, or `undefined` for a value outside the
+ * known scale. The mapping is global (not per-model) — see {@link SuctionLevel}.
+ */
+export declare function suctionLevelName(value: number): string | undefined;
+/**
+ * Bound suction reads and controls — the object returned by `dev.suction()`.
+ *
+ * `setSuctionLevel` is DERIVED from the `level` member entry; `supportedLevels` is the only addition
+ * from `actions()` — it names the per-SKU DP 158 range but is not itself a device param.
+ */
+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]`.
+     *
+     * `undefined` when the catalog is absent or does not cover DP 158. Only meaningful on devices where
+     * `setSuctionLevel` is installed (AIoT vacuums).
+     */
+    readonly supportedLevels?: readonly SuctionLevelValue[];
+};
+/**
+ * Every `suction` read and write — `setSuctionLevel` (DP 158, via `writeAs`) and `setBoostIq`
+ * (DP 159) are both derived from this table.
+ *
+ * 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 SUCTION_MEMBERS: {
+    /**
+     * Narrowed to the known scale, which is NARROWER THAN THE WIRE: the level
+     * arrives as a plain integer and a firmware reporting a value outside {@link SuctionLevel} would be
+     * typed as one of these regardless. {@link suctionLevelName} stays total for that reason — it answers
+     * `undefined` for an int it does not recognise, so an unexpected level surfaces as unnamed rather than
+     * mislabelled.
+     */
+    readonly level: {
+        readonly param: 158;
+        readonly property: "suction";
+        readonly type: "number";
+        readonly kind: "enum";
+        readonly enumValues: Record<number, string>;
+        readonly provenance: "mega";
+        readonly decode: (raw: unknown) => SuctionLevelValue | undefined;
+        readonly decodedKind: "enum";
+        readonly decodedValues: readonly SuctionLevelValue[];
+        readonly write: (v: string | number | boolean) => import("../../index.js").Command;
+        readonly writeAs: "setSuctionLevel";
+        readonly available: (ctx: AvailabilityContext) => boolean;
+        readonly description: string;
+    };
+    /**
+     * The auto-suction toggle — an independent boolean, NOT the `BoostIQ` entry in the suction scale. A
+     * robot may report both at once without contradicting itself: `level` says which power the robot is
+     * fixed at, this says whether it may raise it by itself on carpet. Writable straight from the table
+     * because DP 159 is a plain bool with no per-model range to validate against, unlike `level`.
+     */
+    readonly boostIq: {
+        readonly param: 159;
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "mega";
+        readonly description: "BoostIQ auto-suction (DP 159, Bool).";
+        readonly write: (v: string | number | boolean) => import("../../index.js").Command;
+        readonly available: (ctx: AvailabilityContext) => boolean;
+    };
+};
+/** `suction` — vacuum suction power level (RoboVac). */
+export declare const SUCTION: CapabilityModule;