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

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

@@ -0,0 +1,289 @@
+import { type Surface } from "./members.js";
+import type { CapabilityModule, CommandContext } from "./types.js";
+import type { Command } from "../../core/contracts.js";
+/**
+ * The P2P **feature-command ids** this pan-tilt capability drives. Capability-owned wire vocabulary
+ * (transport forwards `cmd.param` opaquely; full id→name catalog in the generated
+ * `transport/p2p/commands.ts`). Distinct from the {@link PTZ_ROTATE} direction map below (which is
+ * `rotate_type` 1..4, not a command id).
+ *
+ * Ids + envelopes are taken from the V6 app's own command builders (the `Set*Parser`/`*PositionsParser`
+ * classes in the decompiled JS), which is this project's wire ground truth — NOT a third-party
+ * catalogue, whose PTZ labels are known-wrong here (one labels 6038 a rotate; the app sends it as a
+ * span-cruise preview).
+ */
+export declare const PTZ_CMD: {
+    /** Rotate. App `SetPtz…`/`INDOOR_ROTATE`: 1700 wrapper, `{cmd_type,rotate_type,zoom}`. */
+    readonly PTZ_ROTATE: 6030;
+    /** Digital zoom. App `SetPictureZoomParser` (`COMMAND_DUAL_CAMERA_ZOOM`): 1350 SET_PAYLOAD sub-command,
+     * payload `{x,y,w,h,offset,orgZoom,dstZoom}`. Also the inbound `1351` zoom-notify `cmd`. */
+    readonly PTZ_ZOOM: 6203;
+    /** Go to a stored preset — AND the save-preset frame (identical bytes; the camera moves vs creates
+     * by whether the slot is occupied). App `SetPresetPositionsParser` (`COMMAND_INDOOR_SPAN_CRUISE_POINT`):
+     * 1700 wrapper, `{settingstate:0, value:<presetId>}`. */
+    readonly PTZ_PRESET_GOTO: 6032;
+    /** Capture the camera's current frame as a preset's thumbnail. App `COMMAND_APP_SPAN_PTZ_PIC`: 1700
+     * wrapper, `{value:<presetId>}`. The app sends this right before the 6032 save when creating a preset. */
+    readonly PTZ_PRESET_PIC: 6097;
+    /** Delete a stored preset. App `DeletePresetPositionsParser` (`COMMAND_INDOOR_SPAN_CRUISE_DELETE`):
+     * 1700 wrapper, `{value:<presetId>}`. */
+    readonly PTZ_PRESET_DELETE: 6033;
+    /** List stored presets. App `QueryPresetPositionsParser` (`COMMAND_INDOOR_SPAN_CRUISE_QUERY`): 1700
+     * request whose reply is a `1351` notify carrying `{points:[…]}`. */
+    readonly PTZ_PRESET_QUERY: 6034;
+    /** Preview a stored preset — move to it transiently (the app uses this to show a preset before
+     * committing a default). App `COMMAND_INDOOR_SPAN_CRUISE_PREVIEW`: 1700 wrapper, `{value:<presetId>}`. */
+    readonly PTZ_PRESET_PREVIEW: 6035;
+    /** Mark a stored preset as the default/home position. App `DefaultPresetPositionsParser`
+     * (`COMMAND_APP_SET_DEFAULT_POSITION`): 1350 SET_PAYLOAD, payload `{index:<presetId>, settingstate}`.
+     * A compound builder — the app follows it with PREVIEW (6035) + PTZ_PIC (6097) to refresh the
+     * thumbnail; the default-set itself is this frame. */
+    readonly PTZ_SET_DEFAULT_POSITION: 6242;
+    /** How fast a rotate STEP travels. 1700 wrapper, `{value:1|3|5}`. Observed live: the app's
+     * Slow/Mid/Fast control on an indoor pan-tilt writes 1 / 3 / 5 and nothing else moves. The id sits
+     * inside the smart lock's `601x` block, so the shared param dictionary labels it `lockParam` — an id
+     * reused across product lines, and the camera's meaning is the observed one. */
+    readonly PTZ_ROTATE_SPEED: 6015;
+};
+/**
+ * Optional digital-zoom crop window for `zoom`. The app's `SetPictureZoomParser`
+ * carries a region alongside the target factor; when `offset` is false the region is ignored and the
+ * zoom is centred (x/y/w/h sent as 0). Coordinates are the app's own normalised values — pass them
+ * through only when mirroring a captured region.
+ */
+export type ZoomRegion = {
+    x?: number;
+    y?: number;
+    w?: number;
+    h?: number;
+    /** When true, the x/y/w/h crop is applied; when false (default) the zoom is centred. */
+    offset?: boolean;
+    /** The zoom factor the region is relative to (app default 0). */
+    orgZoom?: number;
+};
+/** One stored PTZ preset, as returned by `list`. Shape follows the app's
+ * `query_preset_positions` reply `points[]`; fields beyond `id` vary by model, so the raw entry is
+ * preserved. */
+export type PtzPreset = {
+    /** The preset id used by `goto` / `delete`. */
+    id: number;
+    /** The raw reply entry, for fields (name/thumbnail/coordinates) that vary by model. */
+    raw: Record<string, unknown>;
+};
+/** A preset's thumbnail, as returned by `image`. Follows the app's
+ * `get_preset_position_pic` reply `{data, index}`. */
+export type PtzPresetImage = {
+    /** The preset id the image belongs to (`-1` if the reply omitted it). */
+    index: number;
+    /** The thumbnail image payload as the camera delivers it (a base64-encoded JPEG). */
+    data: string;
+};
+/**
+ * The preset sub-API — everything that acts on a stored PTZ preset, grouped under `dev.ptz().preset()`.
+ * The write verbs are always present; the read verbs (`list`/`image`) are request/reply over P2P and so
+ * present only when the device is bound to a live client — call them with `?.`.
+ *
+ * The `id`-taking write verbs are **fire-and-forget** (P2P sends no ack): referencing an empty slot is
+ * a **silent no-op** — the camera ignores it and no error surfaces here. Only `save(id)` populates a
+ * slot; `goto`/`preview`/`setDefault`/`delete` on an unpopulated `id` do nothing. Check `list?()` first
+ * if the id might not exist.
+ */
+export type PtzPresetActions = {
+    /** Move to the stored preset `id`. No-op if `id` isn't a saved preset (see the type note). */
+    goto(id: number): Promise<void>;
+    /** Preview the stored preset `id` — move to it transiently (the app's pre-default preview). No-op if
+     * `id` isn't a saved preset. */
+    preview(id: number): Promise<void>;
+    /** Save the camera's current position into preset `id` (thumbnail + save). Creates the preset when
+     * the slot is empty, overwrites it when occupied. */
+    save(id: number): Promise<void>;
+    /** Promote a preset to the default/home position. Sets the default to the preset the camera is
+     * **currently parked on**, so the sequence is `preview(id)` → wait for the pan to finish →
+     * `setDefault(id)`; sent with the camera elsewhere it has no effect. */
+    setDefault(id: number): Promise<void>;
+    /** Delete the stored preset `id`. No-op if `id` isn't a saved preset. */
+    delete(id: number): Promise<void>;
+    /** List the stored presets. Present only when the device is bound to a live client, so call with `?.`. */
+    list?(opts?: {
+        timeoutMs?: number;
+    }): Promise<PtzPreset[]>;
+    /** Fetch preset `id`'s thumbnail. Present only when the device is bound to a live client, so call with
+     * `?.`. Resolves `undefined` when the reply carried no image data — typically nothing stored for that
+     * preset. A reply that never arrives rejects instead. */
+    image?(id: number, opts?: {
+        timeoutMs?: number;
+    }): Promise<PtzPresetImage | undefined>;
+};
+/**
+ * Bound pan/tilt/zoom (PTZ) controls — the object returned by `dev.ptz()`. Movement is
+ * command-driven (the camera has no "go to angle X" write; it steps in a direction). Preset operations
+ * are grouped under {@link PtzPresetActions} via `preset()` (e.g. `dev.ptz().preset().goto(3)`).
+ */
+export type PtzActions = Surface<typeof PTZ_MEMBERS>;
+/**
+ * Rotate direction. `PtzDirection` is both the const value-object (`PtzDirection.left`) and the
+ * union type of its values, so callers use the named constant: `rotate(PtzDirection.left)`.
+ */
+export declare const PtzDirection: {
+    /** Pan left (one step). */
+    readonly left: "left";
+    /** Pan right (one step). */
+    readonly right: "right";
+    /** Tilt up (one step). */
+    readonly up: "up";
+    /** Tilt down (one step). */
+    readonly down: "down";
+};
+export type PtzDirection = (typeof PtzDirection)[keyof typeof PtzDirection];
+/** Pan-tilt rotate direction → `rotate_type` (the on-wire code). Not re-exported by the barrel —
+ * stays internal to the capability. Confirmed on hardware (T8425): 1=left, 2=right, 3=up, 4=down. */
+export declare const PTZ_ROTATE: {
+    readonly left: 1;
+    readonly right: 2;
+    readonly up: 3;
+    readonly down: 4;
+};
+/**
+ * Pan-tilt rotate as a transport-neutral {@link Command}. CONFIRMED wire command (captured on
+ * T8425 ch3 during live-view): `{"commandType":6030,"data":{"cmd_type":1,"rotate_type":1..4,
+ * "zoom":1.0}}` under the generic control wrapper `1700` on the camera channel. `cmd_type:1` =
+ * move; `zoom` defaults to 1.0.
+ *
+ * Emitted as a `set-json` intent — the capability names only the param + payload; the transport
+ * resolver picks the encryption level by topology (standalone → L1, HomeBase → L2). A PT cam can be
+ * either, so the level is NOT fixed here.
+ */
+export declare function rotateCommand(direction: PtzDirection, ctx: CommandContext, zoom?: number): Command;
+/**
+ * Digital-zoom as a transport-neutral {@link Command}. The V6 app's `SetPictureZoomParser` builds a
+ * `SET_PAYLOAD` (1350) sub-command `COMMAND_DUAL_CAMERA_ZOOM` with the crop-window payload
+ * `{x,y,w,h,offset,orgZoom,dstZoom}`; the region collapses to zeros unless `offset` is set. `dstZoom`
+ * is the target factor. `mValue3:0` — verified byte-exact against a live capture of the real app's own
+ * pinch-zoom gesture; NOT `mValue3:cmd` like the general `SET_PAYLOAD` default (see `setPayload`'s doc).
+ */
+export declare function zoomCommand(dstZoom: number, ctx: CommandContext, region?: ZoomRegion): Command;
+/**
+ * Go-to-preset as a transport-neutral {@link Command}. The V6 app's `SetPresetPositionsParser` builds
+ * a 1700-wrapper sub-command `COMMAND_INDOOR_SPAN_CRUISE_POINT` with `{settingstate:0, value:<id>}`
+ * (the app follows it with a query + thumbnail fetch; the move itself is this frame).
+ */
+export declare function gotoPresetCommand(id: number, ctx: CommandContext): Command;
+/**
+ * Delete-preset as a transport-neutral {@link Command}. The V6 app's `DeletePresetPositionsParser`
+ * builds a 1700-wrapper sub-command `COMMAND_INDOOR_SPAN_CRUISE_DELETE` with `{value:<id>}`.
+ */
+export declare function deletePresetCommand(id: number, ctx: CommandContext): Command;
+/**
+ * Preview-preset as a transport-neutral {@link Command}. The V6 app's `COMMAND_INDOOR_SPAN_CRUISE_PREVIEW`
+ * sub-command carries `{value:<id>}`; the app moves the camera to preset `id` to preview it (decoded on
+ * a T8170 SoloCam: `{"commandType":6035,"data":{"value":3}}`).
+ */
+export declare function previewPresetCommand(id: number, ctx: CommandContext): Command;
+/**
+ * Capture-current-frame-as-thumbnail as a transport-neutral {@link Command}. The V6 app's
+ * `COMMAND_APP_SPAN_PTZ_PIC` sub-command carries `{value:<id>}`; the app emits it immediately before
+ * the 6032 save when creating a preset (see {@link savePresetCommand}).
+ */
+export declare function presetPicCommand(id: number, ctx: CommandContext): Command;
+/**
+ * Save the camera's CURRENT position into preset `id`, as the two frames the V6 app emits to create a
+ * preset (decoded on a T8170 SoloCam): `COMMAND_APP_SPAN_PTZ_PIC {value:id}` (thumbnail) then
+ * `COMMAND_INDOOR_SPAN_CRUISE_POINT {settingstate:0, value:id}` (save). The save frame is byte-identical
+ * to {@link gotoPresetCommand}; the camera creates vs moves by whether slot `id` is occupied.
+ */
+export declare function savePresetCommand(id: number, ctx: CommandContext): [Command, Command];
+/**
+ * Promote a stored preset to the default/home position, as a transport-neutral {@link Command}. The V6
+ * app's `DefaultPresetPositionsParser` builds a 1350 SET_PAYLOAD `COMMAND_APP_SET_DEFAULT_POSITION`
+ * `{index:<presetId>, settingstate:0}`.
+ *
+ * 6242 sets the default to the preset the camera is **currently parked on**. To move the default, park
+ * the camera on `presetId` first — `preview(presetId)`, let the pan finish, then `setDefault(presetId)`.
+ * Sent while the camera is elsewhere, it has no effect. The parser is topology-agnostic; the router
+ * picks the encryption level (L1/L2) by topology.
+ */
+export declare function setDefaultPositionCommand(presetId: number, ctx: CommandContext): Command;
+/**
+ * Parse a `query_preset_positions` reply (`{points:[…]}`) into {@link PtzPreset}s. Mirrors the app's
+ * `query_preset_positions_parse_payload`, which reads the reply's `points` array. The id field is
+ * `index` — confirmed live on a T8171 SoloCam, whose reply entries are
+ * `{index, enable, zoom, isdefault}` (8 slots, `enable:0` = empty). `id`/`value` are accepted as
+ * fallbacks for other models; the full entry is preserved as `raw`.
+ */
+export declare function parsePresetPoints(reply: Record<string, unknown> | undefined): PtzPreset[];
+/**
+ * Parse a `get_preset_position_pic` reply into a {@link PtzPresetImage}. Mirrors the app's
+ * `get_preset_position_pic_parse_payload`, which reads `{data, index}` off the notify (`data` = the
+ * thumbnail, `index` defaults to `-1`). Returns `undefined` when the reply carries no image.
+ */
+export declare function parsePresetImage(reply: Record<string, unknown> | undefined): PtzPresetImage | undefined;
+/**
+ * Every `ptz` feature, declared once.
+ *
+ * Movement is command-driven, so almost every entry is a `method`: `rotate` takes a direction plus an
+ * optional speed, the four compass verbs take nothing, `preset()` returns a whole sub-API, and `zoom`
+ * is gated on the device having a second lens. `rotationSpeed` is the one value member — the camera's
+ * own step speed, which it stores. There is no position member: no device reports where it is pointed
+ * as a parameter. Position arrives only while the camera moves, as the `ptzNotify` event {@link PTZ}
+ * decodes from a live frame.
+ *
+ * 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 PTZ_MEMBERS: {
+    /**
+     * How fast a rotate STEP travels, on the app's own three-position control: `1` slow, `3` mid, `5`
+     * fast. A `scalar` rather than an enum — the endpoints and the midpoint are observed, so 2 and 4 are
+     * a prediction of the scale's shape and the wire is not known to reject them.
+     *
+     * Not the same thing as `rotate`'s `zoom` argument, which scales one step's SIZE rather than its
+     * speed.
+     *
+     * The parameter is **absent until first written**: a camera whose speed has never been set reports
+     * no `6015` at all, so the getter is installed only once the value exists — an absent reading is "not
+     * configured", never "unsupported".
+     */
+    readonly rotationSpeed: {
+        readonly param: 6015;
+        readonly type: "number";
+        readonly kind: "scalar";
+        readonly provenance: "verified";
+        readonly description: string;
+        readonly write: (v: string | number | boolean, ctx: CommandContext) => Command | undefined;
+    };
+    /** Rotate a step in a direction; `zoom` scales the step size (1.0 = the default step). */
+    readonly rotate: import("./members.js").MethodMember<(direction: PtzDirection, zoom?: number) => Promise<void>>;
+    /** Rotate one step left. */
+    readonly left: import("./members.js").MethodMember<() => Promise<void>>;
+    /** Rotate one step right. */
+    readonly right: import("./members.js").MethodMember<() => Promise<void>>;
+    /** Rotate one step up. */
+    readonly up: import("./members.js").MethodMember<() => Promise<void>>;
+    /** Rotate one step down. */
+    readonly down: import("./members.js").MethodMember<() => Promise<void>>;
+    /**
+     * Zoom rides a SECOND (telephoto) lens, so it is offered only where the device shows zoom evidence —
+     * otherwise `dev.ptz()?.zoom` would be a silent no-op on a single-lens pan-tilt camera.
+     */
+    readonly zoom: import("./members.js").MethodMember<(dstZoom: number, region?: ZoomRegion) => Promise<void>> & {
+        available: (ctx: CommandContext) => boolean;
+    };
+    /**
+     * The preset sub-API. Write verbs dispatch through the sink; the READ verbs (`list`/`image`) are P2P
+     * request/reply and exist only when bound to a media provider — the transport stays
+     * capability-agnostic (it runs a generic control-payload query and resolves the correlated notify)
+     * while this module owns the sub-command id and the reply parsing.
+     *
+     * `answers` because calling it performs nothing: it hands back the namespace the verbs live on. Offering
+     * it as a control would produce one that returns an object and does nothing.
+     */
+    readonly preset: {
+        readonly method: (deps: import("./members.js").MemberDeps) => () => PtzPresetActions;
+        readonly description: string;
+        readonly available?: (ctx: CommandContext) => boolean;
+        readonly args?: readonly import("./types.js").ActionArgSpec[];
+        readonly answers: true;
+    };
+};
+export declare const PTZ: CapabilityModule;

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

@@ -0,0 +1,221 @@
+import type { Command } from "../../core/contracts.js";
+import { type Surface } from "./members.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: {
+    /**
+     * RTSP publish switch (app `NAS_STREAM_SWITHC`, the vendor's own typo for SWITCH). `1` publishes the
+     * camera's stream, `0` withdraws it. ✅ Verified live 2026-08-01 on a HomeBase-attached doorbell and
+     * two indoor cameras: written through this param's scalar wire, both directions confirmed by the
+     * stream appearing and disappearing on the serving device's RTSP port.
+     */
+    readonly STREAM_SWITCH: 1145;
+    /**
+     * The camera's authoritative RTSP URL — `rtsp://user:pass@host/path`, with the credentials it is
+     * enforcing right now. The station pushes this back on the 1145 wire as a string data frame once the
+     * stream is asked to start (see the transport's device-URL read); {@link RTSP.decodeState} lifts it
+     * into state, read as `dev.rtsp()?.url`.
+     *
+     * A SYNTHETIC id: the wire supplies no second id — the URL rides the same 1145 as the publish bool,
+     * and {@link STREAM_SWITCH} already owns that — so the string gets its own id here, keeping the two as
+     * distinct properties rather than one id read two ways. Never in the cloud record (P2P-notify only), so
+     * it is quarantined in `property-id-integrity`'s `KNOWN_UNLISTED` — which otherwise holds real-but-unlisted
+     * ids (1612), so its entry for this one says it is not a wire id at all.
+     *
+     * `1145 * 10` is a readable, currently-free number, NOT a reserved allocation — height buys nothing,
+     * the dictionary already holds real ids past 100000. It is the only synthetic id today; if a second is
+     * ever needed, reserve a stated band for them rather than copying this per-site choice.
+     */
+    readonly STREAM_URL: 11450;
+    /**
+     * RTSP credentials + the authentication switch (app `NAS_SEND_SECURITY_PASSWD`). A `SET_PAYLOAD`
+     * (1350) envelope: `{cmd:1287, mChannel:<deviceCh>, mValue3:0, payload:{mode, passwd, username}}`.
+     *
+     * ✅ Byte-exact against the app's own frame (confirmed 2026-08-03 on a T8425 behind a T8030): the app
+     * auto-generates BOTH a username and a password (16 chars each — its "13 char" UI rule is
+     * frontend-only; the firmware accepts any length). The app maps `mode` as `0` = open, `1` = Basic,
+     * `2` = Digest and offers Basic/Digest but no "open" option. A standalone T8442 was observed serving
+     * a Digest challenge. A HomeBase-attached T8210 echoed freshly supplied Basic credentials in its URL,
+     * confirming storage, while unauthenticated `DESCRIBE` remained 200 with no challenge.
+     */
+    readonly SEND_SECURITY_PASSWD: 1287;
+    /**
+     * What the NAS records (app `NAS_VIDEO_TYPE_EVENT`): events only or continuously. The readable half
+     * of the app's two-frame recording-mode pair (6050 + 6010). ✅ Write verified live on a T8030 by
+     * param readback (0 → 1 → 0).
+     */
+    readonly VIDEO_TYPE_EVENT: 6050;
+    /** Second frame of the recording-mode pair — see {@link VIDEO_TYPE_EVENT}. Sent with it, never alone. */
+    readonly VIDEO_TYPE_CONTINUE: 6010;
+};
+/**
+ * The RTSP authentication scheme a caller can require. Maps to the credential write's `mode` field.
+ *
+ * - `"digest"` — request a hashed nonce challenge, observed on a standalone camera. The reader does
+ *   not send the plaintext password during RTSP authentication, though configuration still sends it
+ *   to the device. The safer choice, and the app's default.
+ * - `"basic"` — request Basic authentication, where the reader sends the password base64-encoded on
+ *   every request (encoding, not encryption). Offered for players that only speak Basic.
+ */
+export type RtspAuthScheme = "digest" | "basic";
+/**
+ * What the NAS records. `Events` stores clips around a detection; `Continuous` records without
+ * stopping.
+ */
+export declare const RtspRecordingMode: {
+    /** Record only around detections. */
+    readonly Events: 0;
+    /** Record continuously. */
+    readonly Continuous: 1;
+};
+/** A NAS recording mode — the value side of {@link RtspRecordingMode}. */
+export type RtspRecordingModeValue = (typeof RtspRecordingMode)[keyof typeof RtspRecordingMode];
+/**
+ * Bound RTSP controls — the object returned by `dev.rtsp()`.
+ *
+ * This is the vendor's NAS/RTSP feature: publish a camera's stream so a NAS/NVR (or the HomeBase
+ * itself) can record it. Two things a caller must know, because neither is expressible in the wire:
+ *
+ * - **A station publishes for ONE attached camera at a time.** Enabling a second withdraws the first,
+ *   silently — the station tracks a single camera, not a set. The SDK cannot detect or prevent this;
+ *   a caller driving several cameras owns the arbitration.
+ * - **Publication is a persistent device setting, not an SDK-owned media session.** An RTSP consumer
+ *   connects directly to the serving device; the SDK does not observe consumer disconnects and does
+ *   not withdraw in response. The caller that publishes owns calling `withdraw()` when its recorder is
+ *   done. The SDK deliberately applies no live-media power budget: on a device with the `battery`
+ *   capability, leaving RTSP published will drain the cell, so the feature suits mains-powered cameras
+ *   feeding a recorder.
+ *
+ * The stream itself is served over plain RTSP on the local network, by the station for a
+ * HomeBase-attached camera or by the camera itself when standalone. A standalone camera has been
+ * observed serving a Digest challenge. A tested HomeBase-attached camera echoed freshly supplied Basic
+ * credentials in its URL but stayed open without them. Verify storage from the device-reported URL
+ * and the served effect on each endpoint with an RTSP `DESCRIBE`: 401 = challenged, 200 = open.
+ */
+export type RtspActions = Surface<typeof RTSP_MEMBERS>;
+/**
+ * Every `rtsp` feature, declared once.
+ *
+ * `setRecordingMode` is a `method`, not a derived setter, because ONE UI change is TWO frames on
+ * the wire — the app sends 6050 then 6010, and sending only the first leaves the continuous recorder out
+ * of step with the advertised type. A member's `write` returns a single command, so the pair cannot be
+ * expressed as one.
+ *
+ * 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 RTSP_MEMBERS: {
+    /**
+     * This is DEVICE STATE — "whether the stream is published over RTSP" — not a record of who turned it
+     * on. So it reads true from more than a caller's own `publish()`: {@link RTSP.decodeState} sets it from
+     * the station's URL push (which proves the stream is up) and the cloud poll reports it too. A caller
+     * that needs "did *I* turn it on" tracks its own `publish()` call rather than reading this back.
+     *
+     * `provenance` is name-trust: the name is the app's own typo'd constant (`NAS_STREAM_SWITHC`), so it
+     * is "apk". The verified live WRITE — both directions, HomeBase and standalone — is in the description.
+     */
+    readonly published: {
+        readonly param: 1145;
+        readonly property: "rtspStream";
+        readonly type: "bool";
+        readonly kind: "boolean";
+        readonly provenance: "apk";
+        readonly description: string;
+        readonly write: (v: string | number | boolean, ctx: CommandContext) => Command;
+        readonly aliases: {
+            readonly publish: true;
+            readonly withdraw: false;
+        };
+    };
+    /**
+     * The device-reported RTSP URL — the full `rtsp://user:pass@host/path`, carrying the credentials the
+     * device enforces RIGHT NOW. This is the only source of the freshly-generated pair: the credentials
+     * regenerate on every publish toggle and the cloud record lags a cycle, so an assembled URL or an
+     * imposed one would not match what the device is enforcing.
+     *
+     * The flat property name is `rtspUrl`, not `url`: property names are a FLAT namespace shared across
+     * every capability (`getProperty`/`setProperty`/`propertyChanged` key on the bare string), so the
+     * generic `url` would claim that word SDK-wide. The fluent read stays `dev.rtsp()?.url` — the member
+     * key qualifies it there.
+     *
+     * The FRAME SHAPE — 1145 returning as a NUL-terminated `rtsp://user:pass@host/path` string — was
+     * OBSERVED live, so `decodeState` is grounded. The station pushes it only once the stream is asked to
+     * start, not from the publish switch alone (field-confirmed).
+     *
+     * To FETCH the URL, the canonical call is `EufyMega.reportedRtspUrl(sn)` — it provokes and returns it.
+     * This member is NOT a second fetch path: it surfaces whatever the station last pushed as inbound
+     * state, for code that already holds a `dev.rtsp()` and reacts to `propertyChanged` (a getter that is
+     * simply absent until a push has landed), rather than driving the read itself.
+     *
+     * `provenance` below is `verified` for the VALUE and its frame — not for the id: {@link STREAM_URL}
+     * is synthetic and the wire never reports it, so no capture could have "verified" the id itself.
+     *
+     * Arrives ONLY over the P2P notify wire and never in the cloud record, so it is absent until a push
+     * lands and then reads back like any other state. Read-only: the device reports it, a caller does not
+     * set it. Lifted from the frame by {@link RTSP.decodeState}.
+     */
+    readonly url: {
+        readonly param: 11450;
+        readonly property: "rtspUrl";
+        readonly type: "string";
+        readonly kind: "text";
+        readonly provenance: "verified";
+        readonly description: string;
+    };
+    /**
+     * The READ half of a control written by `setRecordingMode` below, hence `writtenElsewhere` — one UI
+     * change is TWO frames on the wire (6050 then 6010) and a member's `write` returns a single command,
+     * so the pair cannot be a derived setter. 6050 is the half the device reports back, which is why the
+     * member hangs off that id and not its silent partner.
+     */
+    readonly recordingMode: {
+        readonly param: 6050;
+        readonly type: "enum";
+        readonly kind: "enum";
+        readonly enumValues: Record<number, string>;
+        readonly provenance: "apk";
+        readonly writtenElsewhere: true;
+        readonly description: string;
+    };
+    /** Persistently publish this camera's stream. The enabling caller owns withdrawing it when done. */
+    readonly publish: import("./members.js").MethodMember<() => Promise<void>>;
+    /** Withdraw this camera's persistent publication; consumer retries do not ask the SDK to republish it. */
+    readonly withdraw: import("./members.js").MethodMember<() => Promise<void>>;
+    /**
+     * Store credentials and request authentication on this camera's stream. Served enforcement is
+     * topology-dependent and must be verified with `DESCRIBE` (401 = challenged, 200 = open).
+     *
+     * `scheme` defaults to `"digest"` (a hashed nonce challenge and the app's own default). The reader
+     * does not send the plaintext password during Digest authentication, though this configuration write
+     * still sends it to the device. Pass `"basic"` only for a player that can't do Digest: Basic sends
+     * the password base64-encoded on every request, readable by anyone on the LAN.
+     *
+     * The write stores credentials on both topologies, but a tested HomeBase-attached endpoint did not
+     * enforce the requested mode. Verify storage from the device-reported URL, which embeds the
+     * credentials, and enforcement with a `DESCRIBE` (401 = challenged, 200 = open).
+     */
+    readonly requireAuth: import("./members.js").MethodMember<(username: string, password: string, scheme?: RtspAuthScheme) => Promise<void>>;
+    /** Store an anonymous-mode request while keeping the supplied credentials. */
+    readonly allowAnonymous: import("./members.js").MethodMember<(username: string, password: string) => Promise<void>>;
+    /**
+     * Set what the NAS records — events only, or continuously. Sends the app's two-frame pair in one call.
+     * Present only when this camera reports the recording-mode state, mirroring the publish switch's own
+     * evidence gate.
+     *
+     * On a battery-powered camera, `Continuous` keeps the stream up and will flatten the battery far
+     * faster than event recording — the app only offers it for wired/HomeBase-attached cameras.
+     */
+    readonly setRecordingMode: import("./members.js").MethodMember<(mode: RtspRecordingModeValue | number) => Promise<void>> & {
+        available: (ctx: CommandContext) => boolean;
+    };
+};
+/**
+ * `rtsp` — publish a camera's stream over RTSP for a NAS/NVR to record.
+ *
+ * Detection is evidence-only: a device advertises param 1145 or it does not get the accessor. The
+ * vendor app gates the setting to a subset of models, but that gate is CLIENT-side — a model whose app
+ * never shows the toggle still accepts the write, which is why detection keys off the reported param
+ * rather than a model table.
+ */
+export declare const RTSP: CapabilityModule;