@apocaliss92/nodelink-js 0.4.10 → 0.4.12

package/dist/index.d.ts

@@ -180,15 +180,27 @@ export declare type AiTypesCacheEntry = {
 export declare type AnyBuffer = Buffer<ArrayBufferLike>;
 
 /**
- * Patch one or more fields inside an `<Enc>` stream block
- * (`<mainStream>` or `<subStream>`). Used by `setEnc` —
- * Reolink emits both blocks in the same document so a per-block scope
- * is needed to avoid clobbering the wrong stream.
- */
-export declare function applyStreamPatch(xml: string, streamTag: "mainStream" | "subStream", patch: {
+ * Patch fields inside a `<Compression>` stream block (`<mainStream>`,
+ * `<subStream>`, or `<thirdStream>`). Used by `setEnc` — Reolink emits all
+ * three blocks in the same document so a per-block scope is needed to avoid
+ * clobbering the wrong stream.
+ *
+ * The mapping `videoEncType` ↔ codec uses the convention seen on the wire:
+ *   0 = H.264
+ *   1 = H.265
+ * Both `<frame>` (camera-side preferred) and `<frameRate>` (older reolink_aio
+ * naming) are patched defensively — no-op if only one is present.
+ */
+export declare function applyStreamPatch(xml: string, streamTag: "mainStream" | "subStream" | "thirdStream", patch: {
+    audio?: 0 | 1;
+    width?: number;
+    height?: number;
     bitRate?: number;
     frameRate?: number;
     videoEncType?: "h264" | "h265";
+    encoderType?: "vbr" | "cbr";
+    encoderProfile?: "high" | "main" | "baseline";
+    gop?: number;
 } | undefined): string;
 
 /**
@@ -464,6 +476,23 @@ export declare class BaichuanClient extends EventEmitter<{
      *   even if the current client instance is idle/disconnected.
      */
     private static readonly streamingRegistry;
+    /**
+     * Per-device set of live BaichuanClient instances.
+     *
+     * Why: when a streaming client unsubscribes (e.g. RTSP grace timer expires
+     * and SocketPool tears the streaming socket down), the global streaming
+     * registry decrements but the GENERAL client of the same device has no
+     * way of knowing — its idle-disconnect timer was last evaluated while
+     * `isDeviceStreamingActive()` was still true (because the streaming socket
+     * was still alive) and wasn't rescheduled. Without this registry the
+     * general socket stays connected, the 60-second session-guard timer keeps
+     * sending getOnlineUserList() to the camera, and a battery camera ends up
+     * waking up every minute (issue #18).
+     *
+     * On streamingRegistry decrement-to-zero we walk this set and kick every
+     * sibling's idle-disconnect timer so it can re-evaluate eligibility.
+     */
+    private static readonly deviceClients;
     /**
      * Per-host D2C_DISC backoff state that persists across client instance recreation.
      *
@@ -552,6 +581,10 @@ export declare class BaichuanClient extends EventEmitter<{
     private streamTraceStats;
     private rxCmdTraceStats;
     private readonly alarmEventState;
+    /** Whether this instance is currently in BaichuanClient.deviceClients. */
+    private registeredInDeviceClients;
+    private registerInDeviceClients;
+    private unregisterFromDeviceClients;
     constructor(options: BaichuanClientOptions);
     private newSocketSessionId;
     private logFixed;
@@ -1701,6 +1734,50 @@ export declare type BaichuanStreamInfoList = {
 
 export declare type BaichuanTransport = "tcp" | "udp";
 
+/**
+ * Snapshot of `<VersionInfo>` returned by Baichuan cmd_id=80
+ * (`BC_CMD_ID_GET_VERSION_INFO`) — the same payload the Reolink mobile app
+ * displays in "About this device". Distinct from `getSystemGeneral`
+ * (cmd_104) which holds time/locale.
+ *
+ * All fields optional because firmware variants and models include
+ * different subsets. Empty XML elements (e.g. `<cc3200Version></cc3200Version>`)
+ * come through as the empty string so callers can distinguish "absent"
+ * (undefined) from "explicitly empty" ("").
+ */
+export declare interface BaichuanVersionInfo {
+    /** User-assigned name (matches the OSD camera name). */
+    name?: string;
+    /** Model code, e.g. `"E1 Zoom"`, `"RLC-810A"`. */
+    type?: string;
+    /** Hardware serial number. */
+    serialNumber?: string;
+    /** Build identifier, typically a date string like `"build 2503281992"`. */
+    buildDay?: string;
+    /** Internal hardware revision, e.g. `"IPC_NT14NA48MPSD6"`. */
+    hardwareVersion?: string;
+    /** Config-format version Reolink uses to identify the schema the device speaks. */
+    cfgVersion?: string;
+    /** Firmware version, e.g. `"v3.2.0.4741_2503281992"`. */
+    firmwareVersion?: string;
+    /** Extended hardware detail (often hardwareVersion + region/sku suffix). */
+    detail?: string;
+    /** IE-Client identifier (legacy plug-in tag, usually `"IEClient"`). */
+    IEClient?: string;
+    /** Legacy MCU firmware version (present on some Reolink wireless models). */
+    cc3200Version?: string;
+    /** Signal-processor firmware version (rarely populated). */
+    spVersion?: string;
+    /** File extension Reolink expects for firmware updates (`"pak"`). */
+    pakSuffix?: string;
+    /** Reolink item / SKU number, e.g. `"E340"`. */
+    itemNo?: string;
+    /** AI-model bundle version (the on-device people/vehicle/animal detector). */
+    aiVersion?: string;
+    /** Diagnostic helper string the app sends to support, e.g. `"blackPointsLevel=0"`. */
+    helpVersion?: string;
+}
+
 export declare type BaichuanVideoInputPush = {
     channelId?: number;
     bright?: number;
@@ -1737,6 +1814,22 @@ export declare class BaichuanVideoStream extends EventEmitter<{
         time?: number;
     }
     ];
+    /**
+     * Raw BcMedia `additionalHeader` block emitted for every I-frame and P-frame.
+     * Carries Reolink's per-frame side-channel metadata (detection bounding boxes).
+     * `frameWidth`/`frameHeight` come from the most recent BcMedia InfoV1/V2 packet
+     * so consumers can normalize pixel coordinates against the actual stream size.
+     */
+    additionalHeader: [
+        {
+        raw: Buffer;
+        frameType: "Iframe" | "Pframe";
+        videoType: "H264" | "H265";
+        microseconds: number;
+        frameWidth?: number;
+        frameHeight?: number;
+    }
+    ];
     audioFrame: [Buffer];
     error: [Error];
     close: [];
@@ -1755,6 +1848,13 @@ export declare class BaichuanVideoStream extends EventEmitter<{
     private readonly acceptAnyStreamType;
     private lockedChannelId;
     private bcMediaCodec;
+    /**
+     * Diagnostic-only accessor for the BcMedia codec. Used by tools that need to
+     * inspect unknown chunks (for example to discover undocumented audio
+     * sub-packets the parser currently skips). Not part of the supported public
+     * surface — do not rely on it in application code.
+     */
+    get _bcMediaCodec(): BcMediaCodec;
     private debugH264LogsLeft;
     private debugSavedSamples;
     private warnedNonAnnexBOnce;
@@ -1773,6 +1873,9 @@ export declare class BaichuanVideoStream extends EventEmitter<{
     private lastPpsH265;
     private lastPrependedParamSetsH265;
     private aesStreamDecryptor;
+    private latestFrameWidth;
+    private latestFrameHeight;
+    private detectionTeardown;
     /**
      * Pending startup error stashed when emitSafeError is called before any
      * "error" listener is registered (e.g. camera returns 400 during start()).
@@ -1902,6 +2005,14 @@ export declare class BaichuanWebRTCServer extends EventEmitter {
      * H.265 → DataChannel with raw Annex-B frames (decoded by WebCodecs in browser)
      */
     private pumpFramesToWebRTC;
+    /**
+     * Lazily start the AAC → Opus transcoder for `session` and wire it to the
+     * audio RTP track. ffmpeg writes RTP-formatted Opus packets back to a UDP
+     * loopback the transcoder owns; we strip the RTP header and rewrap the
+     * Opus payload with our audioTrack's SSRC so the browser receives a
+     * coherent stream.
+     */
+    private ensureAudioTranscoder;
     /**
      * Send H.264 frame via RTP media track
      * Returns the number of RTP packets sent
@@ -1960,6 +2071,12 @@ export declare interface BaichuanWebRTCServerOptions {
     iceAdditionalHostAddresses?: string[];
     /** Force relay-only (TURN) if needed */
     iceTransportPolicy?: "all" | "relay";
+    /**
+     * Path to ffmpeg used for AAC → Opus audio transcoding. Defaults to
+     * "ffmpeg" on PATH. Pass an empty string to disable audio (the audio track
+     * will still appear in the SDP for SDP-stability, but stay silent).
+     */
+    ffmpegPath?: string;
     /** Logger callback */
     logger?: (level: "debug" | "info" | "warn" | "error", message: string) => void;
 }
@@ -2155,6 +2272,8 @@ export declare const BC_CMD_ID_GET_SYSTEM_GENERAL = 104;
 
 export declare const BC_CMD_ID_GET_TIMELAPSE_CFG = 319;
 
+export declare const BC_CMD_ID_GET_VERSION_INFO = 80;
+
 export declare const BC_CMD_ID_GET_VIDEO_INPUT = 26;
 
 export declare const BC_CMD_ID_GET_WHITE_LED = 289;
@@ -2222,6 +2341,8 @@ export declare const BC_CMD_ID_SET_LED_STATE = 209;
 
 export declare const BC_CMD_ID_SET_MOTION_ALARM = 47;
 
+export declare const BC_CMD_ID_SET_OSD_DATETIME = 45;
+
 export declare const BC_CMD_ID_SET_PIR_INFO = 213;
 
 export declare const BC_CMD_ID_SET_PRIVACY_MASK = 53;
@@ -2373,7 +2494,10 @@ export declare class BcMediaCodec {
     private strict;
     private amountSkipped;
     private logger;
+    private onUnknownChunk;
     constructor(strict?: boolean, logger?: Logger);
+    /** Register a listener that fires for every unknown chunk before recovery. */
+    setUnknownChunkListener(listener: UnknownChunkListener | undefined): void;
     /**
      * Push data into the codec buffer and try to parse complete BcMedia packets.
      * Returns an array of complete BcMedia packets found.
@@ -4046,6 +4170,23 @@ export declare function decodeHeader(buf: AnyBuffer): {
     messageKey: number;
 };
 
+/**
+ * Decode the base64 `valueTable` from a `<scope>` (or `<area>`) into a flat
+ * boolean grid. Bytes are packed MSB-first: bit 7 of byte 0 is cell (0,0).
+ *
+ * The camera ships TWO pairs of dimensions: `<scope><columns>×<rows>`
+ * (bitmap size — typically 96×64) and `<width>×<height>` in the parent
+ * block (the effective motion grid — typically smaller, e.g. 60×33 on
+ * E1 Zoom). The user-editable region matches `width × height`, not the
+ * full bitmap; bits past that are camera-side padding that stays 0.
+ *
+ * When `width`/`height` are omitted we treat the whole bitmap as the
+ * active region (back-compat).
+ *
+ * Throws if the base64 contains too few bytes for `columns*rows` bits.
+ */
+export declare function decodeMotionScopeBitmap(valueTable: string, columns: number, rows: number, width?: number, height?: number): MotionZoneScope;
+
 /**
  * AES key derivation used by Reolink:
  * keyString = md5_str_modern(`${nonce}-${password}`).slice(0,16)
@@ -4463,6 +4604,49 @@ export declare function encodeHeader(h: Omit<BaichuanHeader, "magic"> & {
     magic?: AnyBuffer;
 }): AnyBuffer;
 
+/**
+ * Encode a `width × height` boolean grid back into the camera's
+ * `columns × rows` `valueTable`. Bits outside the active region stay 0,
+ * matching what the camera ships on the way down.
+ *
+ * `scope.cells.length` must equal `scope.width * scope.height`.
+ */
+export declare function encodeMotionScopeBitmap(scope: MotionZoneScope): string;
+
+/**
+ * Reply from `getEncOptions` — the set of allowable values for `setEnc`,
+ * derived from `getStreamInfoList`. Use this to validate user input or
+ * populate UI selectors.
+ */
+export declare interface EncOptions {
+    channel: number;
+    mainStream?: EncStreamOptions;
+    subStream?: EncStreamOptions;
+    thirdStream?: EncStreamOptions;
+}
+
+/**
+ * One allowable resolution from a `getEncOptions` reply.
+ * `videoEncTypeList` enumerates the codecs supported at this resolution
+ * (mapped to `"h264"`/`"h265"`).
+ */
+export declare interface EncResolutionOption {
+    width: number;
+    height: number;
+    /** Codecs available at this resolution. */
+    videoEncTypes: Array<"h264" | "h265">;
+    /** Camera-default framerate at this resolution, if reported. */
+    defaultFramerate?: number;
+    /** Camera-default bitrate (kbps) at this resolution, if reported. */
+    defaultBitrate?: number;
+    /** Camera-default GOP at this resolution, if reported. */
+    defaultGop?: number;
+    /** Allowed framerate values. */
+    framerateOptions: number[];
+    /** Allowed bitrate values (kbps). */
+    bitrateOptions: number[];
+}
+
 export declare type EncryptionProtocol = {
     kind: "none";
 } | {
@@ -4475,6 +4659,40 @@ export declare type EncryptionProtocol = {
     key: Buffer;
 };
 
+/**
+ * Allowable values for a single stream profile (mainStream / subStream / thirdStream).
+ * Aggregated from `getStreamInfoList` (cmd_146) so consumers can populate UI
+ * pickers without re-implementing the parsing logic.
+ */
+export declare interface EncStreamOptions {
+    /** Stream profile (one of `mainStream` / `subStream` / `thirdStream`). */
+    type: string;
+    /** Each entry is a `{width, height}` paired with its allowed values. */
+    resolutions: EncResolutionOption[];
+    /** Encoder rate-control modes Reolink exposes in the app. */
+    encoderTypes: Array<"vbr" | "cbr">;
+    /** Encoder profiles Reolink exposes in the app. */
+    encoderProfiles: Array<"high" | "main" | "baseline">;
+}
+
+/**
+ * Patch payload accepted by `setEnc` for a single stream block
+ * (`mainStream` / `subStream` / `thirdStream`). All fields optional —
+ * unspecified ones are preserved from the device's current config.
+ */
+export declare interface EncStreamPatch {
+    audio?: 0 | 1;
+    width?: number;
+    height?: number;
+    bitRate?: number;
+    frameRate?: number;
+    videoEncType?: "h264" | "h265";
+    encoderType?: "vbr" | "cbr";
+    encoderProfile?: "high" | "main" | "baseline";
+    /** Keyframe interval in seconds — patches `<gop><cur>`. */
+    gop?: number;
+}
+
 /**
  * Prepend the XML declaration if the body doesn't already start with
  * one. Reolink rejects payloads without it on most setX commands.
@@ -4585,6 +4803,13 @@ export declare interface FtpTaskConfig {
     };
 }
 
+/**
+ * Convenience: build an "everything enabled" grid of the given dimensions.
+ * Useful when the camera response has no `<valueTable>` and we want to
+ * start the user off with a clean slate.
+ */
+export declare function fullCoverageScope(columns: number, rows: number, width?: number, height?: number): MotionZoneScope;
+
 /**
  * Get constructed video stream options for all available profiles.
  *
@@ -4733,6 +4958,9 @@ export declare class Go2rtcTcpServer extends EventEmitter<{
     private resolvedPort;
     private nativeFanout;
     private nativeStreamActive;
+    private nativeStreamStopping;
+    private nativeStreamRetryTimer;
+    private nativeStreamRetryDelayMs;
     private dedicatedSessionRelease;
     private detectedVideoType;
     private connectedClients;
@@ -4794,6 +5022,21 @@ export declare class Go2rtcTcpServer extends EventEmitter<{
      * Returns null when the buffer is not a valid ADTS frame.
      */
     private static parseAdtsSamplingInfo;
+    /**
+     * Schedule another startNativeStream() attempt after the given delay.
+     * Idempotent: a no-op if a retry is already scheduled, the server is no
+     * longer active, or an explicit stop is in progress. Implements unbounded
+     * exponential backoff (5s → 60s) so a camera that stays unreachable for
+     * minutes (e.g. nightly maintenance reboot) eventually recovers without
+     * manual intervention — see issue #16.
+     */
+    private scheduleNativeStreamRetry;
+    /**
+     * Cancel any pending retry timer and reset the backoff. Called on explicit
+     * stop and on first-frame-received so the next failure starts the backoff
+     * window from scratch.
+     */
+    private clearNativeStreamRetry;
     private startNativeStream;
     private stopNativeStream;
     private startStreamHealthMonitor;
@@ -5463,6 +5706,37 @@ export declare interface MotionEvent {
     source?: "md" | "pir" | "unknown";
 }
 
+/**
+ * Motion-detection zone grid helpers.
+ *
+ * Reolink's GetMdAlarm response (cmd_id=46) carries the active detection
+ * region as a base64-encoded bitmap inside `<scope><valueTable>...</valueTable></scope>`.
+ * The bitmap has one bit per grid cell:
+ *
+ *   <scope>
+ *     <columns>96</columns>
+ *     <rows>64</rows>
+ *     <valueTable>{base64 of columns*rows bits, packed MSB-first per byte}</valueTable>
+ *   </scope>
+ *
+ * The same shape is reused by AI detection (`<AiDetectCfg><area>...</area>`)
+ * — only the column/row counts differ across firmwares. Use the helpers
+ * here to round-trip between the camera's base64 string and a flat boolean
+ * grid the UI can render and edit.
+ */
+export declare interface MotionZoneScope {
+    /** Active region width (effective grid columns, `<width>` in MD). */
+    width: number;
+    /** Active region height (effective grid rows, `<height>` in MD). */
+    height: number;
+    /** Bitmap columns reported by `<scope><columns>`. */
+    columns: number;
+    /** Bitmap rows reported by `<scope><rows>`. */
+    rows: number;
+    /** Flat `width × height` array, row-major. `true` = cell included. */
+    cells: boolean[];
+}
+
 /**
  * Stateful MPEG-TS muxer.  Each instance has its own continuity counters —
  * create one per output stream (or per client connection for prebuffer replay).
@@ -5996,6 +6270,12 @@ export declare class ReolinkBaichuanApi {
     private sessionGuardIntervalTimer;
     private readonly simpleEventListeners;
     private simpleEventSubscribed;
+    private readonly detectionEventListeners;
+    private readonly detectionEventStreamHooks;
+    private readonly objectDetectionListeners;
+    private objectDetectionStream;
+    private objectDetectionStreamStartInFlight;
+    private objectDetectionInternalListener;
     private simpleEventSubscribeInFlight;
     private simpleEventUnsubscribeInFlight;
     private simpleEventResubscribeTimer;
@@ -6413,6 +6693,73 @@ export declare class ReolinkBaichuanApi {
      * When the last listener is removed, the API unsubscribes from Baichuan events.
      */
     offSimpleEvent(callback?: (event: ReolinkSimpleEvent) => void | Promise<void>): Promise<void>;
+    /**
+     * Subscribe to per-frame detection events sourced from the BcMedia
+     * `additionalHeader` block on active video streams.
+     *
+     * Mirrors {@link onSimpleEvent} but is fed by the streaming side-channel:
+     * one event fires for every I-frame / P-frame that carries an overlay block.
+     * Coordinates are reported in normalized [0, 1] fractions of the source
+     * frame, so the same box renders correctly on mainStream, subStream, and
+     * externStream.
+     *
+     * Unlike `onSimpleEvent`, no Baichuan subscribe command is involved — events
+     * only flow while a video stream is open. The library hooks every
+     * `BaichuanVideoStream` created via this API for the listener's lifetime.
+     */
+    onDetection(callback: (event: ReolinkDetectionEvent) => void | Promise<void>): void;
+    /**
+     * Remove a single detection callback, or all of them if `callback` is omitted.
+     */
+    offDetection(callback?: (event: ReolinkDetectionEvent) => void | Promise<void>): void;
+    /**
+     * Subscribe to AI object detections (people / vehicle / animal / face boxes
+     * with class label and confidence) without managing a video stream yourself.
+     *
+     * Mirrors {@link onSimpleEvent} end-to-end: the API opens a dedicated
+     * substream behind the scenes on the first listener, forwards every box-bearing
+     * `additionalHeader` to your callback, and tears the stream down when the last
+     * listener unsubscribes. The substream is the lightest profile (typically
+     * 640×360) so the additional bandwidth/CPU overhead is minimal.
+     *
+     * Each event carries normalized `[0, 1]` box coordinates, a class label, and
+     * a confidence score — render-ready without further conversion.
+     */
+    onObjectDetections(callback: (event: ReolinkDetectionEvent) => void | Promise<void>): Promise<void>;
+    /**
+     * Remove one detection callback, or all of them if `callback` is omitted.
+     * When the last listener is removed the auto-managed substream is closed.
+     */
+    offObjectDetections(callback?: (event: ReolinkDetectionEvent) => void | Promise<void>): Promise<void>;
+    private ensureObjectDetectionStream;
+    private tearDownObjectDetectionStream;
+    /**
+     * Internal: invoked by BaichuanVideoStream when it starts so the API can hook
+     * its `additionalHeader` event. Returns a teardown function the stream calls
+     * on stop. Not intended for direct use by consumers.
+     */
+    _registerVideoStreamForDetection(stream: {
+        on: (event: "additionalHeader", listener: (info: {
+            raw: Buffer;
+            frameType: "Iframe" | "Pframe";
+            videoType: "H264" | "H265";
+            microseconds: number;
+            frameWidth?: number;
+            frameHeight?: number;
+        }) => void) => void;
+        off: (event: "additionalHeader", listener: (info: {
+            raw: Buffer;
+            frameType: "Iframe" | "Pframe";
+            videoType: "H264" | "H265";
+            microseconds: number;
+            frameWidth?: number;
+            frameHeight?: number;
+        }) => void) => void;
+    }, context: {
+        channel: number;
+        profile: "main" | "sub" | "ext";
+    }): () => void;
+    private dispatchDetectionEvent;
     private startSimpleEventResubscribeTimer;
     private stopSimpleEventResubscribeTimer;
     /**
@@ -6568,6 +6915,55 @@ export declare class ReolinkBaichuanApi {
         port: "rtsp" | "rtmp" | "onvif" | "http" | "https";
         enable: boolean;
     }): Promise<void>;
+    /**
+     * Full port-config setter (cmd_id 36). Patches one or more of the six
+     * service ports the camera serves — Server (Baichuan), HTTP, HTTPS,
+     * RTSP, RTMP, ONVIF. Each entry takes an optional `port` (number) and
+     * `enable` (boolean); fields the caller doesn't pass are left alone.
+     *
+     * Sends one block per port that has any field set, then issues a
+     * single cmd_36 with the merged body. The camera accepts multiple
+     * `<XxxPort>` siblings in the same payload.
+     *
+     * Wire format observed on E1 Zoom:
+     *
+     *   <body>
+     *     <RtspPort version="1.1">
+     *       <rtspPort>554</rtspPort>
+     *       <enable>1</enable>
+     *     </RtspPort>
+     *     <HttpsPort version="1.1">
+     *       <enable>0</enable>
+     *     </HttpsPort>
+     *     ...
+     *   </body>
+     */
+    setPortConfig(patch: {
+        server?: {
+            port?: number;
+            enable?: boolean;
+        };
+        http?: {
+            port?: number;
+            enable?: boolean;
+        };
+        https?: {
+            port?: number;
+            enable?: boolean;
+        };
+        rtsp?: {
+            port?: number;
+            enable?: boolean;
+        };
+        rtmp?: {
+            port?: number;
+            enable?: boolean;
+        };
+        onvif?: {
+            port?: number;
+            enable?: boolean;
+        };
+    }): Promise<void>;
     /** GetDevInfo via Baichuan: host cmd_id 80, channel cmd_id 318 */
     getInfo(channel?: number, options?: {
         timeoutMs?: number;
@@ -7358,6 +7754,15 @@ export declare class ReolinkBaichuanApi {
      */
     setPtzPreset(presetId: number, name: string, channel?: number): Promise<void>;
     setPtzPreset(channel: number, presetId: number, name: string): Promise<void>;
+    /**
+     * Recall (move to) a saved PTZ preset.
+     *
+     * cmd_id 19 (PTZ_CONTROL_PRESET) with command="toPos". The camera moves
+     * the head at its own default preset-recall speed; we don't expose
+     * speed here because most firmwares ignore the field on toPos.
+     */
+    gotoPtzPreset(presetId: number, channel?: number): Promise<void>;
+    gotoPtzPreset(channel: number, presetId: number): Promise<void>;
     /**
      * Best-effort delete/disable a PTZ preset.
      *
@@ -7532,6 +7937,39 @@ export declare class ReolinkBaichuanApi {
      */
     setMotionDetection(enabled: boolean, sensitivity?: number, channel?: number): Promise<void>;
     setMotionDetection(channel: number, enabled: boolean, sensitivity?: number): Promise<void>;
+    /**
+     * Set motion alarm with full control, including the detection-zone grid.
+     *
+     * Wire format observed on E1 Zoom (cmd_id=47 SetMdAlarm body):
+     *
+     *   <MD version="1.1">
+     *     <channelId>0</channelId>
+     *     <enable>1</enable>
+     *     <usepir>0</usepir>
+     *     <width>60</width> <height>33</height>
+     *     <scope>
+     *       <columns>96</columns> <rows>64</rows>
+     *       <valueTable>{base64 6144-bit bitmap}</valueTable>
+     *     </scope>
+     *     ... other camera-specific fields ...
+     *   </MD>
+     *
+     * We do a read-modify-write of the GET response so any camera-specific
+     * extension fields are preserved untouched. Pass `valueTable` to update
+     * the detection zone — see `encodeMotionScopeBitmap` for the bitmap layout.
+     *
+     * @param channel - 0-based channel
+     * @param enabled - toggle motion detection on/off (optional)
+     * @param sensitivity - 0-50, higher = more sensitive (optional)
+     * @param valueTable - base64-encoded grid bitmap; size must match
+     *   `<scope><columns>×<rows></scope>` from the GET (optional)
+     */
+    setMotionAlarmFull(opts: {
+        channel?: number;
+        enabled?: boolean;
+        sensitivity?: number;
+        valueTable?: string;
+    }): Promise<void>;
     /**
      * Set AI detection settings via Baichuan.
      * cmd_id: 343 (SetAiAlarm)
@@ -7822,25 +8260,30 @@ export declare class ReolinkBaichuanApi {
     }): Promise<EncConfig>;
     /**
      * SetEnc via Baichuan (cmdId=57). Read-modify-write — preserves
-     * unspecified fields. Mirrors reolink_aio's `SetEnc`.
+     * unspecified fields. Mirrors reolink_aio's `SetEnc` plus the additional
+     * `width`/`height`/`encoderType`/`encoderProfile`/`gop`/`thirdStream`
+     * fields observed in the official mobile app (see `pcap/resolution.pcapng`).
+     *
+     * Field meaning per stream:
+     *  - `audio`           — 0/1 toggle
+     *  - `width`/`height`  — resolution in pixels. Must be one of the
+     *                        resolutions returned by {@link getStreamInfoList}.
+     *  - `bitRate`         — kbps. Must match the table from `getStreamInfoList`.
+     *  - `frameRate`       — fps. Must match the table from `getStreamInfoList`.
+     *  - `videoEncType`    — `"h264"` or `"h265"`
+     *  - `encoderType`     — `"vbr"` or `"cbr"`
+     *  - `encoderProfile`  — `"high"`, `"main"`, or `"baseline"`
+     *  - `gop`             — keyframe interval in seconds (sets `<gop><cur>`)
      *
      * @param channel - Channel number (0-based)
-     * @param patch - Fields to update on `mainStream` and/or `subStream`,
-     *   plus a top-level `audio` toggle (0/1). Pass only what you want
-     *   to change.
+     * @param patch - Fields to update. Pass only the fields you want to change;
+     *   everything else is preserved from the device's current configuration.
      */
     setEnc(channel: number, patch: {
         audio?: 0 | 1;
-        mainStream?: {
-            bitRate?: number;
-            frameRate?: number;
-            videoEncType?: "h264" | "h265";
-        };
-        subStream?: {
-            bitRate?: number;
-            frameRate?: number;
-            videoEncType?: "h264" | "h265";
-        };
+        mainStream?: EncStreamPatch;
+        subStream?: EncStreamPatch;
+        thirdStream?: EncStreamPatch;
     }, options?: {
         timeoutMs?: number;
     }): Promise<void>;
@@ -8100,6 +8543,35 @@ export declare class ReolinkBaichuanApi {
     getCoordinatePointListFromPushCache(channel?: number): BaichuanCachedPush<BaichuanCoordinatePointListPush> | undefined;
     private isNvrLikeDevice;
     private sendPcapDerivedSettingsGetXml;
+    /**
+     * Update the OSD timestamp + channel-name overlay via cmd_id=45
+     * (SetOsdDatetime). The schema is the same `<body><OsdDatetime>` +
+     * `<OsdChannelName>` block returned by `getOsdDatetime` — we
+     * read-modify-write so any extension fields the camera sent are
+     * preserved.
+     *
+     * Position is in **camera pixel coordinates** (e.g. (1,1) for top-left,
+     * not preset strings). Set `enable=0` to hide the overlay; the camera
+     * keeps the stored position so re-enabling later restores it.
+     */
+    setOsdDatetime(channel: number, patch: {
+        datetime?: {
+            enable?: boolean | 0 | 1;
+            topLeftX?: number;
+            topLeftY?: number;
+            language?: string;
+        };
+        channelName?: {
+            name?: string;
+            enable?: boolean | 0 | 1;
+            topLeftX?: number;
+            topLeftY?: number;
+            enWatermark?: boolean | 0 | 1;
+            enBgcolor?: boolean | 0 | 1;
+        };
+    }, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
     getOsdDatetime(channel: number, options?: {
         timeoutMs?: number;
     }): Promise<BaichuanGetOsdDatetimeResult>;
@@ -8118,6 +8590,36 @@ export declare class ReolinkBaichuanApi {
     getStreamInfoList(channel: number, options?: {
         timeoutMs?: number;
     }): Promise<BaichuanStreamInfoList>;
+    /**
+     * Return the set of values `setEnc` will accept on each stream of `channel`.
+     * Aggregates `getStreamInfoList` (cmd_146) into a UI-friendly shape:
+     * per-stream resolutions with their allowed codecs/framerates/bitrates plus
+     * the enumerated encoder modes/profiles Reolink exposes.
+     *
+     * Useful for populating selectors and validating user input before calling
+     * `setEnc` — picking an unsupported combination causes the camera to reject
+     * the SET_ENC command (responseCode != 200).
+     */
+    getEncOptions(channel: number, options?: {
+        timeoutMs?: number;
+    }): Promise<EncOptions>;
+    /**
+     * Read the camera's `<VersionInfo>` block (cmd_id=80). Returns the
+     * friendly name, model code (e.g. `"E1 Zoom"`), serial number, firmware
+     * version, hardware revision, build day, AI model bundle version, etc.
+     *
+     * This is the same info the Reolink mobile app shows in "About this
+     * device" — distinct from `getSystemGeneral` (cmd_104) which carries
+     * time/locale.
+     *
+     * No channel parameter: this command is device-global on NVRs/Hubs and
+     * camera-global on standalone cameras. Pass an explicit channel via the
+     * underlying `sendXml` only if a specific firmware demands it (none we've
+     * tested do).
+     */
+    getVersionInfo(options?: {
+        timeoutMs?: number;
+    }): Promise<BaichuanVersionInfo>;
     getLedState(channel: number, options?: {
         timeoutMs?: number;
     }): Promise<BaichuanLedState>;
@@ -9353,6 +9855,64 @@ export declare interface ReolinkDayNightNotification {
     timestamp?: number;
 }
 
+/**
+ * A single detection bounding box in normalized [0, 1] coordinates relative to
+ * the source video frame. Using fractions instead of pixels keeps the same box
+ * valid across mainStream / subStream / externStream output and across firmware
+ * resolution changes.
+ */
+export declare interface ReolinkDetectionBox {
+    /** Left edge in [0, 1] (0 = left, 1 = right). */
+    x: number;
+    /** Top edge in [0, 1] (0 = top, 1 = bottom). */
+    y: number;
+    /** Width in [0, 1]. */
+    width: number;
+    /** Height in [0, 1]. */
+    height: number;
+    /** AI class label if the camera reports one (e.g. "person", "vehicle"). */
+    label?: string;
+    /** Confidence in [0, 1] if exposed by the camera. */
+    confidence?: number;
+}
+
+/**
+ * Diagnostic state describing how much of the BcMedia additionalHeader the
+ * decoder was able to interpret. Useful for consumers iterating on the format.
+ */
+export declare type ReolinkDetectionDecodeState = 
+/** Header marker was missing or malformed. */
+"invalid-marker"
+/** Baseline 128-byte header — camera reports no overlay metadata. */
+| "no-overlay"
+/** Overlay block present, but coordinates have not been decoded yet. */
+| "overlay-undecoded"
+/** Overlay block decoded successfully. */
+| "overlay-decoded";
+
+/**
+ * High-level "detection" event emitted alongside every video frame that carries
+ * a non-empty BcMedia additionalHeader. Mirrors `ReolinkSimpleEvent` but is
+ * sourced from the streaming side-channel rather than from cmd_id 33 push events.
+ */
+export declare interface ReolinkDetectionEvent {
+    channel: number;
+    /** Microseconds timestamp from the BcMedia video frame. */
+    microseconds: number;
+    /** Stream profile that produced the underlying frame. */
+    profile: "main" | "sub" | "ext";
+    /** Boxes in [0, 1] fractional coordinates. */
+    boxes: ReolinkDetectionBox[];
+    /** Source frame width (from BcMedia InfoV1/V2) if known. */
+    frameWidth?: number;
+    /** Source frame height (from BcMedia InfoV1/V2) if known. */
+    frameHeight?: number;
+    /** Decoder diagnostic state. */
+    decodeState: ReolinkDetectionDecodeState;
+    /** Raw additionalHeader bytes — kept for downstream decoder work. */
+    rawHeader: Buffer;
+}
+
 export declare interface ReolinkDeviceInfo {
     type?: string;
     hardwareVersion?: string;
@@ -10224,6 +10784,27 @@ export declare interface TwoWayAudioConfig {
     mode?: "mixAudioStream" | string;
 }
 
+/**
+ * Optional listener invoked whenever the codec encounters a 4-byte sequence
+ * at the buffer head that does NOT match any known BcMedia magic and is about
+ * to be skipped as "recovery". Use it to discover undocumented sub-packet
+ * shapes (e.g. AI overlay metadata) without altering the codec's behaviour.
+ */
+export declare type UnknownChunkListener = (info: {
+    magic: number;
+    /** Up to 256 bytes starting at the unknown chunk's first byte. */
+    preview: Buffer;
+    /** Number of bytes the codec is about to skip before resyncing. */
+    skipped: number;
+}) => void;
+
+/**
+ * Like {@link applyXmlTagPatch} but inserts the tag at the end of the block
+ * when it is not already present. Required for fields the camera omits on
+ * GET responses but expects on SET (e.g. `<encoderType>` on `setEnc`).
+ */
+export declare function upsertXmlTag(xml: string, tag: string, value: string | number | boolean | undefined): string;
+
 /**
  * Client information extracted from HTTP request headers.
  * Used to determine optimal video delivery format.