@apocaliss92/nodedreame 1.11.11 → 1.12.1

package/dist/index.d.cts

@@ -1,5 +1,6 @@
 import { fetch } from 'undici';
 import { z } from 'zod';
+import { EventEmitter } from 'node:events';
 
 /** Public name of this library. */
 declare const LIBRARY_NAME = "nodedreame";
@@ -36,6 +37,47 @@ declare class DreameTransportError extends DreameError {
 /** Supported Dreame cloud regions. */
 type DreameRegion = 'eu' | 'us' | 'cn' | 'ru' | 'sg' | 'in' | 'de' | 'tw';
 
+/**
+ * Connectivity / diagnostic info distilled from a device-list record.
+ *
+ * Scope note: the Dreame cloud device record exposes reachability + identity +
+ * the assigned MQTT broker, but NOT Wi-Fi RSSI / SSID / local IP — those are
+ * native-firmware (miIO-style) details the cloud API does not return for these
+ * vacuums. So `signalStrength`/`ssid`/`ip` are intentionally absent here; this
+ * surfaces everything the cloud actually provides.
+ */
+/** The device's assigned MQTT broker endpoint (from `bindDomain`). */
+interface BrokerEndpoint {
+    readonly host: string;
+    readonly port: number | null;
+}
+interface DeviceConnectivity {
+    /** Whether the cloud considers the device online (LWT/online flag). */
+    readonly online: boolean;
+    /** Physical link type reported by the cloud (e.g. `"WIFI"`), or null. */
+    readonly connectionType: string | null;
+    /** Device MAC address, or null. */
+    readonly mac: string | null;
+    /** Assigned MQTT broker (`bindDomain` split into host/port), or null. */
+    readonly broker: BrokerEndpoint | null;
+    /** Cloud region the device is bound to (e.g. `"eu"`), or null. */
+    readonly region: string | null;
+    /** Cloud media/IoT vendor (e.g. `"ali"`), or null. */
+    readonly cloudVendor: string | null;
+    /** Firmware version (`ver`), or null. */
+    readonly firmwareVersion: string | null;
+    /** Serial number (`sn`), or null. */
+    readonly serialNumber: string | null;
+    /** Sub-model code, or null. */
+    readonly subModel: string | null;
+    /** Battery percentage 0–100 from the cloud snapshot, or null. */
+    readonly battery: number | null;
+    /** Latest MIoT status int from the cloud snapshot, or null. */
+    readonly statusCode: number | null;
+}
+/** Parse the connectivity view from a raw device-list record. */
+declare function parseConnectivity(raw: Record<string, unknown>): DeviceConnectivity;
+
 interface DreameSession {
     accessToken: string;
     refreshToken?: string | undefined;
@@ -55,6 +97,8 @@ interface DreameDevice {
     firmwareVersion?: string;
     serialNumber?: string;
     cloudState?: DreameCloudState;
+    /** Connectivity/diagnostic view distilled from the cloud record. */
+    connectivity?: DeviceConnectivity;
 }
 /** Cloud-cached subset of device state distilled from the device-list response. */
 interface DreameCloudState {
@@ -932,6 +976,268 @@ declare class VacuumCapabilityResolver implements CapabilityResolver {
     resolve(model: string): DeviceCapabilities;
 }
 
+/**
+ * MIoT surface of the Dreame camera service (SIID 10001), reversed byte-exact
+ * from the r2538z (X50) React-Native plugin `Monitor` model. Every camera
+ * control the app issues is a MIoT `action` on this service; the values below
+ * are the verbatim aiid/piid maps from the bundle.
+ */
+/** The camera/monitor service id. Same across the X40/X50 vacuum class. */
+declare const MONITOR_SIID = 10001;
+/** Action instance ids on {@link MONITOR_SIID}. */
+declare const MONITOR_AIID: {
+    /** Stream lifecycle + keep-alive (monitor start/end, keep_alive). */
+    readonly CAMERA_OPERATE: 1;
+    /** Two-way intercom start/end. */
+    readonly VOICE_OPERATE: 2;
+    /** Generic property-scoped operations. */
+    readonly PROPERTY_OPERATE: 3;
+    /** Privacy access-code gate (launch/verify/set/reset). */
+    readonly ACCESS_CODE_OPERATE: 4;
+    /** Video-vendor SDK init / switch. */
+    readonly VIDEO_VENDOR: 7;
+};
+/** Property instance ids on {@link MONITOR_SIID}. */
+declare const MONITOR_PIID: {
+    readonly MONITOR_STATUS: 1;
+    readonly MONITOR_AUDIO_STATUS: 2;
+    readonly MONITOR_RECORD_STATUS: 4;
+    readonly TAKE_PHOTO: 5;
+    readonly KEEP_ALIVE: 6;
+    readonly MONITOR_FAULTS: 7;
+    readonly FILL_LIGHT_SET: 9;
+    readonly CAMERA_LIGHT_SWITCH: 10;
+    readonly VIDEO_VENDOR_STATUS: 11;
+    readonly GET_PROPERTY: 99;
+    readonly PERSON_DATA: 110;
+    readonly VIDEO_OBSTACLE_SWITCH: 111;
+    readonly VIDEO_OBSTACLE_DATA: 112;
+    readonly MONITOR_TASK_STATUS: 103;
+    readonly UPLOAD_STATUS: 1003;
+    readonly GET_ACCESS_CODE: 1100;
+    readonly SET_ACCESS_CODE: 1101;
+    readonly VERIFY_ACCESS_CODE: 1102;
+    readonly MONITOR_REST_MODE: 1103;
+    readonly SET_ACCESS_HOT_STATUS: 1104;
+    readonly MONITOR_SPACE: 2003;
+};
+/**
+ * The `token` field the `startMonitor` action expects, keyed by vendor. Aliyun
+ * LinkVisual uses the literal `"alify"`; Tencent uses `"tx"`. (Agora passes an
+ * RTC access token instead and is not modelled here.)
+ */
+declare const MONITOR_VENDOR_TOKEN: Record<'ali' | 'tx', string>;
+/**
+ * The vacuum work service (SIID 4). The camera has no gimbal — "PTZ" and the
+ * camera-adjacent controls (remote drive, go-to-point, person-follow) drive the
+ * robot itself through this service.
+ */
+declare const VACUUM_SIID = 4;
+declare const VACUUM_MOVE: {
+    /** Remote-drive state property (set_properties), sent ~1 Hz while held. */
+    readonly REMOTE_STATE_PIID: 15;
+    /** Work-mode action instance (go-to-point, cruise, person-follow start). */
+    readonly WORK_AIID: 1;
+    /** Work-mode stop action instance (person-follow stop). */
+    readonly STOP_AIID: 2;
+    /** piid carrying the work-mode selector value in the WORK action. */
+    readonly MODE_PIID: 1;
+    /** piid carrying the point-info JSON in the WORK action. */
+    readonly POINT_PIID: 10;
+    /** Work-mode selector values. */
+    readonly MODE_SPOT: 23;
+    readonly MODE_CRUISE: 22;
+    readonly MODE_PERSON_FOLLOW: 26;
+    readonly MODE_SPOT_CLEAN: 20;
+    /** Auto-switch setter property (fill-light auto/full toggle lives here). */
+    readonly AUTO_SWITCH_PIID: 50;
+};
+/** Pet-teasing sound clips playable via {@link VOICE_PLAY_SOUND_AIID}. */
+declare const PET_SOUNDS: {
+    readonly meow: 684;
+    readonly bark: 685;
+    readonly footsteps: 686;
+    readonly purring: 687;
+    readonly tickTock: 688;
+};
+type PetSound = keyof typeof PET_SOUNDS;
+/** Common whole-robot actions (usable as camera presets). */
+declare const VACUUM_ACTIONS: {
+    readonly startClean: {
+        readonly siid: 2;
+        readonly aiid: 1;
+    };
+    readonly pauseClean: {
+        readonly siid: 2;
+        readonly aiid: 2;
+    };
+    readonly stopClean: {
+        readonly siid: 4;
+        readonly aiid: 2;
+    };
+    readonly dockWash: {
+        readonly siid: 4;
+        readonly aiid: 4;
+    };
+    readonly autoEmpty: {
+        readonly siid: 15;
+        readonly aiid: 1;
+    };
+};
+type VacuumActionKey = keyof typeof VACUUM_ACTIONS;
+
+/**
+ * Per-session correlation token, exactly as the app's `Monitor.updateSession()`:
+ * `MD5(accountId + "_" + epochMillis)`. Pass an explicit `now` for deterministic
+ * tests. `accountId` is the Dreame account uid.
+ */
+declare function makeMonitorSession(accountId: string, now?: number): string;
+/** SHA-256 hex of a privacy access code, as `Monitor.verifyAccessCode` sends it. */
+declare function hashAccessCode(code: string): string;
+/**
+ * Remote-drive value (siid 4 / piid 15), sent ~1 Hz while a direction is held.
+ * `spdv` = forward speed (200 fwd, 0 stop), `spdw` = turn (45 left, -45 right,
+ * 180 turn-around, 0 straight). Pass an explicit `now` for deterministic tests.
+ */
+declare function remoteDriveValue(spdv: number, spdw: number, now?: number): string;
+/** Named remote-drive directions, mapping to (spdv, spdw). */
+declare const DRIVE_DIRECTIONS: {
+    readonly forward: readonly [200, 0];
+    readonly left: readonly [0, 45];
+    readonly right: readonly [0, -45];
+    readonly turnAround: readonly [0, 180];
+    readonly stop: readonly [0, 0];
+};
+type DriveDirection = keyof typeof DRIVE_DIRECTIONS;
+
+/**
+ * MIoT device transport the controller drives — satisfied by a nodedreame device
+ * handle (VacuumDevice). `setProperty` is optional so callAction-only fakes still
+ * satisfy the interface; the robot-drive helpers require it.
+ */
+interface MonitorActionCaller {
+    callAction(siid: number, aiid: number, input: unknown[]): Promise<unknown>;
+    setProperty?(write: {
+        siid: number;
+        piid: number;
+        value: unknown;
+    }): Promise<unknown>;
+}
+/** Minimal relay minter — satisfied by {@link DreameVideoSession}. */
+interface RelayMinter {
+    getStreamInfo(iotId: string, opts?: {
+        encrypted?: boolean;
+        wakeTimeoutMs?: number;
+        pollMs?: number;
+    }): Promise<{
+        relayUrl: string | null;
+    }>;
+}
+interface DreameCameraControllerInput {
+    /** MIoT action transport (the device handle). */
+    readonly device: MonitorActionCaller;
+    /** Aliyun relay minter (a {@link DreameVideoSession}). */
+    readonly relay: RelayMinter;
+    /** LinkVisual channel id for this device (`iotId`). */
+    readonly iotId: string;
+    /** Dreame account uid — seeds the per-session correlation token. */
+    readonly accountId: string;
+    /** Video vendor. Only `ali` mints an RTMP relay; defaults to `ali`. */
+    readonly vendor?: 'ali' | 'tx';
+    /** Privacy access code (PIN) set at pairing, if any. Required to wake a coded camera. */
+    readonly accessCode?: string;
+    /** Aliyun region code the device reports as `area`; defaults to `'4'`. */
+    readonly area?: string;
+    /** Keep-alive cadence in ms (app default 10s). */
+    readonly keepAliveIntervalMs?: number;
+    /** Max time to wait for the relay to come up while the device wakes. */
+    readonly wakeTimeoutMs?: number;
+    /** Reported when a keep-alive tick fails (the stream is likely dying). */
+    readonly onKeepAliveError?: (err: unknown) => void;
+    /** Optional line logger (nodelink-style). Defaults to no-op. */
+    readonly log?: (line: string) => void;
+}
+/** A live camera stream: the pullable relay URL plus the device's per-stream key. */
+interface CameraStreamHandle {
+    /** Plain RTMP relay URL (H.264 + AAC). Single stream; re-open for another consumer. */
+    readonly rtmpUrl: string;
+    /** Device-generated per-session encryption key echoed by `startMonitor`. */
+    readonly encryptionKey: string | null;
+}
+declare class DreameCameraController {
+    #private;
+    constructor(input: DreameCameraControllerInput);
+    /** True while a monitor session is active (between {@link open} and {@link close}). */
+    get isOpen(): boolean;
+    /**
+     * Run the full cold-start sequence and return a live relay URL. Starts the
+     * keep-alive loop; the caller MUST {@link close} when done to release the
+     * device. Throws if the monitor cannot be started or no relay comes up.
+     */
+    open(): Promise<CameraStreamHandle>;
+    /**
+     * Mint a FRESH single-use RTMP relay URL for the already-open monitor. Each
+     * consumer needs its own relay URL, so call this once per ffmpeg/consumer.
+     * Throws if the stream is not open.
+     */
+    mintRelayUrl(): Promise<string>;
+    /** Start the two-way intercom session (control plane only; see module docs on mic uplink). */
+    startIntercom(opts?: {
+        needRecordSound?: boolean;
+        videoCall?: boolean;
+    }): Promise<unknown>;
+    /** Stop the two-way intercom session. */
+    stopIntercom(): Promise<unknown>;
+    /** Set the fill-light brightness (40–100 = manual %, below 40 / 101 = auto). */
+    setFillLight(value: number): Promise<unknown>;
+    /**
+     * Device-side snapshot: the robot captures a still and uploads it to cloud
+     * storage (read the result back from the `uploadStatus` property). Prefer a
+     * frame-grab from the live stream for an instant image.
+     */
+    takePhoto(): Promise<unknown>;
+    /**
+     * Remote-drive the robot ("PTZ" substitute — the camera is fixed, the robot
+     * moves). `spdv` = forward speed, `spdw` = turn; send repeatedly (~1 Hz) while
+     * a direction is held, then `stop`. Only valid while the stream is open.
+     */
+    drive(spdv: number, spdw: number): Promise<unknown>;
+    /** Remote-drive by named direction (forward/left/right/turnAround/stop). */
+    driveDirection(direction: DriveDirection): Promise<unknown>;
+    /** Start person-follow mode (robot tracks a detected person). */
+    startPersonFollow(): Promise<unknown>;
+    /**
+     * Universal stop for the current work mode — stops person-follow, spot-clean,
+     * go-to-point, cruise, etc. (siid 4 / aiid 2).
+     */
+    stopWork(): Promise<unknown>;
+    /** Stop person-follow mode (alias for {@link stopWork}). */
+    stopPersonFollow(): Promise<unknown>;
+    /** Spot-clean the robot's current position (WorkMode SpotClean). */
+    spotClean(): Promise<unknown>;
+    /** Play one of the robot's sound clips (e.g. pet sounds) by id. */
+    playSound(soundId: number): Promise<unknown>;
+    /** Play a named pet-teasing sound (meow/bark/footsteps/purring/tickTock). */
+    playPetSound(sound: PetSound): Promise<unknown>;
+    /** Run a common whole-robot action (startClean/pauseClean/stopClean/dockWash/autoEmpty). */
+    runVacuumAction(action: VacuumActionKey): Promise<unknown>;
+    /** Find-pet: cruise the home looking for the pet. */
+    findPet(): Promise<unknown>;
+    /** Send the robot to a map point (`spoint` current, `tpoint` targets). */
+    goToPoint(spoint: number[][], tpoint: number[][]): Promise<unknown>;
+    /** Toggle the fill light between auto (`full=false`) and full-on (`full=true`). */
+    setFillLightAuto(full: boolean): Promise<unknown>;
+    /**
+     * Send the robot back to its dock to charge ("go home"). Works regardless of
+     * stream state — usable as a standalone command or a PTZ "home" preset.
+     */
+    returnToDock(): Promise<unknown>;
+    /** Locate the robot — it beeps. Works regardless of stream state. */
+    locate(): Promise<unknown>;
+    /** Stop the keep-alive loop and release the monitor on the device. Idempotent. */
+    close(): Promise<void>;
+}
+
 /**
  * Public types for the live-map decoder.
  *
@@ -1246,6 +1552,19 @@ interface VacuumMap {
      */
     cleanedArea: MapCleanedAreaOverlay | null;
 }
+/**
+ * Optional decode hints. The AES key is per-blob (it arrives appended to
+ * the OSS object name with a comma, or via the OLD_MAP_DATA multiplexed
+ * format); the IV is per-model (lives in Tasshack's `device_info` table)
+ * and must be supplied here since node-dreame doesn't ship a per-model
+ * IV lookup.
+ */
+interface VacuumMapDecodeOptions {
+    /** AES-256-CBC key — 32 ASCII hex chars from `sha256(<rawKey>)[0:32]`. */
+    key?: string;
+    /** AES-256-CBC IV — 16 ASCII bytes, model-specific. */
+    iv?: string;
+}
 
 /**
  * Raster PNG renderer for a decoded `VacuumMap`.
@@ -1307,6 +1626,34 @@ interface RenderVacuumPngOptions {
 }
 declare function renderVacuumPng(map: VacuumMap, opts?: RenderVacuumPngOptions): Buffer;
 
+interface WifiSignalMap {
+    readonly dimensions: MapDimensions;
+    /** Robot pose from the frame header, or null when absent. */
+    readonly robot: MapPose | null;
+    /** Charging-dock pose from the frame header, or null when absent. */
+    readonly dock: MapPose | null;
+    /** Raw per-cell nibble (`pixel & 15`), row-major (width*height). */
+    readonly cells: Uint8Array;
+    /** Signal bars (1–4) at a world point, 0 = unreached, or null = no Wi-Fi data / off-map. */
+    signalAt(worldX: number, worldY: number): number | null;
+    /** Signal bars at the robot's own position (or null when unknown). */
+    readonly currentSignal: number | null;
+}
+/** Decode a Wi-Fi map blob (raw string/Buffer or already-inflated) into signal cells + geometry. */
+declare function decodeWifiSignalMap(input: string | Buffer, opts?: VacuumMapDecodeOptions): WifiSignalMap;
+interface RenderWifiSignalPngOptions {
+    /** Upscale factor (each map cell → scale×scale px). Default 4. */
+    scale?: number;
+    /** Draw a marker at the robot position. Default true. */
+    markRobot?: boolean;
+}
+/**
+ * Render a simple Wi-Fi coverage heatmap PNG (weakest→strongest blue, unreached
+ * grey, no-data transparent), with an optional robot marker — a ready-to-show
+ * image for consumers.
+ */
+declare function renderWifiSignalPng(map: WifiSignalMap, opts?: RenderWifiSignalPngOptions): Buffer;
+
 /**
  * Resolve a Dreame OSS object name (advertised via the PATH push,
  * `siid 6 piid 3`) to a signed download URL and fetch the blob.
@@ -1399,6 +1746,26 @@ interface VacuumGetMapInput {
     /** Caller-supplied AbortSignal. */
     signal?: AbortSignal;
 }
+/** Input to {@link VacuumDevice.getWifiSignalMap} / {@link VacuumDevice.getCurrentSignal}. */
+interface WifiSignalMapInput {
+    /** Request the last stored map first (default true). `false` = read what's advertised. */
+    requestFresh?: boolean;
+    /** Poll interval (ms) while waiting for the OSS object to be advertised. Default 2500. */
+    pollMs?: number;
+    /** Max wait (ms) for the map to become available. Default 20000. */
+    maxWaitMs?: number;
+    /** Inject the signed-blob fetcher (tests pass a fake). */
+    fetcher?: OssFetcherLike;
+    /** Optional AES key/iv for an encrypted blob (hex). */
+    key?: string;
+    iv?: string;
+    /** Override the API host (defaults from the device region). */
+    host?: string;
+    /** Per-request timeout override in ms. */
+    timeoutMs?: number;
+    /** Caller-supplied AbortSignal. */
+    signal?: AbortSignal;
+}
 /** A typed Dreame-vacuum handle (state + capability-gated commands). */
 declare class VacuumDevice extends BaseDevice<VacuumDeviceEvents> {
     #private;
@@ -1639,6 +2006,29 @@ declare class VacuumDevice extends BaseDevice<VacuumDeviceEvents> {
      * `applyVacuumPFrame` merge primitive ships separately for that work.
      */
     getMap(input: VacuumGetMapInput): Promise<VacuumMap>;
+    /**
+     * Fetch the robot's Wi-Fi signal map — the last stored coverage heatmap, with
+     * NO robot movement. Requests it (map service `wifiMap` action, siid 6 aiid 4),
+     * polls `PropWifiMap` (6/15) for the OSS object it advertises, fetches + decodes
+     * it into a per-cell signal grid + geometry + robot/dock poses. The signal at
+     * any world point (incl. the robot's own position) is a lookup — see
+     * {@link WifiSignalMap.signalAt} / {@link WifiSignalMap.currentSignal}.
+     *
+     * Pass `requestFresh: false` to skip the request and read whatever is already
+     * advertised. Throws if no Wi-Fi map exists yet (never run on this device).
+     */
+    getWifiSignalMap(input?: WifiSignalMapInput): Promise<WifiSignalMap>;
+    /**
+     * Render the Wi-Fi signal map as a simple PNG heatmap image (weakest→strongest,
+     * unreached grey, robot marker) — ready to display. Convenience over
+     * {@link getWifiSignalMap} + {@link renderWifiSignalPng}.
+     */
+    getWifiSignalImage(input?: WifiSignalMapInput & RenderWifiSignalPngOptions): Promise<Buffer>;
+    /**
+     * The one-call "current Wi-Fi signal": fetches the signal map and returns the
+     * bars (1–4, 0 = unreached) at the robot's own position, or null when unknown.
+     */
+    getCurrentSignal(input?: WifiSignalMapInput): Promise<number | null>;
     /** Drop the P-frame merge base so the next I-frame re-seeds the stream. */
     resetMapStream(): void;
     /**
@@ -1655,6 +2045,37 @@ declare class VacuumDevice extends BaseDevice<VacuumDeviceEvents> {
      * frame on every push during a live clean.
      */
     fetchLatestMapStreaming(opts?: Omit<VacuumGetMapInput, 'filename'>): Promise<VacuumMap | null>;
+    /**
+     * Build a {@link DreameCameraController} for this device's camera, wired to
+     * both planes it needs: the MIoT action transport (this device handle) and a
+     * fresh Aliyun {@link DreameVideoSession} for the relay. Call
+     * `controller.open()` to autonomously cold-start the stream and get a pullable
+     * RTMP URL, then `controller.close()` to release it.
+     *
+     * The camera's per-session privacy gate means a coded camera needs its PIN:
+     * pass `accessCode` (the code set at pairing). `iotId` is resolved from the
+     * device's cloud video profile when not supplied.
+     */
+    createCameraController(opts?: {
+        /** LinkVisual channel id; resolved from the cloud profile when omitted. */
+        iotId?: string;
+        /** Privacy PIN set at pairing (required to wake a coded camera). */
+        accessCode?: string;
+        /** Video vendor; defaults to `ali` (the only vendor that mints an RTMP relay). */
+        vendor?: 'ali' | 'tx';
+        /** Aliyun region code reported as `area`; defaults to `'4'`. */
+        area?: string;
+        /** Keep-alive cadence in ms (default 10s). */
+        keepAliveIntervalMs?: number;
+        /** Max time to wait for the relay while the device wakes. */
+        wakeTimeoutMs?: number;
+        /** Reported when a keep-alive tick fails. */
+        onKeepAliveError?: (err: unknown) => void;
+        /** Optional nodelink-style line logger. */
+        log?: (line: string) => void;
+        /** Reuse an existing relay minter (e.g. a shared {@link DreameVideoSession}). */
+        relay?: RelayMinter;
+    }): Promise<DreameCameraController>;
     /** Props worth seeding on start() / polling — exported for the facade. */
     static readonly DEFAULT_PROPS: readonly [{
         readonly siid: 2;
@@ -2305,13 +2726,13 @@ declare const DeviceDumpSchema: z.ZodObject<{
         type: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         model: string;
-        type?: string | undefined;
         region?: string | undefined;
+        type?: string | undefined;
         firmware?: string | undefined;
     }, {
         model: string;
-        type?: string | undefined;
         region?: string | undefined;
+        type?: string | undefined;
         firmware?: string | undefined;
     }>;
     observations: z.ZodObject<{
@@ -2469,8 +2890,8 @@ declare const DeviceDumpSchema: z.ZodObject<{
     libraryVersion: string;
     device: {
         model: string;
-        type?: string | undefined;
         region?: string | undefined;
+        type?: string | undefined;
         firmware?: string | undefined;
     };
     observations: {
@@ -2516,8 +2937,8 @@ declare const DeviceDumpSchema: z.ZodObject<{
     libraryVersion: string;
     device: {
         model: string;
-        type?: string | undefined;
         region?: string | undefined;
+        type?: string | undefined;
         firmware?: string | undefined;
     };
     observations: {
@@ -2629,4 +3050,700 @@ declare function createDumper(target: DumperDevice, options?: DumperOptions): Du
  */
 declare function createClientDumper(client: Nodreame, options?: DumperOptions): Dumper[];
 
-export { AI_FEATURE_BIT, AI_FEATURE_JSON_KEY, AUTO_SWITCH_JSON_KEY, type AiDetectionRaw, type AutoSwitchKey, type AutoSwitchRaw, BaseDevice, type BaseDeviceEvents, type BatchDeviceDataFetcher, type CapabilityResolver, ChargingStatus, type CleanOpts, CleaningMode, type ConsumableReading, type ConsumableSpec, type CreateDeviceArgs, DefaultCapabilityResolver, type DeviceCapabilities, type DeviceDump, type DeviceEvent, type DreameAiFeature, DreameApiError, DreameAuthError, type DreameCloudState, type DreameConsumableKey, type DreameDevice, DreameDeviceOfflineError, DreameError, type DreameRegion, type DreameSession, DreameTransportError, type DumperOptions, LIBRARY_NAME, MODEL_CAPABILITIES as MOWER_MODEL_CAPABILITIES, MOWER_TASK_SUBSTATES, type MapBoundingBox, type MapCleanedAreaOverlay, type MapColorScheme, type MapDimensions, type MapFrameType, type MapLayer, type MapLayerType, type MapLowLyingArea, type MapObstacle, type MapPath, type MapPathType, type MapPoint, type MapPose, type MapRestrictedArea, type MapRoom, type MapRoomWall, type MapRun, type MapSegment, type MapStorey, type MapVirtualWall, type MapWallsInfo, type MiotAction, MiotError, type MiotProp, MiotState, type MowerAvailableMap, type MowerCapabilities, MowerCapabilityResolver, MowerChargingStatus, type MowerConsumableKey, type MowerConsumableReading, type MowerContour, MowerControlAction, type MowerControlState, MowerDevice, type MowerDeviceInput, MowerFault, type MowerFaultSeverity, type MowerHeartbeat, type MowerMap, type MowerMapBoundary, type MowerMowPath, type MowerMowingProgress, type MowerPathEntry, type MowerPoint, type MowerSpotArea, MowerStatus, type MowerTaskDescriptor, MowerTaskStatus, type MowerTaskSubState, type MowerZone, Nodreame, type NodreameDeps, type NodreameEvents, type NodreameOptions, type OssFetchInput, type OssFetcherLike, type PropertyChangedEvent, type PropertyResult, type PropertyState, type PropertyWrite, type RenderMowerSvgOptions, type RenderVacuumPngOptions, type StateChangedEvent, SuctionLevel, TaskStatus, VACUUM_CONSUMABLES, MODEL_CAPABILITIES$1 as VACUUM_MODEL_CAPABILITIES, type VacuumCapabilities, VacuumCapabilityResolver, VacuumDevice, type VacuumGetMapInput, type VacuumMap, WaterVolume, consumableSpec, createClientDumper, createDumper, decodeAiFeature, decodeAutoSwitch, decodeAutoSwitchAll, encodeAiFeatureWrite, encodeAutoSwitchWrite, extractMowerConsumableValues, getMowerCapabilities, getVacuumCapabilities, isAuthRefusedError, isDreameConsumableKey, mowerConsumableIndex, mowerFaultSeverity, parseMowerConsumables, parseMowerHeartbeat, parseMowingProgress, renderMowerSvg, renderVacuumPng, resolveCapabilities, supportedAutoSwitchKeys };
+/**
+ * Public types for the video control-plane. The Dreamehome cloud fronts several
+ * camera backends ("vendors"); a device advertises which ones it supports and
+ * which one it is currently provisioned on. This module models only the
+ * control-plane (token + session negotiation); the media transport per vendor
+ * is built on top of it.
+ */
+/** Camera backend a device streams through. `tx` = Tencent, `ali` = Aliyun LinkVisual. */
+type VideoVendor = 'tx' | 'ali';
+/** Short-lived token minted by `tx/user/accesstoken`, used by the video endpoints. */
+interface VideoAccessToken {
+    /** Opaque bearer for the third-video service (distinct from the account token). */
+    readonly token: string;
+    /** Numeric video-service user id, as a string. */
+    readonly userId: string | null;
+    /** Epoch-ms at which {@link token} expires (converted from the cloud's epoch-seconds). */
+    readonly expiresAt: number;
+}
+/**
+ * A device's video profile, derived from its cloud record. Tells you whether the
+ * device has a camera, which vendors it supports, which one it is on now, and —
+ * when on Aliyun — its LinkVisual `iotId` (the id every LinkVisual call needs).
+ */
+interface DeviceVideoProfile {
+    /** Dreame device id (the `did`). */
+    readonly did: string;
+    /** Model code, e.g. `dreame.vacuum.r2538z`. */
+    readonly model: string;
+    /** Human product name, e.g. `X50 Ultra Complete`. */
+    readonly displayName: string | null;
+    /** True when the device exposes a camera stream (`permit === "video"`). */
+    readonly videoCapable: boolean;
+    /** The vendor the device is currently provisioned on (`''` in the record → null). */
+    readonly currentVendor: VideoVendor | null;
+    /** Vendors the device can use, in cloud-declared order. */
+    readonly supportedVendors: readonly VideoVendor[];
+    /** True when the cloud picks the vendor dynamically at session time. */
+    readonly dynamicVendor: boolean;
+    /** Aliyun LinkVisual device id, when the device is on (or has been on) Aliyun. */
+    readonly iotId: string | null;
+    /** Whether the device is online. */
+    readonly online: boolean;
+}
+
+/** Shared inputs for every video control-plane call. Mirrors `listDevices`. */
+interface VideoRequestInput {
+    session: DreameSession;
+    region: DreameRegion;
+    ctx?: RequestContext;
+    country?: string;
+    lang?: string;
+    apiHost?: string;
+    fetchImpl?: FetchImpl;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+/**
+ * Mint the short-lived third-video access token. Required as a body field by the
+ * device-scoped video calls (getIdentity, getP2PInfo, …).
+ */
+declare function getVideoAccessToken(input: VideoRequestInput): Promise<VideoAccessToken>;
+/**
+ * Fetch the Aliyun authCode blob (`getAuthCodeV3`). This opaque hex string is the
+ * material exchanged with Aliyun IoT to obtain a LinkVisual identity — the first
+ * step of the Aliyun media path.
+ */
+declare function getAliyunAuthCode(input: VideoRequestInput): Promise<string>;
+/**
+ * Fetch the account's video `familyId` (used to scope some vendor calls). This
+ * endpoint requires the third-video access token in the body — pass one via
+ * `videoToken`, otherwise a fresh one is minted with {@link getVideoAccessToken}.
+ */
+declare function getVideoFamilyId(input: VideoRequestInput & {
+    videoToken?: string;
+}): Promise<string>;
+/**
+ * Resolve a device's video profile (vendor, supported vendors, Aliyun iotId,
+ * capability) from its cloud record. `did` is the Dreame device id.
+ */
+declare function getDeviceVideoProfile(input: VideoRequestInput & {
+    did: string;
+}): Promise<DeviceVideoProfile>;
+
+/**
+ * Why this device cannot open a camera channel — or `null` when it can.
+ *
+ * The camera path needs one thing from the cloud: the `iotId`, which is the
+ * CHANNEL id `startMonitor` addresses (for both vendors — see
+ * `startMonitorParams`). When it is absent the call cannot proceed, and for a
+ * long time that was reported as a single sentence covering four different
+ * situations:
+ *
+ *   "device has no LinkVisual iotId; not a camera device or not provisioned"
+ *
+ * A CamStack operator met it on a robot whose camera they had just enabled in
+ * the Dreame app (2026-09-16). Working out which of the four they were in
+ * meant reading this library's source — the sentence names a MISSING FIELD,
+ * not a cause, and the profile sitting right next to it already knows whether
+ * the device is a camera at all, whether it is online, and which vendors it is
+ * on and supports.
+ *
+ * The four states want four different actions:
+ *
+ *   - not a camera        → wrong device; nothing done here will help
+ *   - offline             → wait; the binding is published BY the device
+ *   - camera, online, no channel → open it once in the vendor app, which is
+ *                           what creates the binding
+ *   - channel present     → not this function's business
+ *
+ * Pure, so it is testable against captured profiles without a cloud.
+ */
+declare function explainNoCameraChannel(profile: DeviceVideoProfile): string | null;
+
+/** A device record as returned by `device/info` (`data` = single record). */
+declare const DeviceInfoRecordSchema: z.ZodObject<{
+    did: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    model: z.ZodOptional<z.ZodString>;
+    customName: z.ZodOptional<z.ZodString>;
+    vendor: z.ZodOptional<z.ZodString>;
+    online: z.ZodOptional<z.ZodBoolean>;
+    lwt: z.ZodOptional<z.ZodNumber>;
+    property: z.ZodOptional<z.ZodString>;
+    bindDomain: z.ZodOptional<z.ZodString>;
+    deviceInfo: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        permit: z.ZodOptional<z.ZodString>;
+        videoDynamicVendor: z.ZodOptional<z.ZodBoolean>;
+        defaultVendors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        productId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        model: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        permit: z.ZodOptional<z.ZodString>;
+        videoDynamicVendor: z.ZodOptional<z.ZodBoolean>;
+        defaultVendors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        productId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        model: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        permit: z.ZodOptional<z.ZodString>;
+        videoDynamicVendor: z.ZodOptional<z.ZodBoolean>;
+        defaultVendors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        productId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    did: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    model: z.ZodOptional<z.ZodString>;
+    customName: z.ZodOptional<z.ZodString>;
+    vendor: z.ZodOptional<z.ZodString>;
+    online: z.ZodOptional<z.ZodBoolean>;
+    lwt: z.ZodOptional<z.ZodNumber>;
+    property: z.ZodOptional<z.ZodString>;
+    bindDomain: z.ZodOptional<z.ZodString>;
+    deviceInfo: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        permit: z.ZodOptional<z.ZodString>;
+        videoDynamicVendor: z.ZodOptional<z.ZodBoolean>;
+        defaultVendors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        productId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        model: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        permit: z.ZodOptional<z.ZodString>;
+        videoDynamicVendor: z.ZodOptional<z.ZodBoolean>;
+        defaultVendors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        productId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        model: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        permit: z.ZodOptional<z.ZodString>;
+        videoDynamicVendor: z.ZodOptional<z.ZodBoolean>;
+        defaultVendors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        productId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    did: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    model: z.ZodOptional<z.ZodString>;
+    customName: z.ZodOptional<z.ZodString>;
+    vendor: z.ZodOptional<z.ZodString>;
+    online: z.ZodOptional<z.ZodBoolean>;
+    lwt: z.ZodOptional<z.ZodNumber>;
+    property: z.ZodOptional<z.ZodString>;
+    bindDomain: z.ZodOptional<z.ZodString>;
+    deviceInfo: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        permit: z.ZodOptional<z.ZodString>;
+        videoDynamicVendor: z.ZodOptional<z.ZodBoolean>;
+        defaultVendors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        productId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        model: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        permit: z.ZodOptional<z.ZodString>;
+        videoDynamicVendor: z.ZodOptional<z.ZodBoolean>;
+        defaultVendors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        productId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        model: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        permit: z.ZodOptional<z.ZodString>;
+        videoDynamicVendor: z.ZodOptional<z.ZodBoolean>;
+        defaultVendors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        productId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">>;
+type DeviceInfoRecord = z.infer<typeof DeviceInfoRecordSchema>;
+
+/**
+ * Derive a {@link DeviceVideoProfile} from a raw device record. Pure — no I/O —
+ * so it is unit-testable against captured records. `videoCapable` is true when
+ * the cloud marks the device `permit: "video"` or lists any supported vendor.
+ */
+declare function toVideoProfile(record: DeviceInfoRecord): DeviceVideoProfile;
+
+/**
+ * Aliyun API Gateway ("x-ca") request signing, HmacSHA1. Used by the LinkVisual
+ * video endpoints the Dreamehome app talks to (living-account + api-iot hosts).
+ *
+ * The string to sign is:
+ *   METHOD\n Accept\n Content-MD5\n Content-Type\n Date\n <signed-headers-block> <resource>
+ * where the signed-headers block is `Name:Value\n` for each header named in
+ * `X-Ca-Signature-Headers`, sorted case-insensitively, and `resource` is the
+ * path plus, for form bodies, the `?`-joined sorted form params.
+ *
+ * Verified byte-for-byte against a captured connect.json request (see tests).
+ */
+interface SignedRequest {
+    headers: Record<string, string>;
+    body: string;
+}
+interface SignInput {
+    method: 'POST' | 'GET';
+    host: string;
+    path: string;
+    appKey: string;
+    appSecret: string;
+    /** JSON payload → sent as the raw body with a Content-MD5. */
+    json?: unknown;
+    /** Form fields → sent as application/x-www-form-urlencoded and folded into the resource. */
+    form?: Record<string, string>;
+    /** Extra x-ca headers to sign (e.g. `{ 'X-Ca-Stage': 'RELEASE' }`). */
+    extraCaHeaders?: Record<string, string>;
+    /** Overrides for deterministic tests. */
+    nonce?: string;
+    timestamp?: number;
+    date?: string;
+}
+/** Build the x-ca headers + body for a request. */
+declare function signApiGatewayRequest(input: SignInput): SignedRequest;
+
+/** LinkVisual live-stream descriptor returned by /vision/customer/stream/query. */
+interface StreamInfo {
+    /** Connection strategies the cloud offers, e.g. ["Direct","Relay","NAT"]. */
+    typeList: string[];
+    /** RTMP relay URL. Plain (playable directly) when requested with relayEncrypted:false. */
+    relayUrl: string | null;
+    /** AES key/iv for the relay payload — present (non-empty) only when relayEncrypted:true. */
+    relayDecryptKey: {
+        iv: string;
+        key: string;
+    } | null;
+    /** P2P (Direct/NAT) parameters: STUN/TURN + the WebSocket signaling URL. */
+    p2pInfo: {
+        stunUrl?: string;
+        alterStunUrl?: string;
+        signalUrl?: string;
+        portDetectStunUrlList?: string[];
+    } | null;
+    supportVisionPtz?: boolean;
+}
+interface StreamQueryInput {
+    /** Aliyun IoT region id, e.g. `eu-central-1`. */
+    regionId: string;
+    /** Short-lived IoT identity token (from createSessionByAuthCode). */
+    iotToken: string;
+    /** LinkVisual device id. */
+    iotId: string;
+    /**
+     * When false (default) the relay RTMP carries a PLAIN (unencrypted) FLV, so it
+     * can be handed straight to ffmpeg. When true the payload is AES-encrypted and
+     * `relayDecryptKey` is returned.
+     */
+    relayEncrypted?: boolean;
+    /** 0 = HD main stream (default). */
+    streamType?: number;
+    appKey?: string;
+    appSecret?: string;
+    fetchImpl?: FetchImpl;
+    signal?: AbortSignal;
+}
+/**
+ * Query the LinkVisual live stream for a device. Returns the relay RTMP URL and
+ * P2P parameters. Note: each returned relay token is single-use — request a
+ * fresh one per consumer.
+ */
+declare function streamQuery(input: StreamQueryInput): Promise<StreamInfo>;
+
+/** Aliyun OpenAccount session from loginbyoauth. */
+interface OaSession {
+    sid: string;
+    refreshToken: string;
+    openId: string;
+}
+/** Aliyun IoT session (the iotToken used by every LinkVisual call). */
+interface IotSession {
+    iotToken: string;
+    refreshToken: string;
+    identityId: string;
+    /** Epoch-ms at which iotToken expires. */
+    expiresAt: number;
+}
+interface LoginByOauthInput {
+    authCode: string;
+    regionId: string;
+    deviceId?: string;
+    utdid?: string;
+    fetchImpl?: FetchImpl;
+}
+/** Exchange the Dreame authCode for an Aliyun OpenAccount session (step 2). */
+declare function loginByOauth(input: LoginByOauthInput): Promise<OaSession>;
+interface CreateIotSessionInput {
+    /** The OpenAccount `sid` from {@link loginByOauth}. */
+    sid: string;
+    regionId: string;
+    fetchImpl?: FetchImpl;
+}
+/** Exchange the OA `sid` for an Aliyun IoT session / iotToken (step 3). */
+declare function createIotSession(input: CreateIotSessionInput): Promise<IotSession>;
+
+/** Aliyun IoT region id per Dreame region. Only `eu-central-1` is verified live. */
+declare const ALIYUN_REGION_ID: Record<DreameRegion, string>;
+
+interface DreameVideoSessionInput {
+    /** An authenticated Dreame account session (from `Nodreame`). */
+    session: DreameSession;
+    region: DreameRegion;
+    fetchImpl?: FetchImpl;
+}
+/**
+ * High-level video session for a Dreame account. Establishes and caches the
+ * Aliyun IoT identity (iotToken), and mints fresh LinkVisual RTMP stream URLs
+ * on demand. Each returned relay URL is single-use — call {@link getStreamInfo}
+ * (or {@link getRtmpUrl}) once per consumer.
+ *
+ * The plain (unencrypted) relay URL is a standard RTMP stream: hand it straight
+ * to ffmpeg / scrypted / camstack. No local muxing or RTSP server required here.
+ */
+declare class DreameVideoSession {
+    #private;
+    constructor(input: DreameVideoSessionInput);
+    /** The resolved Aliyun IoT region id (e.g. `eu-central-1`). */
+    get regionId(): string;
+    /** Mint (or reuse) a valid Aliyun IoT session, refreshing before expiry. */
+    ensureIotSession(): Promise<IotSession>;
+    /**
+     * Mint a fresh LinkVisual stream descriptor for a device. `encrypted:false`
+     * (default) yields a plain RTMP relay URL directly playable by ffmpeg.
+     *
+     * A camera that has been idle reports "device offline" until the query wakes
+     * its video agent via the LinkVisual cloud. This transparently retries on that
+     * (up to `wakeTimeoutMs`, default 30s) so a single call returns a live stream;
+     * pass `wakeTimeoutMs: 0` to fail fast instead.
+     */
+    getStreamInfo(iotId: string, opts?: {
+        encrypted?: boolean;
+        wakeTimeoutMs?: number;
+        pollMs?: number;
+    }): Promise<StreamInfo>;
+    /**
+     * Convenience: mint a fresh plain RTMP relay URL for a device, or `null` when
+     * the device is not currently streaming (no relay available).
+     */
+    getRtmpUrl(iotId: string): Promise<string | null>;
+}
+
+/**
+ * Parsers for the robot's on-device AI detections, pushed as camera-service
+ * properties (subscribe to `propertyChanged` for SIID 10001):
+ *   - piid 110 (`personFollow` / PERSON_DATA): a tracked-person bounding box
+ *   - piid 112 (`videoObstacleData`): a list of obstacle boxes
+ *
+ * The overlay for obstacle boxes is gated on `set_properties siid 28 piid 13 = 1`.
+ * Payloads are JSON strings; these parsers are lenient (return `null` on garbage)
+ * and normalize timestamps (the device reports nanoseconds).
+ */
+/** A normalized detection box. Coordinates are passed through as-reported. */
+interface DetectionBox {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+    /** Optional label/class if the payload carries one. */
+    readonly label?: string;
+    /** Optional confidence if the payload carries one. */
+    readonly score?: number;
+}
+interface PersonFollowDetection {
+    /** Detection time in epoch milliseconds (converted from the device's ns). */
+    readonly timestampMs: number;
+    readonly box: DetectionBox | null;
+}
+interface ObstacleDetection {
+    readonly timestampMs: number;
+    readonly boxes: readonly DetectionBox[];
+}
+/** Parse a `personFollow` (piid 110) payload into a normalized detection. */
+declare function parsePersonFollow(value: unknown): PersonFollowDetection | null;
+/** Parse a `videoObstacleData` (piid 112) payload into normalized boxes. */
+declare function parseObstacleData(value: unknown): ObstacleDetection | null;
+
+type AmfValue = number | boolean | string | null | undefined | AmfValue[] | {
+    [key: string]: AmfValue;
+};
+
+declare const LV_STATUS: {
+    readonly REQUEST_AUDIO_TYPE: "NetStream.RequestAudioType";
+    readonly FORCE_IFRAME_START: "NetStream.ForceIFrame.Start";
+    readonly PING_START: "NetStream.Ping.Start";
+    readonly PING_RESPONSE: "NetStream.Ping.Response";
+    readonly PRE_CONNECT: "NetStream.PreConnect";
+    readonly KEEPALIVE: "NetStream.Keepalive";
+    readonly SERVER_INFO: "NetStream.ServerInfo";
+    readonly TRANSFER_DATA: "NetStream.TransferData";
+    readonly PLAY_START: "NetStream.Play.Start";
+    /** Server signals the talk (intercom uplink) channel is ready. */
+    readonly TALK_READY: "NetStream.TalkReady";
+};
+/**
+ * FLV audio tag header byte for the intercom uplink: G.711 A-law, 8 kHz, 16-bit,
+ * mono — `(7<<4)|(0<<2)|(1<<1)|0` = 0x72. Verified against liblvmedia SetTalkInfo.
+ */
+declare const TALK_AUDIO_HEADER_G711A = 114;
+interface StatusEvent {
+    code: string;
+    level: string;
+    description: string;
+    fields: {
+        [key: string]: AmfValue;
+    };
+    transactionId: number;
+}
+interface VideoAccessUnitEvent {
+    data: Buffer;
+    isKeyframe: boolean;
+    videoType: 'H264';
+    microseconds: number;
+    time?: number;
+}
+interface AudioInfoEvent {
+    codec: 'aac' | 'g711a' | 'g711u' | 'unknown';
+    sampleRate: number;
+    channels: number;
+}
+interface LvRtmpClientOptions {
+    /** relayUrl from stream/query, e.g. rtmp://host:8000/live?token=..&session=../<key>_0 */
+    url: string;
+    /** Appended to app/tcUrl as "&cacheDuration=N" when not already present (the app always sends 3000). */
+    cacheDurationMs?: number;
+    /** Send the onStatus NetStream.RequestAudioType {audio_type:"1"} right after play (app does). */
+    requestAudioType?: boolean;
+    /** Send NetStream.Ping.Start after the first server message and then periodically (app does). */
+    ping?: boolean;
+    pingIntervalMs?: number;
+    /** Also send NetStream.ForceIFrame.Start once playing (the app sends it when it starts an MP4 record). */
+    forceIFrameOnStart?: boolean;
+    connectTimeoutMs?: number;
+    log?: (line: string) => void;
+}
+interface Endpoint {
+    host: string;
+    port: number;
+    app: string;
+    tcUrl: string;
+    playpath: string;
+}
+/**
+ * Split like librtmp/ffmpeg do: playpath = last path segment, app = everything between host and it
+ * (query string included). Verified against the app's connect/play in both pcaps.
+ */
+declare function parseRelayUrl(url: string, cacheDurationMs: number): Endpoint;
+type Events = {
+    connected: [];
+    status: [StatusEvent];
+    command: [string, AmfValue[]];
+    metadata: [{
+        [key: string]: AmfValue;
+    }];
+    audio: [{
+        timestamp: number;
+        body: Buffer;
+    }];
+    video: [{
+        timestamp: number;
+        body: Buffer;
+    }];
+    videoAccessUnit: [VideoAccessUnitEvent];
+    audioFrame: [Buffer];
+    audioInfo: [AudioInfoEvent];
+    error: [Error];
+    close: [];
+};
+declare class LvRtmpClient extends EventEmitter<Events> {
+    private readonly opts;
+    private readonly endpoint;
+    private socket;
+    private handshakeBuf;
+    private handshakeDone;
+    private c1Time;
+    private reader;
+    private transactionId;
+    private bytesIn;
+    private bytesAcked;
+    private ackWindow;
+    private pingTimer;
+    private firstMessageSeen;
+    private avcConfig;
+    private aacConfig;
+    private closed;
+    constructor(options: LvRtmpClientOptions);
+    /** Open TCP, write C0+C1 and the pipelined connect/play/RequestAudioType. Resolves once written. */
+    connect(): Promise<void>;
+    close(): void;
+    /** onStatus encoder — byte-exact replica of liblvmedia IOT_RTMP_SendMessage (csid 3, fmt 1, ts 0). */
+    buildStatus(code: string, extra?: readonly [string, string]): Buffer;
+    sendStatus(code: string, extra?: readonly [string, string]): void;
+    forceIFrame(): void;
+    private buildC0C1;
+    private buildConnect;
+    private buildPlay;
+    /** Exposed for the byte-exact self-test against the pcap. */
+    buildOpeningSequence(): Buffer[];
+    /**
+     * Push one intercom (talk-back) audio frame UPSTREAM to the device — an RTMP
+     * type-8 audio message on the talk chunk stream (csid 4, msid 1), exactly as
+     * liblvmedia's `IOT_RTMP_SendAudio` does. `payload` is the raw codec audio
+     * (default framing = G.711 A-law); `tsMs` is a running millisecond timestamp.
+     * Only meaningful after the server sends {@link LV_STATUS.TALK_READY}.
+     */
+    sendAudioFrame(payload: Buffer, tsMs: number, header?: number): void;
+    private write;
+    private sendAck;
+    private sendPingResponse;
+    private startPinging;
+    private onData;
+    private onHandshake;
+    private dispatch;
+    private onUserControl;
+    private onCommand;
+    private onDataMessage;
+    private onAudio;
+    private onVideo;
+    private fail;
+    private onClose;
+}
+
+/**
+ * End-to-end camera media pipeline: autonomously cold-start the LinkVisual
+ * monitor, connect to the resulting RTMP relay, and re-emit demuxed elementary
+ * frames — H.264 access units (Annex-B, SPS/PPS prepended on keyframes) and AAC
+ * (ADTS) — plus lifecycle events.
+ *
+ * This is the reusable frame feed for any external consumer (scrypted's RFC4571
+ * muxer, camstack, a file writer). It owns the {@link DreameCameraController}
+ * lifecycle: {@link start} opens the monitor and connects; {@link stop} closes
+ * the relay socket and releases the monitor on the device.
+ */
+
+/** The subset of {@link LvRtmpClient} the pipeline drives — injectable for tests. */
+interface FrameSource {
+    connect(): Promise<void>;
+    close(): void;
+    on(event: 'videoAccessUnit', cb: (e: VideoAccessUnitEvent) => void): void;
+    on(event: 'audioFrame', cb: (buf: Buffer) => void): void;
+    on(event: 'audioInfo', cb: (info: AudioInfoEvent) => void): void;
+    on(event: 'status', cb: (e: StatusEvent) => void): void;
+    on(event: 'error', cb: (err: Error) => void): void;
+    on(event: 'close', cb: () => void): void;
+    /** Push an intercom (talk-back) audio frame upstream. */
+    sendAudioFrame(payload: Buffer, tsMs: number, header?: number): void;
+}
+/** Factory for the RTMP frame source; defaults to a real {@link LvRtmpClient}. */
+type FrameSourceFactory = (url: string) => FrameSource;
+interface DreameCameraStreamEvents {
+    /** Emitted once the relay is connected; carries the (single-use) RTMP URL. */
+    started: [{
+        rtmpUrl: string;
+    }];
+    /** One H.264 access unit (Annex-B). */
+    videoAccessUnit: [VideoAccessUnitEvent];
+    /** One audio frame (AAC in ADTS, or raw G.711). */
+    audioFrame: [Buffer];
+    /** Audio format, emitted once known. */
+    audioInfo: [AudioInfoEvent];
+    /** Emitted after the pipeline is fully torn down. */
+    stopped: [];
+    error: [Error];
+    [event: string]: unknown[];
+}
+interface DreameCameraStreamInput {
+    /** A controller for the target camera (not yet opened). */
+    controller: DreameCameraController;
+    /** Override the RTMP client (tests inject a fake). */
+    clientFactory?: FrameSourceFactory;
+    /** Forwarded to {@link LvRtmpClient}: send NetStream.RequestAudioType after play. */
+    requestAudioType?: boolean;
+    /** Forwarded to {@link LvRtmpClient}: send periodic NetStream.Ping. */
+    ping?: boolean;
+    /** Optional line logger for the RTMP client. */
+    log?: (line: string) => void;
+}
+declare class DreameCameraStream extends TypedEmitter<DreameCameraStreamEvents> {
+    #private;
+    constructor(input: DreameCameraStreamInput);
+    /** True while frames are flowing. */
+    get isRunning(): boolean;
+    /**
+     * Cold-start the monitor, connect to the relay, and begin emitting frames.
+     * Resolves once connected. Throws (and cleans up) if the monitor or relay
+     * connection fails.
+     */
+    start(): Promise<{
+        rtmpUrl: string;
+    }>;
+    /** Close the relay connection and release the monitor. Idempotent. */
+    stop(): Promise<void>;
+    /**
+     * Open the two-way intercom: send the MIoT start, then resolve once the relay
+     * signals the talk channel is ready (so it's safe to {@link sendTalkPcm}).
+     * Rejects if not ready within `timeoutMs`.
+     */
+    startTalk(opts?: {
+        needRecordSound?: boolean;
+        videoCall?: boolean;
+        timeoutMs?: number;
+    }): Promise<void>;
+    /** Resolve when the talk channel is ready (or reject on timeout). */
+    whenTalkReady(timeoutMs?: number): Promise<void>;
+    /**
+     * Encode 16-bit LE mono PCM (8 kHz) to G.711 A-law and push it upstream.
+     * `tsMs` defaults to a running clock advanced by the frame duration.
+     */
+    sendTalkPcm(pcm16le: Buffer, tsMs?: number): void;
+    /** Push raw A-law audio upstream (advancing the running talk clock). */
+    sendTalkAlaw(alaw: Buffer, tsMs?: number): void;
+    /** Close the two-way intercom (MIoT stop). */
+    stopTalk(): Promise<void>;
+}
+
+/**
+ * G.711 A-law codec (ITU-T G.711) — the intercom uplink format for Dreame
+ * cameras (8 kHz, mono, 16-bit PCM in). Pure functions, no state.
+ */
+/** Encode one 16-bit signed PCM sample to an A-law byte. */
+declare function pcm16ToALaw(sample: number): number;
+/**
+ * Encode a buffer of little-endian 16-bit PCM samples to A-law bytes
+ * (one output byte per input sample).
+ */
+declare function pcm16leToALaw(pcm: Buffer): Buffer;
+
+interface AvcConfig {
+    sps: Buffer[];
+    pps: Buffer[];
+    nalLengthSize: number;
+}
+interface AacConfig {
+    objectType: number;
+    samplingFrequencyIndex: number;
+    channelConfiguration: number;
+}
+/** Parse an AVCDecoderConfigurationRecord (FLV AVC sequence header payload). */
+declare function parseAvcConfig(rec: Buffer): AvcConfig;
+/** Length-prefixed NALUs -> Annex-B. Prepends SPS/PPS when `prependParams` is set (for keyframes). */
+declare function avccToAnnexB(data: Buffer, cfg: AvcConfig, prependParams: boolean): Buffer;
+declare function parseAacConfig(asc: Buffer): AacConfig;
+declare function aacSampleRate(cfg: AacConfig): number;
+/** Wrap one raw AAC frame in a 7-byte ADTS header. */
+declare function aacToAdts(raw: Buffer, cfg: AacConfig): Buffer;
+
+interface ListDevicesInput {
+    session: DreameSession;
+    region: DreameRegion;
+    ctx?: RequestContext;
+    country?: string;
+    lang?: string;
+    apiHost?: string;
+    fetchImpl?: FetchImpl;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+/** Enumerate the devices visible to the authenticated account (incl. shared). */
+declare function listDevices(input: ListDevicesInput): Promise<DreameDevice[]>;
+
+export { AI_FEATURE_BIT, AI_FEATURE_JSON_KEY, ALIYUN_REGION_ID, AUTO_SWITCH_JSON_KEY, type AacConfig, type AiDetectionRaw, type AudioInfoEvent, type AutoSwitchKey, type AutoSwitchRaw, type AvcConfig, BaseDevice, type BaseDeviceEvents, type BatchDeviceDataFetcher, type BrokerEndpoint, type CameraStreamHandle, type CapabilityResolver, ChargingStatus, type CleanOpts, CleaningMode, type ConsumableReading, type ConsumableSpec, type CreateDeviceArgs, DRIVE_DIRECTIONS, DefaultCapabilityResolver, type DetectionBox, type DeviceCapabilities, type DeviceConnectivity, type DeviceDump, type DeviceEvent, type DeviceVideoProfile, type DreameAiFeature, DreameApiError, DreameAuthError, DreameCameraController, type DreameCameraControllerInput, DreameCameraStream, type DreameCameraStreamEvents, type DreameCameraStreamInput, type DreameCloudState, type DreameConsumableKey, type DreameDevice, DreameDeviceOfflineError, DreameError, type DreameRegion, type DreameSession, DreameTransportError, DreameVideoSession, type DreameVideoSessionInput, type DriveDirection, type DumperOptions, type FrameSource, type FrameSourceFactory, type IotSession, LIBRARY_NAME, LV_STATUS, type ListDevicesInput, LvRtmpClient, type LvRtmpClientOptions, MONITOR_AIID, MONITOR_PIID, MONITOR_SIID, MONITOR_VENDOR_TOKEN, MODEL_CAPABILITIES as MOWER_MODEL_CAPABILITIES, MOWER_TASK_SUBSTATES, type MapBoundingBox, type MapCleanedAreaOverlay, type MapColorScheme, type MapDimensions, type MapFrameType, type MapLayer, type MapLayerType, type MapLowLyingArea, type MapObstacle, type MapPath, type MapPathType, type MapPoint, type MapPose, type MapRestrictedArea, type MapRoom, type MapRoomWall, type MapRun, type MapSegment, type MapStorey, type MapVirtualWall, type MapWallsInfo, type MiotAction, MiotError, type MiotProp, MiotState, type MonitorActionCaller, type MowerAvailableMap, type MowerCapabilities, MowerCapabilityResolver, MowerChargingStatus, type MowerConsumableKey, type MowerConsumableReading, type MowerContour, MowerControlAction, type MowerControlState, MowerDevice, type MowerDeviceInput, MowerFault, type MowerFaultSeverity, type MowerHeartbeat, type MowerMap, type MowerMapBoundary, type MowerMowPath, type MowerMowingProgress, type MowerPathEntry, type MowerPoint, type MowerSpotArea, MowerStatus, type MowerTaskDescriptor, MowerTaskStatus, type MowerTaskSubState, type MowerZone, Nodreame, type NodreameDeps, type NodreameEvents, type NodreameOptions, type OaSession, type ObstacleDetection, type OssFetchInput, type OssFetcherLike, PET_SOUNDS, type PersonFollowDetection, type PetSound, type PropertyChangedEvent, type PropertyResult, type PropertyState, type PropertyWrite, type RelayMinter, type RenderMowerSvgOptions, type RenderVacuumPngOptions, type RenderWifiSignalPngOptions, type StateChangedEvent, type StatusEvent, type StreamInfo, type StreamQueryInput, SuctionLevel, TALK_AUDIO_HEADER_G711A, TaskStatus, VACUUM_ACTIONS, VACUUM_CONSUMABLES, MODEL_CAPABILITIES$1 as VACUUM_MODEL_CAPABILITIES, VACUUM_MOVE, VACUUM_SIID, type VacuumActionKey, type VacuumCapabilities, VacuumCapabilityResolver, VacuumDevice, type VacuumGetMapInput, type VacuumMap, type VideoAccessToken, type VideoAccessUnitEvent, type VideoRequestInput, type VideoVendor, WaterVolume, type WifiSignalMap, type WifiSignalMapInput, aacSampleRate, aacToAdts, avccToAnnexB, consumableSpec, createClientDumper, createDumper, createIotSession, decodeAiFeature, decodeAutoSwitch, decodeAutoSwitchAll, decodeWifiSignalMap, encodeAiFeatureWrite, encodeAutoSwitchWrite, explainNoCameraChannel, extractMowerConsumableValues, getAliyunAuthCode, getDeviceVideoProfile, getMowerCapabilities, getVacuumCapabilities, getVideoAccessToken, getVideoFamilyId, hashAccessCode, isAuthRefusedError, isDreameConsumableKey, listDevices, loginByOauth, makeMonitorSession, mowerConsumableIndex, mowerFaultSeverity, parseAacConfig, parseAvcConfig, parseConnectivity, parseMowerConsumables, parseMowerHeartbeat, parseMowingProgress, parseObstacleData, parsePersonFollow, parseRelayUrl, pcm16ToALaw, pcm16leToALaw, remoteDriveValue, renderMowerSvg, renderVacuumPng, renderWifiSignalPng, resolveCapabilities, signApiGatewayRequest, streamQuery, supportedAutoSwitchKeys, toVideoProfile };