@apocaliss92/nodelink-js 0.4.7 → 0.4.10

package/dist/index.d.cts

@@ -116,9 +116,29 @@ declare const BC_CMD_ID_GET_AI_CFG = 299;
 declare const BC_CMD_ID_SET_AI_CFG = 300;
 declare const BC_CMD_ID_GET_SIREN_STATUS = 547;
 declare const BC_CMD_ID_SET_AUDIO_TASK = 231;
+declare const BC_CMD_ID_SET_VIDEO_INPUT = 25;
+declare const BC_CMD_ID_SET_DAY_NIGHT_THRESHOLD = 297;
+declare const BC_CMD_ID_GET_ENC = 56;
+declare const BC_CMD_ID_SET_ENC = 57;
+declare const BC_CMD_ID_GET_PRIVACY_MASK = 52;
+declare const BC_CMD_ID_SET_PRIVACY_MASK = 53;
+declare const BC_CMD_ID_SET_AI_DENOISE = 440;
+declare const BC_CMD_ID_SET_LED_STATE = 209;
+declare const BC_CMD_ID_SET_AUDIO_CFG = 265;
+declare const BC_CMD_ID_SET_RECORD = 82;
+declare const BC_CMD_ID_SET_RECORD_CFG = 55;
+declare const BC_CMD_ID_SET_EMAIL_TASK = 216;
+declare const BC_CMD_ID_GET_PUSH_TASK = 219;
+declare const BC_CMD_ID_SET_PUSH_TASK = 218;
+declare const BC_CMD_ID_GET_AUTO_FOCUS = 224;
+declare const BC_CMD_ID_SET_AUTO_FOCUS = 225;
+/** @deprecated Use {@link BC_CMD_ID_SET_LED_STATE} (209). */
 declare const BC_CMD_ID_CMD_123 = 123;
+/** @deprecated Use {@link BC_CMD_ID_SET_LED_STATE} (209). */
 declare const BC_CMD_ID_CMD_209 = 209;
+/** @deprecated Use {@link BC_CMD_ID_SET_AUDIO_CFG} (265). */
 declare const BC_CMD_ID_CMD_265 = 265;
+/** @deprecated Use {@link BC_CMD_ID_SET_AI_DENOISE} (440). */
 declare const BC_CMD_ID_CMD_440 = 440;
 declare const BC_CMD_ID_PUSH_VIDEO_INPUT = 78;
 declare const BC_CMD_ID_PUSH_SERIAL = 79;
@@ -380,6 +400,45 @@ declare function buildFloodlightManualXml(channelId: number, status: number, dur
  * In practice, many cameras expect FloodlightManual payload for cmd 288.
  */
 declare function buildWhiteLedStateXml(channelId: number, state: number): string;
+/**
+ * Prepend the XML declaration if the body doesn't already start with
+ * one. Reolink rejects payloads without it on most setX commands.
+ */
+declare function ensureXmlHeader(xml: string): string;
+/**
+ * Replace the text content of `<tag>...</tag>` (first match) with the
+ * stringified value. No-op when `value` is undefined — lets callers
+ * pass partial patches without branching at every field.
+ */
+declare function applyXmlTagPatch(xml: string, tag: string, value: string | number | boolean | undefined): string;
+/**
+ * Patch a child tag inside a named parent block. Used for nested
+ * structures like `<DayNight><mode>...</mode></DayNight>` where the
+ * same `<mode>` tag appears under multiple parents.
+ */
+declare function patchNestedTag(xml: string, parent: string, child: string, value: string | number | boolean | undefined): string;
+/**
+ * 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.
+ */
+declare function applyStreamPatch(xml: string, streamTag: "mainStream" | "subStream", patch: {
+    bitRate?: number;
+    frameRate?: number;
+    videoEncType?: "h264" | "h265";
+} | undefined): string;
+/**
+ * Normalize human-friendly day/night labels to the camera's expected
+ * lowercase form. Mirrors reolink_aio's `SetIsp` post-processing
+ * (`& → And`, capitalize first letter).
+ */
+declare function normalizeDayNightMode(input: string): string;
+/**
+ * Normalize "On"/"Off" / "open"/"close" / boolean-ish inputs to the
+ * `open`/`close` enum the camera expects on LED-control commands.
+ */
+declare function normalizeOpenClose(input: string): string;
 /**
  * Build AbilityInfo extension XML for requesting device capabilities.
  * Requests all available tokens: "system, streaming, PTZ, IO, security, replay, disk, network, alarm, record, video, image"
@@ -682,6 +741,17 @@ interface PirState {
     state?: {
         enable?: number;
         channel?: number;
+        /** PIR sensitivity (typically 1..100). Camera-side field is
+         *  `sensiValue` in the cmd_id 212 response. */
+        sensitive?: number;
+        /** False-positive reduction toggle (`reduceFalseAlarm` on the
+         *  wire). 0/1. */
+        reduceAlarm?: number;
+        /** Cooldown between consecutive PIR triggers (seconds). */
+        interval?: number;
+        /** Firmware-advertised max value for `interval`. Drives the
+         *  upper bound of operator-facing sliders. */
+        intervalMax?: number;
         [key: string]: unknown;
     };
 }
@@ -1606,6 +1676,209 @@ interface AiAlarmConfig {
         };
     };
 }
+/**
+ * Per-stream encoding entry inside `Compression`. Captured live on
+ * E1-Zoom (TCP), Doorbell (UDP), Hub channel-0 (Argus 3E).
+ *
+ * Note: the camera-side field name is `frame`, NOT `frameRate`.
+ * `videoEncType` is a numeric enum (`0` = h264, `1` = h265). The
+ * `gop`/`encoderType`/`separateCfg` sub-blocks are firmware-dependent
+ * (Hub-channel cameras carry them; standalone devices may not).
+ */
+interface CompressionStream {
+    audio?: number | undefined;
+    resolutionName?: string | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+    frame?: number | undefined;
+    bitRate?: number | undefined;
+    encoderProfile?: string | undefined;
+    videoEncType?: number | undefined;
+    gop?: {
+        cur?: number;
+        max?: number;
+        min?: number;
+    } | undefined;
+    encoderType?: string | undefined;
+    [key: string]: unknown;
+}
+/**
+ * Encoding configuration (getEnc response).
+ * cmdId=56 (GetEnc) — payload is wrapped in `Compression`, not `Enc`.
+ */
+interface EncConfig {
+    body?: {
+        Compression?: {
+            channelId?: number | undefined;
+            isNoTranslateFrame?: number | undefined;
+            mainStream?: CompressionStream | undefined;
+            subStream?: CompressionStream | undefined;
+            thirdStream?: CompressionStream | undefined;
+            separateCfg?: {
+                encodeCfg?: number;
+                [key: string]: unknown;
+            } | undefined;
+            [key: string]: unknown;
+        };
+    };
+}
+/**
+ * ISP / image input configuration. Both `getIsp` (cmdId=25) and
+ * `getImage` (cmdId=26) return identical payloads on observed firmwares
+ * — the underlying VideoInput + InputAdvanceCfg blocks. Different
+ * cmdIds preserved for backwards compatibility.
+ */
+interface IspConfig {
+    body?: {
+        VideoInput?: {
+            channelId?: number | undefined;
+            bright?: number | undefined;
+            contrast?: number | undefined;
+            saturation?: number | undefined;
+            hue?: number | undefined;
+            sharpen?: number | undefined;
+            corridorAbility?: number | undefined;
+            corridorMode?: string | undefined;
+            [key: string]: unknown;
+        };
+        InputAdvanceCfg?: {
+            channelId?: number | undefined;
+            digitalChannel?: number | undefined;
+            separateCfg?: {
+                encType?: number;
+                constantFrameRate?: number;
+                [key: string]: unknown;
+            } | undefined;
+            PowerLineFrequency?: {
+                mode?: string;
+                enable?: number;
+                [key: string]: unknown;
+            } | undefined;
+            Exposure?: {
+                mode?: string;
+                Gainctl?: {
+                    defMin?: number;
+                    defMax?: number;
+                    curMin?: number;
+                    curMax?: number;
+                };
+                Shutterctl?: {
+                    defMin?: number;
+                    defMax?: number;
+                    curMin?: number;
+                    curMax?: number;
+                };
+                shutterLevel?: string;
+                gainLevel?: number;
+                [key: string]: unknown;
+            } | undefined;
+            Scene?: {
+                mode?: string;
+                modeList?: string;
+                Redgain?: {
+                    min?: number;
+                    max?: number;
+                    cur?: number;
+                };
+                Bluegain?: {
+                    min?: number;
+                    max?: number;
+                    cur?: number;
+                };
+                [key: string]: unknown;
+            } | undefined;
+            DayNight?: {
+                mode?: string;
+                IrcutMode?: string;
+                Threshold?: string;
+                [key: string]: unknown;
+            } | undefined;
+            BLC?: {
+                enable?: number;
+                mode?: string;
+                [key: string]: unknown;
+            } | undefined;
+            [key: string]: unknown;
+        };
+    };
+}
+/**
+ * IR / supplemental light state (`getIrLights`). Captured live on every
+ * test camera — `state` is the operator-facing toggle, `lightState` is
+ * the camera's own runtime status. `doorbellLightState` /
+ * `doorbellAbility` only appear on doorbell models.
+ */
+interface IrLightsConfig {
+    body?: {
+        LedState?: {
+            channelId?: number | undefined;
+            ledVersion?: number | undefined;
+            IRLedBrightness?: number | undefined;
+            state?: string | undefined;
+            lightState?: string | undefined;
+            doorbellLightState?: string | undefined;
+            doorbellAbility?: number | undefined;
+            [key: string]: unknown;
+        };
+    };
+}
+/**
+ * Privacy mask configuration (`getMask`). The `Shelter` block always
+ * contains `enable` + `maxNum` + `shelterList`; tracked-shelter sub-
+ * blocks (`trackEnable`, `trackShelterList`) are PTZ-only and
+ * conditional on the camera supporting motion-tracking. Hub-channel
+ * cameras include `separateCfg` + `logicChannel`.
+ */
+interface MaskConfig {
+    body?: {
+        Shelter?: {
+            channelId?: number | undefined;
+            enable?: number | undefined;
+            maxNum?: number | undefined;
+            shelterList?: unknown;
+            trackEnable?: number | undefined;
+            maxTrackShelterNum?: number | undefined;
+            trackShelterList?: unknown;
+            separateCfg?: {
+                shelter?: number;
+                [key: string]: unknown;
+            } | undefined;
+            logicChannel?: number | undefined;
+            [key: string]: unknown;
+        };
+    };
+}
+/**
+ * Audio noise reduction configuration (`getAudioNoise`).
+ * cmdId=439. Note: the wire tag is lowercase `aiDenoise` (capital `V`
+ * in `@_Version`). Mirrors the camera-side schema observed live.
+ */
+interface AudioNoiseConfig {
+    body?: {
+        aiDenoise?: {
+            channelId?: number | undefined;
+            enable?: number | undefined;
+            level?: number | undefined;
+            [key: string]: unknown;
+        };
+    };
+}
+/**
+ * Auto-focus configuration (`getAutoFocus`). cmdId=224.
+ *
+ * The `disable` field is a 0/1 flag — `0` means autofocus is ENABLED.
+ * Non-PTZ cameras may return an empty `{}` or 400 — callers should
+ * narrow `body?.AutoFocus?.disable` defensively.
+ */
+interface AutoFocusConfig {
+    body?: {
+        AutoFocus?: {
+            channelId?: number | undefined;
+            disable?: number | undefined;
+            [key: string]: unknown;
+        };
+    };
+}
 /**
  * Video input configuration.
  * cmdId=75 (GetVideoInput)
@@ -2846,6 +3119,250 @@ type CgiAudioAlarmPlayParam = ({
     alarm_mode: "manul";
     manual_switch: number;
 });
+type CgiIsp = {
+    channel: number;
+    bright?: number;
+    contrast?: number;
+    saturation?: number;
+    sharpen?: number;
+    hue?: number;
+    antiFlicker?: string;
+    exposure?: string;
+    dayNight?: string;
+    backLight?: string;
+    blueGain?: number;
+    redGain?: number;
+    whiteBalance?: string;
+    mirroring?: number;
+    flip?: number;
+    rotation?: number;
+} & Record<string, JsonValue>;
+type CgiGetIspValue = {
+    Isp?: CgiIsp;
+} & Record<string, JsonValue>;
+type CgiSetIspParam = {
+    Isp: CgiIsp;
+};
+type CgiImage = {
+    channel: number;
+    bright?: number;
+    contrast?: number;
+    saturation?: number;
+    hue?: number;
+    sharpen?: number;
+    mirroring?: number;
+    flip?: number;
+} & Record<string, JsonValue>;
+type CgiGetImageValue = {
+    Image?: CgiImage;
+} & Record<string, JsonValue>;
+type CgiSetImageParam = {
+    Image: CgiImage;
+};
+type CgiAudioCfg = {
+    channel: number;
+    /** 0 = unmuted, 1 = muted. */
+    mute?: number;
+    /** 0..100. */
+    volume?: number;
+} & Record<string, JsonValue>;
+type CgiGetAudioCfgValue = {
+    AudioCfg?: CgiAudioCfg;
+} & Record<string, JsonValue>;
+type CgiSetAudioCfgParam = {
+    AudioCfg: CgiAudioCfg;
+};
+type CgiSetEncParam = {
+    Enc: CgiEnc;
+};
+type CgiMdAlarmSens = {
+    id?: number;
+    beginHour?: number;
+    beginMin?: number;
+    endHour?: number;
+    endMin?: number;
+    sensitivity?: number;
+} & Record<string, JsonValue>;
+type CgiMdAlarmScope = {
+    cols?: number;
+    rows?: number;
+    table?: string;
+} & Record<string, JsonValue>;
+type CgiMdAlarm = {
+    channel: number;
+    type?: string;
+    enable?: number;
+    scope?: CgiMdAlarmScope;
+    sens?: CgiMdAlarmSens[];
+} & Record<string, JsonValue>;
+type CgiGetMdAlarmValue = {
+    MdAlarm?: CgiMdAlarm;
+} & Record<string, JsonValue>;
+type CgiSetMdAlarmParam = {
+    MdAlarm: CgiMdAlarm;
+};
+type CgiIrLights = {
+    channel: number;
+    /** "Auto" | "Off" — modern firmwares; some legacy support "On". */
+    state?: string;
+} & Record<string, JsonValue>;
+type CgiGetIrLightsValue = {
+    IrLights?: CgiIrLights;
+} & Record<string, JsonValue>;
+type CgiSetIrLightsParam = {
+    IrLights: CgiIrLights;
+};
+type CgiAiCfg = {
+    channel: number;
+    AiTrack?: number;
+    smartTrack?: number;
+    trackType?: Record<string, number>;
+} & Record<string, JsonValue>;
+type CgiGetAiCfgValue = {
+    AiCfg?: CgiAiCfg;
+} & Record<string, JsonValue>;
+type CgiSetAiCfgParam = {
+    AiCfg: CgiAiCfg;
+};
+type CgiMaskShelter = {
+    enabled?: number;
+    position?: {
+        x?: number;
+        y?: number;
+        w?: number;
+        h?: number;
+    };
+} & Record<string, JsonValue>;
+type CgiMask = {
+    channel: number;
+    enable?: number;
+    shelterList?: CgiMaskShelter[];
+} & Record<string, JsonValue>;
+type CgiGetMaskValue = {
+    Mask?: CgiMask;
+} & Record<string, JsonValue>;
+type CgiSetMaskParam = {
+    Mask: CgiMask;
+};
+type CgiAudioNoise = {
+    channel: number;
+    enable?: number;
+    /** 0 = disabled, 1..N = strength tier (model-specific). */
+    level?: number;
+} & Record<string, JsonValue>;
+type CgiGetAudioNoiseValue = {
+    AudioNoise?: CgiAudioNoise;
+} & Record<string, JsonValue>;
+type CgiSetAudioNoiseParam = {
+    AudioNoise: CgiAudioNoise;
+};
+type CgiRecSchedule = {
+    channel: number;
+    enable?: number;
+    /** 7×24 weekly schedule mask, "1"/"0" per slot — present on V20+. */
+    table?: string;
+} & Record<string, JsonValue>;
+type CgiRec = {
+    schedule?: CgiRecSchedule;
+    scheduleEnable?: number;
+    enable?: number;
+    packTime?: string;
+    postRec?: string;
+} & Record<string, JsonValue>;
+type CgiGetRecValue = {
+    Rec?: CgiRec;
+} & Record<string, JsonValue>;
+type CgiSetRecParam = {
+    Rec: CgiRec;
+};
+type CgiEmail = {
+    schedule?: {
+        channel?: number;
+        enable?: number;
+        table?: string;
+    };
+    scheduleEnable?: number;
+    enable?: number;
+    smtpServer?: string;
+    smtpPort?: number;
+    userName?: string;
+    password?: string;
+    addr1?: string;
+    addr2?: string;
+    addr3?: string;
+    ssl?: number;
+    attachment?: number;
+    interval?: string;
+    textType?: string;
+    subject?: string;
+    content?: string;
+} & Record<string, JsonValue>;
+type CgiGetEmailValue = {
+    Email?: CgiEmail;
+} & Record<string, JsonValue>;
+type CgiSetEmailParam = {
+    Email: CgiEmail;
+};
+type CgiPush = {
+    schedule?: {
+        channel?: number;
+        enable?: number;
+        table?: string;
+    };
+    scheduleEnable?: number;
+    enable?: number;
+} & Record<string, JsonValue>;
+type CgiGetPushValue = {
+    Push?: CgiPush;
+} & Record<string, JsonValue>;
+type CgiSetPushParam = {
+    Push: CgiPush;
+};
+type CgiAudioAlarm = {
+    schedule?: {
+        channel?: number;
+        enable?: number;
+        table?: string;
+    };
+    scheduleEnable?: number;
+    enable?: number;
+    /** Built-in audio id; varies by camera. Use AudioAlarmPlay for
+     *  one-shot test playback. */
+    audioId?: number;
+    /** Times to repeat the audio per trigger. */
+    alarmTimes?: number;
+    audioVolume?: number;
+} & Record<string, JsonValue>;
+type CgiGetAudioAlarmValue = {
+    Audio?: CgiAudioAlarm;
+} & Record<string, JsonValue>;
+type CgiSetAudioAlarmParam = {
+    Audio: CgiAudioAlarm;
+};
+type CgiAutoFocus = {
+    channel: number;
+    /** 0 = enabled (default), 1 = disabled. Reolink names it `disable`
+     *  rather than `enable` because AF is on by default. */
+    disable?: number;
+} & Record<string, JsonValue>;
+type CgiGetAutoFocusValue = {
+    AutoFocus?: CgiAutoFocus;
+} & Record<string, JsonValue>;
+type CgiSetAutoFocusParam = {
+    AutoFocus: CgiAutoFocus;
+};
+type CgiAiAlarm = {
+    channel: number;
+    ai_type: string;
+    sensitivity?: number;
+    stayTime?: number;
+} & Record<string, JsonValue>;
+type CgiGetAiAlarmValue = {
+    AiAlarm?: CgiAiAlarm;
+} & Record<string, JsonValue>;
+type CgiSetAiAlarmParam = {
+    AiAlarm: CgiAiAlarm;
+};
 type CgiNetPort = Record<string, JsonValue>;
 type CgiBattery = {
     batteryPercent?: number;
@@ -3085,6 +3602,45 @@ declare class ReolinkCgiApi {
     GetPirInfo(channel?: number): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
     SetPirInfo(pirInfo: CgiSetPirInfoParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
     GetPtzPreset(channel?: number): Promise<ReolinkCmdResponse[]>;
+    GetIsp(channel?: number): Promise<Array<ReolinkCmdResponseExt<CgiGetIspValue>>>;
+    SetIsp(isp: CgiSetIspParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetImage(channel?: number): Promise<Array<ReolinkCmdResponseExt<CgiGetImageValue>>>;
+    SetImage(image: CgiSetImageParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetAudioCfg(channel?: number): Promise<Array<ReolinkCmdResponseExt<CgiGetAudioCfgValue>>>;
+    SetAudioCfg(audio: CgiSetAudioCfgParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    SetEnc(enc: CgiSetEncParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetMdAlarm(channel?: number): Promise<Array<ReolinkCmdResponseExt<CgiGetMdAlarmValue>>>;
+    SetMdAlarm(md: CgiSetMdAlarmParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetIrLights(channel?: number): Promise<Array<ReolinkCmdResponseExt<CgiGetIrLightsValue>>>;
+    SetIrLights(ir: CgiSetIrLightsParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetAiCfg(channel?: number): Promise<Array<ReolinkCmdResponseExt<CgiGetAiCfgValue>>>;
+    SetAiCfg(ai: CgiSetAiCfgParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetMask(channel: number): Promise<Array<ReolinkCmdResponseExt<CgiGetMaskValue>>>;
+    SetMask(mask: CgiSetMaskParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetAudioNoise(channel: number): Promise<Array<ReolinkCmdResponseExt<CgiGetAudioNoiseValue>>>;
+    SetAudioNoise(noise: CgiSetAudioNoiseParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetRec(channel: number): Promise<Array<ReolinkCmdResponseExt<CgiGetRecValue>>>;
+    SetRec(rec: CgiSetRecParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    /** Newer firmwares advertise `GetRecV20` / `SetRecV20` with the
+     *  weekly-schedule `table` field. Same payload shape as `Rec`. */
+    GetRecV20(channel: number): Promise<Array<ReolinkCmdResponseExt<CgiGetRecValue>>>;
+    SetRecV20(rec: CgiSetRecParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetEmail(channel: number): Promise<Array<ReolinkCmdResponseExt<CgiGetEmailValue>>>;
+    SetEmail(email: CgiSetEmailParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    /** V20 variant on newer firmwares with weekly-schedule `table`. */
+    GetEmailV20(channel: number): Promise<Array<ReolinkCmdResponseExt<CgiGetEmailValue>>>;
+    SetEmailV20(email: CgiSetEmailParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetPush(channel: number): Promise<Array<ReolinkCmdResponseExt<CgiGetPushValue>>>;
+    SetPush(push: CgiSetPushParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetPushV20(channel: number): Promise<Array<ReolinkCmdResponseExt<CgiGetPushValue>>>;
+    SetPushV20(push: CgiSetPushParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetAudioAlarm(channel: number): Promise<Array<ReolinkCmdResponseExt<CgiGetAudioAlarmValue>>>;
+    SetAudioAlarm(audio: CgiSetAudioAlarmParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    SetAudioAlarmV20(audio: CgiSetAudioAlarmParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetAutoFocus(channel: number): Promise<Array<ReolinkCmdResponseExt<CgiGetAutoFocusValue>>>;
+    SetAutoFocus(af: CgiSetAutoFocusParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
+    GetAiAlarm(channel: number, aiType: string): Promise<Array<ReolinkCmdResponseExt<CgiGetAiAlarmValue>>>;
+    SetAiAlarm(ai: CgiSetAiAlarmParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
     GetAudioAlarmV20(channel?: number): Promise<ReolinkCmdResponse[]>;
     AudioAlarmPlay(params: CgiAudioAlarmPlayParam): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
     GetNetPort(): Promise<Array<ReolinkCmdResponseExt<JsonValue>>>;
@@ -3350,13 +3906,34 @@ interface BaichuanRtspServerOptions {
      * - "rfc4571": RFC4571 framing: 2-byte length + RTP packet
      */
     tcpRtpFraming?: "rtsp-interleaved" | "rfc4571";
-    /** Credentials for RTSP authentication (optional) */
+    /**
+     * Credentials for RTSP authentication (optional).
+     *
+     * Each entry carries either the plaintext `password` or a pre-computed
+     * Digest `ha1 = MD5(username ":" realm ":" password)`. The HA1 variant is
+     * preferred when the consumer stores only hashed credentials (e.g. the
+     * manager reuses dashboard-user HA1 values without ever holding plaintext).
+     *
+     * When both are supplied, `ha1` wins for Digest validation while `password`
+     * is used for Basic authentication.
+     */
     credentials?: Array<{
         username: string;
         password: string;
+        ha1?: string;
+    } | {
+        username: string;
+        password?: string;
+        ha1: string;
     }>;
     /** Require authentication for RTSP connections (default: false if no credentials set) */
     requireAuth?: boolean;
+    /**
+     * Digest authentication realm advertised to clients. Must match the realm
+     * used when pre-computing HA1 values in `credentials[*].ha1`.
+     * Default: "BaichuanRtspServer" (kept for backward compatibility).
+     */
+    authRealm?: string;
     /**
      * External identifier for dedicated socket session.
      * When provided, a dedicated BaichuanClient is created for the stream,
@@ -3369,6 +3946,18 @@ interface BaichuanRtspServerOptions {
      * start() still performs metadata fetch and codec detection.
      */
     externalListener?: boolean;
+    /**
+     * When true, the server runs in **mux mode**: `start()` skips creating
+     * or listening on any TCP server (a shared multiplexer — e.g.
+     * `LocalRtspMux` — owns the public RTSP port and routes accepted sockets
+     * here via `injectSocket()`). `stop()` likewise skips closing a TCP
+     * server it does not own.
+     *
+     * Semantically equivalent to `externalListener: true`, but expressed from
+     * the point of view of the multiplexer that will drive this instance.
+     * Either flag is sufficient; both may be set together.
+     */
+    muxMode?: boolean;
     /**
      * Ms after the last RTSP client disconnects before stopping the native Baichuan stream.
      * 0 = keep the native stream running (matches rtsp proxy idle timeout 0 / always-mounted sources).
@@ -3380,6 +3969,18 @@ interface BaichuanRtspServerOptions {
      * 0 = disable. Default 15000 when nativeStreamIdleStopMs > 0, else 0.
      */
     nativeStreamPrimeIdleStopMs?: number;
+    /**
+     * When true, `start()` does NOT fetch stream metadata from the camera —
+     * the metadata fetch is deferred to the first DESCRIBE. Useful for
+     * battery / UDP cameras so binding the RTSP port at boot does not wake
+     * them up when no client is listening.
+     *
+     * Trade-off: the very first DESCRIBE pays the metadata round-trip
+     * latency. Subsequent connections hit the cached metadata.
+     *
+     * Default: false (keep existing behaviour).
+     */
+    lazyMetadata?: boolean;
 }
 /**
  * BaichuanRtspServer - RTSP server that serves a Baichuan video stream.
@@ -3417,6 +4018,7 @@ declare class BaichuanRtspServer extends EventEmitter<{
     private authNonces;
     private readonly AUTH_REALM;
     private readonly NONCE_TIMEOUT_MS;
+    private readonly lazyMetadata;
     private connectedClients;
     private nativeStreamActive;
     private clientConnectionServer;
@@ -3436,10 +4038,20 @@ declare class BaichuanRtspServer extends EventEmitter<{
     private tempStreamGenerator;
     private nativeFanout;
     private noClientAutoStopTimer;
+    /** Fires if camera never sends frames after stream start (sleeping), even with clients connected. */
+    private noFrameDeadlineTimer;
     /** After last RTSP client; 0 = never auto-stop native stream. */
     private readonly nativeStreamIdleStopMs;
     /** Primed-but-no-PLAY timeout; 0 = disabled. */
     private readonly nativeStreamPrimeIdleStopMs;
+    /**
+     * Max time to wait for the first camera frame after stream start.
+     * If no frames arrive within this window, the native stream is stopped
+     * (camera is sleeping). Prevents the BaichuanVideoStream watchdog from
+     * firing and waking the camera when no real viewer is watching.
+     * 0 = disabled. Defaults to nativeStreamPrimeIdleStopMs * 2 when > 0.
+     */
+    private readonly nativeStreamNoFrameDeadlineMs;
     private readonly PREBUFFER_MAX_MS;
     private prebuffer;
     private static isAdtsAacFrame;
@@ -3450,6 +4062,8 @@ declare class BaichuanRtspServer extends EventEmitter<{
     private static splitAnnexBNals;
     private static stripAdtsHeader;
     constructor(options: BaichuanRtspServerOptions);
+    /** Number of currently connected RTSP clients. */
+    get clientCount(): number;
     /**
      * Generate a new nonce for Digest authentication
      */
@@ -3475,6 +4089,7 @@ declare class BaichuanRtspServer extends EventEmitter<{
      */
     private generateWwwAuthenticateHeader;
     private clearNoClientAutoStopTimer;
+    private clearNoFrameDeadlineTimer;
     private setFlowVideoType;
     /**
      * Start the RTSP server.
@@ -3487,6 +4102,21 @@ declare class BaichuanRtspServer extends EventEmitter<{
      * @param initialBuffer - Any bytes already read during path parsing/auth
      */
     acceptConnection(socket: net.Socket, initialBuffer?: Buffer): void;
+    /**
+     * Inject an already-accepted client socket from a multiplexer
+     * (e.g. `LocalRtspMux`) that owns the listening port.
+     *
+     * The mux reads the first RTSP request line to determine the target path,
+     * then hands the socket over. Any bytes already consumed during routing
+     * are replayed back onto the socket via `unshift()` so the RTSP parser in
+     * `handleRtspConnection` sees the complete original request.
+     *
+     * @param socket - Client TCP socket, already accepted by the mux.
+     * @param preReadData - Bytes the mux has already pulled off the socket
+     *   while parsing the request line. Replayed via `socket.unshift()`
+     *   before any further reads.
+     */
+    injectSocket(socket: net.Socket, preReadData: Buffer): void;
     /**
      * Handle RTSP connection from a client.
      */
@@ -4361,7 +4991,17 @@ declare class ReolinkBaichuanApi {
     private statePollingInterval;
     private udpSleepInferenceInterval;
     private readonly udpLastInferredSleepStateByChannel;
+    /**
+     * Per-channel pending sleep-state candidate for hysteresis.
+     * When the inference flips to a new state we require N consecutive polls
+     * of that same state before committing it — this filters out transient
+     * flapping caused by non-waking traffic drifting in/out of the 10 s
+     * getSleepStatus() observation window during stream teardown.
+     */
+    private readonly udpPendingSleepStateByChannel;
     private readonly udpSleepInferenceIntervalMs;
+    /** Consecutive inference polls required to commit a new sleeping/awake state. */
+    private readonly udpSleepInferenceHysteresisPolls;
     private lastMotionState;
     private lastAiState;
     private aiStatePollingDisabled;
@@ -6150,6 +6790,185 @@ declare class ReolinkBaichuanApi {
      * Fetches events/motion/AI state for all channels via CGI and merges results per channel.
      */
     getAllChannelsEvents(options?: Parameters<ReolinkCgiApi["getAllChannelsEvents"]>[0]): ReturnType<ReolinkCgiApi["getAllChannelsEvents"]>;
+    /**
+     * GetEnc via Baichuan (cmdId=56). Returns the `<Compression>` block:
+     * per-stream `mainStream` / `subStream` / `thirdStream` with `audio`
+     * flag, `width`, `height`, `frame` (NOT `frameRate`), `bitRate`,
+     * `videoEncType` (0=h264, 1=h265), `encoderProfile`, `gop`. Mirrors
+     * reolink_aio's `GetEnc` — note the wire payload wraps everything
+     * in `Compression`, not `Enc`.
+     */
+    getEnc(channel?: number, options?: {
+        timeoutMs?: number;
+    }): Promise<EncConfig>;
+    /**
+     * SetEnc via Baichuan (cmdId=57). Read-modify-write — preserves
+     * unspecified fields. Mirrors reolink_aio's `SetEnc`.
+     *
+     * @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.
+     */
+    setEnc(channel: number, patch: {
+        audio?: 0 | 1;
+        mainStream?: {
+            bitRate?: number;
+            frameRate?: number;
+            videoEncType?: "h264" | "h265";
+        };
+        subStream?: {
+            bitRate?: number;
+            frameRate?: number;
+            videoEncType?: "h264" | "h265";
+        };
+    }, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    /**
+     * SetImage via Baichuan (cmdId=25, read via cmdId=26). Patches the
+     * `<VideoInput>` block: bright / contrast / saturation / hue /
+     * sharpen. Mirrors reolink_aio's `SetImage`.
+     */
+    setImage(channel: number, patch: {
+        bright?: number;
+        contrast?: number;
+        saturation?: number;
+        hue?: number;
+        sharpen?: number;
+    }, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    /**
+     * SetIsp via Baichuan (cmdId=25 for image side, cmdId=297 for
+     * dayNightThreshold). Patches the `<InputAdvanceCfg>` block:
+     * `DayNight/mode`, `Exposure/mode`, `binning_mode`, `hdrSwitch`.
+     * Mirrors reolink_aio's `SetIsp`.
+     *
+     * @param channel - Channel number (0-based)
+     * @param patch - Fields to update. `dayNight` accepts the camera's
+     *   raw enum (`color`, `auto`, `blackAndWhite`, …) — pass it as the
+     *   camera reports it (PascalCase / dotted forms get normalized
+     *   server-side).
+     */
+    setIsp(channel: number, patch: {
+        dayNight?: string;
+        exposure?: string;
+        binningMode?: number;
+        hdr?: 0 | 1;
+        dayNightThreshold?: number;
+    }, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    /**
+     * GetIsp via Baichuan (cmdId=26). Convenience alias of
+     * `getVideoInput()` so callers that switched from CGI keep the
+     * familiar name. Both return the merged VideoInput +
+     * InputAdvanceCfg blob.
+     */
+    getIsp(channel?: number, options?: {
+        timeoutMs?: number;
+    }): Promise<IspConfig>;
+    /** GetImage via Baichuan (cmdId=26). Same payload as `getIsp` —
+     *  Reolink merged VideoInput + InputAdvanceCfg under one cmdId. */
+    getImage(channel?: number, options?: {
+        timeoutMs?: number;
+    }): Promise<IspConfig>;
+    /**
+     * GetIrLights via Baichuan (cmdId=208). Returns LedState block:
+     * `IRLedBrightness`, `state` (ir on/off), `lightState` (status LED
+     * open/close), `doorbellLightState`. Mirrors reolink_aio's
+     * `get_status_led`.
+     */
+    getIrLights(channel?: number, options?: {
+        timeoutMs?: number;
+    }): Promise<IrLightsConfig>;
+    /**
+     * SetIrLights via Baichuan (cmdId=209, read via cmdId=208). Patches
+     * IR LED + status LED + doorbell LED + IR brightness. Mirrors
+     * reolink_aio's `set_status_led`.
+     *
+     * @param channel - Channel number (0-based)
+     * @param patch - `irState` ("On" | "Off" | "Auto"), `lightState`
+     *   (status LED), `doorbellLightState`, `irBrightness` (0..255).
+     *   Camera-side accepts lowercase strings (`open`/`close`); the
+     *   helper normalizes from the friendly variants.
+     */
+    setIrLights(channel: number, patch: {
+        irState?: "On" | "Off" | "Auto" | string;
+        lightState?: "On" | "Off" | string;
+        doorbellLightState?: "On" | "Off" | string;
+        irBrightness?: number;
+    }, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    /**
+     * SetAudioCfg via Baichuan (cmdId=265, read via cmdId=264). Patches
+     * volume / talk-and-reply / visitor settings. Mirrors reolink_aio's
+     * `SetAudioCfg`.
+     */
+    setAudioCfg(channel: number, patch: {
+        volume?: number;
+        talkAndReplyVolume?: number;
+        visitorVolume?: number;
+        visitorLoudspeaker?: number;
+    }, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    /**
+     * GetMask (privacy mask) via Baichuan (cmdId=52). Returns the
+     * `<Shelter>` block — `enable` flag + `shelterList`. Mirrors
+     * reolink_aio's `GetMask`.
+     */
+    getMask(channel?: number, options?: {
+        timeoutMs?: number;
+    }): Promise<MaskConfig>;
+    /**
+     * SetMask (privacy mask) via Baichuan (cmdId=53, read via cmdId=52).
+     * Toggles the `<Shelter><enable>` flag. Mirrors reolink_aio's
+     * `SetMask` (which only touches enable too — shelter zone editing
+     * goes through a separate flow).
+     */
+    setMask(channel: number, patch: {
+        enable?: 0 | 1 | boolean;
+    }, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    /**
+     * GetAudioNoise via Baichuan (cmdId=439). Reads `enable` + `level`
+     * from the aiDenoise block. Mirrors reolink_aio's `GetAudioNoise`.
+     *
+     * Note: `getAiDenoise` already returns the same payload typed as
+     * `AiDenoiseConfig`. This getter exists for naming parity with
+     * reolink_aio + the reolink CGI.
+     */
+    getAudioNoise(channel?: number, options?: {
+        timeoutMs?: number;
+    }): Promise<AudioNoiseConfig>;
+    /**
+     * SetAudioNoise via Baichuan (cmdId=440, read via cmdId=439).
+     * Mirrors reolink_aio's `SetAudioNoise` — `level <= 0` flips the
+     * enable flag off; positive values turn it on and update the level.
+     */
+    setAudioNoise(channel: number, level: number, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    /**
+     * GetAutoFocus via Baichuan (cmdId=224). Returns the `<AutoFocus>`
+     * block — only `disable` (0 = AF on, 1 = AF off). Mirrors
+     * reolink_aio's `GetAutoFocus`.
+     */
+    getAutoFocus(channel: number, options?: {
+        timeoutMs?: number;
+    }): Promise<AutoFocusConfig>;
+    /**
+     * SetAutoFocus via Baichuan (cmdId=225). Mirrors reolink_aio's
+     * `SetAutoFocus`. Note: write-only command — the payload is built
+     * from scratch (no read-modify-write needed).
+     */
+    setAutoFocus(channel: number, disable: 0 | 1 | boolean, options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
     /**
      * Passthrough to ReolinkCgiApi.getAllChannelsBatteryInfo.
      * Fetches battery info for all channels via CGI (merged with channel status sleep flag).
@@ -7486,6 +8305,64 @@ declare function computeDeviceCapabilities(params: {
  */
 declare function xmlIndicatesFloodlight(xml: string): boolean;
 
+/**
+ * Pure helpers for the UDP sleep-state inference running inside
+ * `ReolinkBaichuanApi.startUdpSleepInference()`.
+ *
+ * The inference polls `getSleepStatus()` every 2 s. That helper reads a rolling
+ * 10 s tx/rx-history window and infers whether the battery camera is asleep or
+ * awake. During stream teardown or idle-disconnect sequences, non-waking
+ * keepalive / battery-info traffic drifts in and out of the window, which can
+ * cause the inferred state to flap rapidly:
+ *
+ *     awake → sleeping → awake → sleeping → awake → ...
+ *
+ * Emitting every flap as a `sleeping`/`awake` event floods downstream consumers
+ * (events-manager, MQTT, Home Assistant) with phantom state changes even
+ * though the camera has not been touched. Hysteresis smooths this out: a new
+ * state must be observed on N consecutive polls before it is committed and an
+ * event is emitted. N=2 adds a 2 s detection latency (acceptable for battery
+ * cameras) while eliminating single-poll noise entirely.
+ */
+
+interface SleepInferencePending {
+    state: SleepState;
+    count: number;
+}
+interface SleepInferenceInput {
+    /** State returned by the current getSleepStatus() poll — must not be "unknown". */
+    inferred: Exclude<SleepState, "unknown">;
+    /** Previously committed state (undefined = first observation after inference start). */
+    committed: SleepState | undefined;
+    /** Pending candidate state and consecutive match count, if any. */
+    pending: SleepInferencePending | undefined;
+    /** Consecutive polls of the same inferred state required to commit. */
+    hysteresisPolls: number;
+}
+interface SleepInferenceDecision {
+    /** The event to dispatch, or null if no event should fire this poll. */
+    emit: "sleeping" | "awake" | null;
+    /** New committed state to store (never "unknown"). */
+    nextCommitted: SleepState;
+    /** New pending candidate to store, or undefined to clear it. */
+    nextPending: SleepInferencePending | undefined;
+}
+/**
+ * Decide whether a new sleep-inference poll should emit an event, given the
+ * previously committed state and any pending hysteresis candidate.
+ *
+ * Rules:
+ *   1. First observation (committed === undefined): always adopt as committed.
+ *      Emit "sleeping" but not "awake" — awake is the implicit default, so
+ *      emitting on startup would be noisy.
+ *   2. Inferred matches committed: stable, clear any pending candidate.
+ *   3. Inferred differs from committed but matches the pending candidate:
+ *      increment count. When count reaches hysteresisPolls, commit and emit.
+ *   4. Inferred differs from committed AND from any pending candidate:
+ *      restart the candidate at count=1 (does not emit).
+ */
+declare function decideSleepInferenceTransition(input: SleepInferenceInput): SleepInferenceDecision;
+
 type RtspStreamProfile = "main" | "sub" | "ext";
 declare function buildRtspPath(channel: number, stream: RtspStreamProfile): string;
 declare function buildRtspUrl(params: {
@@ -7677,6 +8554,8 @@ declare function createNativeStream(api: ReolinkBaichuanApi, channel: number, pr
     variant?: NativeVideoStreamVariant;
     /** Optional dedicated BaichuanClient for stream isolation. When omitted, uses api.client (shared). */
     client?: BaichuanClient;
+    /** Cancellation signal — aborting wakes the idle sleep and exits the generator promptly. */
+    signal?: AbortSignal;
 }): AsyncGenerator<{
     audio: boolean;
     data: Buffer;
@@ -8050,6 +8929,15 @@ declare function createReplayHttpServer(options: ReplayHttpServerOptions): Promi
  *      get IDR-aligned fast startup without waiting for the next keyframe.
  */
 
+type NativeFrame = {
+    audio: boolean;
+    data: Buffer;
+    codec: string | null;
+    sampleRate: number | null;
+    microseconds: number | null;
+    videoType?: "H264" | "H265";
+    isKeyframe?: boolean;
+};
 interface Go2rtcTcpServerOptions {
     /** API instance (required). */
     api: ReolinkBaichuanApi;
@@ -8130,6 +9018,7 @@ declare class Go2rtcTcpServer extends EventEmitter<{
     private totalFramesReceived;
     private totalVideoFramesWritten;
     private prebuffer;
+    private audioInfo;
     constructor(options: Go2rtcTcpServerOptions);
     /** Start listening. Resolves once the TCP server is bound. */
     start(): Promise<void>;
@@ -8141,18 +9030,45 @@ declare class Go2rtcTcpServer extends EventEmitter<{
     get go2rtcSourceUrl(): string | undefined;
     /** Number of currently connected clients. */
     get clientCount(): number;
+    /**
+     * Subscribe to the raw native stream for diagnostic purposes.
+     * The subscriber receives the same frames the MPEG-TS muxer consumes
+     * (pre-muxing). Counts as a "consumer" so the native stream is kept alive
+     * for the lifetime of the subscription. If the stream is not already
+     * running (battery camera, prestart=false), this starts it.
+     */
+    subscribeDiagnostic(id: string): Promise<AsyncGenerator<NativeFrame, void, unknown>>;
+    /** Unsubscribe a diagnostic session and release its consumer slot. */
+    unsubscribeDiagnostic(id: string): void;
+    /**
+     * Returns ADTS AAC audio metadata detected from the native stream, or
+     * null if no audio frame has been observed yet (e.g. video-only cameras
+     * or before the first audio packet arrives).
+     */
+    getAudioInfo(): {
+        codec: "aac-adts";
+        sampleRate: number;
+        channels: number;
+        configHex: string;
+    } | null;
     private handleClient;
     private feedClient;
     /**
-     * Convert a native frame to wire-ready Annex-B.
-     * Audio frames are skipped — raw TCP carries only video (Annex-B).
-     * go2rtc auto-detects the codec from SPS/PPS/VPS NALUs.
+     * Convert a native video frame to Annex-B.
+     * Returns null for audio frames (handled separately by muxAudio).
      */
-    private convertFrame;
+    private convertVideoFrame;
     /** Check if an Annex-B buffer contains a keyframe (IDR for H.264, IRAP for H.265). */
     private isAnnexBKeyframe;
     /** Split Annex-B byte stream into individual NAL units. */
     private static splitAnnexBNals;
+    /** True if `b` starts with an ADTS AAC syncword (0xFFF). */
+    private static isAdtsAacFrame;
+    /**
+     * Parse an ADTS header into {sampleRate, channels, AudioSpecificConfig hex}.
+     * Returns null when the buffer is not a valid ADTS frame.
+     */
+    private static parseAdtsSamplingInfo;
     private startNativeStream;
     private stopNativeStream;
     private startStreamHealthMonitor;
@@ -8161,6 +9077,73 @@ declare class Go2rtcTcpServer extends EventEmitter<{
     private scheduleStop;
 }
 
+/**
+ * MPEG-TS Muxer for H.264/H.265 video + ADTS AAC audio.
+ *
+ * Produces 188-byte MPEG-TS packets suitable for feeding to go2rtc via a
+ * plain TCP connection (`tcp://127.0.0.1:{port}`).  go2rtc auto-detects the
+ * container format from the 0x47 sync byte and extracts both video and audio.
+ *
+ * Stream layout:
+ *   PID 0x0000 — PAT (Program Association Table)
+ *   PID 0x1000 — PMT (Program Map Table)
+ *   PID 0x0100 — Video elementary stream (H.264 or H.265, Annex-B)
+ *   PID 0x0101 — Audio elementary stream (AAC-ADTS, stream type 0x0F)
+ *
+ * Each `MpegTsMuxer` instance is independent: continuity counters are
+ * per-instance so multiple concurrent streams do not corrupt each other.
+ *
+ * Usage:
+ *   const muxer = new MpegTsMuxer({ videoType: "H265", includeAudio: true });
+ *   const tsBytes = muxer.muxVideo(annexBBuffer, ptsUs, isKeyframe);
+ *   const tsBytes = muxer.muxAudio(adtsBuffer, ptsUs);
+ */
+interface MpegTsMuxerOptions {
+    /** Video codec type. */
+    videoType: "H264" | "H265";
+    /**
+     * Whether to include an audio PID (0x0101) in the PMT.
+     * When true, audio frames muxed via muxAudio() are wrapped in PES packets
+     * on PID 0x0101 (AAC-ADTS, stream type 0x0F).
+     * Default: true.
+     */
+    includeAudio?: boolean;
+}
+/**
+ * Stateful MPEG-TS muxer.  Each instance has its own continuity counters —
+ * create one per output stream (or per client connection for prebuffer replay).
+ */
+declare class MpegTsMuxer {
+    private readonly videoStreamType;
+    private readonly includeAudio;
+    private patCc;
+    private pmtCc;
+    private videoCc;
+    private audioCc;
+    private framesSinceTableSend;
+    private tablesSent;
+    constructor(options: MpegTsMuxerOptions);
+    /**
+     * Mux a video frame (Annex-B H.264 or H.265) into MPEG-TS packets.
+     * PAT and PMT are emitted before keyframes and periodically.
+     *
+     * @param annexBData - Annex-B video data (with start codes)
+     * @param ptsUs      - Presentation timestamp in microseconds
+     * @param isKeyframe - Whether this is an IDR / IRAP frame
+     */
+    muxVideo(annexBData: Buffer, ptsUs: number, isKeyframe: boolean): Buffer;
+    /**
+     * Mux an audio frame (ADTS AAC) into MPEG-TS packets.
+     * Returns an empty Buffer when includeAudio is false.
+     *
+     * @param adtsData - Raw ADTS AAC frame (starting with 0xFF 0xF1/0xF9 syncword)
+     * @param ptsUs    - Presentation timestamp in microseconds
+     */
+    muxAudio(adtsData: Buffer, ptsUs: number): Buffer;
+    /** Reset all continuity counters and table state (e.g. after stream restart). */
+    reset(): void;
+}
+
 /**
  * Baichuan HTTP Stream Server - Serves a Baichuan video stream over HTTP (MPEG-TS).
  * A simpler alternative to an RTSP server.
@@ -9133,4 +10116,4 @@ declare class CompositeRtspServer extends EventEmitter<{
     getClientCount(): number;
 }
 
-export { type AIDetectionState, type AIEvent, type AIState, type AbilityInfo, type AccessUserListConfig, AesStreamDecryptor, type AiAlarmConfig, type AiConfig, type AiDenoiseConfig, type AiKey, type AiTypesCacheEntry, type AnyBuffer, type AudioAlarmParams, type AudioCfgConfig, type AudioConfig, type AudioTaskConfig, type AutoDetectInputs, type AutoDetectMode, type AutoDetectResult, AutodiscoveryClient, type AutodiscoveryClientOptions, BC_AES_IV, BC_CLASS_FILE_DOWNLOAD, BC_CLASS_LEGACY, BC_CLASS_MODERN_20, BC_CLASS_MODERN_24, BC_CLASS_MODERN_24_ALT, BC_CMD_ID_ABILITY_INFO, BC_CMD_ID_ALARM_EVENT_LIST, BC_CMD_ID_AUDIO_ALARM_PLAY, BC_CMD_ID_CHANNEL_INFO_ALL, BC_CMD_ID_CMD_123, BC_CMD_ID_CMD_209, BC_CMD_ID_CMD_265, BC_CMD_ID_CMD_440, BC_CMD_ID_COVER_PREVIEW, BC_CMD_ID_COVER_RESPONSE, BC_CMD_ID_COVER_STANDALONE_458, BC_CMD_ID_COVER_STANDALONE_459, BC_CMD_ID_COVER_STANDALONE_460, BC_CMD_ID_COVER_STANDALONE_461, BC_CMD_ID_COVER_STANDALONE_462, BC_CMD_ID_DING_DONG_CTRL, BC_CMD_ID_DING_DONG_OPT, BC_CMD_ID_FILE_INFO_LIST_CLOSE, BC_CMD_ID_FILE_INFO_LIST_DL_VIDEO, BC_CMD_ID_FILE_INFO_LIST_DOWNLOAD, BC_CMD_ID_FILE_INFO_LIST_GET, BC_CMD_ID_FILE_INFO_LIST_OPEN, BC_CMD_ID_FILE_INFO_LIST_REPLAY, BC_CMD_ID_FILE_INFO_LIST_STOP, BC_CMD_ID_FIND_REC_VIDEO_CLOSE, BC_CMD_ID_FIND_REC_VIDEO_GET, BC_CMD_ID_FIND_REC_VIDEO_OPEN, BC_CMD_ID_FLOODLIGHT_STATUS_LIST, BC_CMD_ID_GET_ABILITY_SUPPORT, BC_CMD_ID_GET_ACCESS_USER_LIST, BC_CMD_ID_GET_AI_ALARM, BC_CMD_ID_GET_AI_CFG, BC_CMD_ID_GET_AI_DENOISE, BC_CMD_ID_GET_AUDIO_ALARM, BC_CMD_ID_GET_AUDIO_CFG, BC_CMD_ID_GET_AUDIO_TASK, BC_CMD_ID_GET_BATTERY_INFO, BC_CMD_ID_GET_BATTERY_INFO_LIST, BC_CMD_ID_GET_DAY_NIGHT_THRESHOLD, BC_CMD_ID_GET_DAY_RECORDS, BC_CMD_ID_GET_DING_DONG_CFG, BC_CMD_ID_GET_DING_DONG_LIST, BC_CMD_ID_GET_DING_DONG_SILENT, BC_CMD_ID_GET_EMAIL_TASK, BC_CMD_ID_GET_FTP_TASK, BC_CMD_ID_GET_HDD_INFO_LIST, BC_CMD_ID_GET_KIT_AP_CFG, BC_CMD_ID_GET_LED_STATE, BC_CMD_ID_GET_MOTION_ALARM, BC_CMD_ID_GET_ONLINE_USER_LIST, BC_CMD_ID_GET_OSD_DATETIME, BC_CMD_ID_GET_PIR_INFO, BC_CMD_ID_GET_PTZ_POSITION, BC_CMD_ID_GET_PTZ_PRESET, BC_CMD_ID_GET_RECORD, BC_CMD_ID_GET_RECORD_CFG, BC_CMD_ID_GET_REC_ENC_CFG, BC_CMD_ID_GET_SIREN_STATUS, BC_CMD_ID_GET_SLEEP_STATE, BC_CMD_ID_GET_STREAM_INFO_LIST, BC_CMD_ID_GET_SUPPORT, BC_CMD_ID_GET_SYSTEM_GENERAL, BC_CMD_ID_GET_TIMELAPSE_CFG, BC_CMD_ID_GET_VIDEO_INPUT, BC_CMD_ID_GET_WHITE_LED, BC_CMD_ID_GET_WIFI, BC_CMD_ID_GET_WIFI_SIGNAL, BC_CMD_ID_GET_ZOOM_FOCUS, BC_CMD_ID_LOGIN, BC_CMD_ID_LOGOUT, BC_CMD_ID_PING, BC_CMD_ID_PTZ_CONTROL, BC_CMD_ID_PTZ_CONTROL_PRESET, BC_CMD_ID_PUSH_COORDINATE_POINT_LIST, BC_CMD_ID_PUSH_DINGDONG_LIST, BC_CMD_ID_PUSH_NET_INFO, BC_CMD_ID_PUSH_SERIAL, BC_CMD_ID_PUSH_SLEEP_STATUS, BC_CMD_ID_PUSH_VIDEO_INPUT, BC_CMD_ID_QUICK_REPLY_PLAY, BC_CMD_ID_SET_AI_ALARM, BC_CMD_ID_SET_AI_CFG, BC_CMD_ID_SET_AUDIO_TASK, BC_CMD_ID_SET_DING_DONG_CFG, BC_CMD_ID_SET_DING_DONG_SILENT, BC_CMD_ID_SET_MOTION_ALARM, BC_CMD_ID_SET_PIR_INFO, BC_CMD_ID_SET_WHITE_LED_STATE, BC_CMD_ID_SET_WHITE_LED_TASK, BC_CMD_ID_SET_ZOOM_FOCUS, BC_CMD_ID_SUPPORT, BC_CMD_ID_TALK, BC_CMD_ID_TALK_ABILITY, BC_CMD_ID_TALK_CONFIG, BC_CMD_ID_TALK_RESET, BC_CMD_ID_UDP_KEEP_ALIVE, BC_CMD_ID_VIDEO, BC_CMD_ID_VIDEO_STOP, BC_MAGIC, BC_MAGIC_REV, BC_TCP_DEFAULT_PORT, BC_XML_KEY, type BaichuanCachedPush, BaichuanClient, type BaichuanClientOptions, type BaichuanCoordinatePointListPush, type BaichuanDingdongListPush, type BaichuanEndpointsServerOptions, BaichuanEventEmitter, type BaichuanFrame, BaichuanFrameParser, type BaichuanGetOsdDatetimeResult, type BaichuanHeader, BaichuanHlsServer, type BaichuanHlsServerOptions, BaichuanHttpStreamServer, type BaichuanHttpStreamServerOptions, type BaichuanLedState, BaichuanMjpegServer, type BaichuanMjpegServerOptions, type BaichuanNetInfoPush, type BaichuanOsdChannelName, type BaichuanOsdDatetime, type BaichuanRecordCfg, type BaichuanRecordSchedule, BaichuanRtspServer, type BaichuanRtspServerOptions, type BaichuanSerialPush, type BaichuanSettingsPushCacheEntry, type BaichuanSleepState, type BaichuanSleepStatusPush, type BaichuanStreamEncodeTable, type BaichuanStreamInfo, type BaichuanStreamInfoList, type BaichuanTransport, type BaichuanVideoInputPush, BaichuanVideoStream, type BaichuanVideoStreamOptions, BaichuanWebRTCServer, type BaichuanWebRTCServerOptions, type BaichuanWifi, type BaichuanWifiSignal, type BatteryInfo, type BatteryInfoResponse, type BcMedia, type BcMediaAac, type BcMediaAdpcm, BcMediaAnnexBDecoder, type BcMediaAnnexBDecoderStats, type BcMediaAnnexBInfo, type BcMediaAudioFrame, type BcMediaAudioType, BcMediaCodec, type BcMediaIframe, type BcMediaInfoV1, type BcMediaInfoV2, type BcMediaPframe, type BcMediaType, type BcMediaVideoFrame, type BcMediaVideoType, type BcUdpDiscoveryMethod, BcUdpStream, type BcUdpStreamOptions, type CgiAbility, type CgiAbilityChn, type CgiAbilityLeaf, type CgiAiKey, type CgiAiStateValue, type CgiAudioAlarmPlayParam, type CgiBattery, type CgiChannelStatusEntry, type CgiChnTypeInfoValue, type CgiDetectionState, type CgiDevInfo, type CgiDeviceInfoEntries, type CgiEnc, type CgiEncStream, type CgiEncValue, type CgiGetAbilityResponse, type CgiGetAbilityValue, type CgiGetAiStateResponse, type CgiGetChannelstatusResponse, type CgiGetChannelstatusValue, type CgiGetChnTypeInfoResponse, type CgiGetDevInfoResponse, type CgiGetDevInfoValue, type CgiGetEncResponse, type CgiGetOsdValue, type CgiGetRtspUrlResponse, type CgiGetRtspUrlValue, type CgiGetVideoclipsParams, type CgiNetPort, type CgiOsd, type CgiPirInfo, type CgiPtzPreset, type CgiSetOsdParam, type CgiSetPirInfoParam, type CgiSetWhiteLedParam, type CgiWhiteLed, type ChannelPushCacheEntry, type ChannelPushDataEntry, type ChannelRecordingFile, type ChannelStreamMetadata, type ChimeAlarmCfg, type ChimeCfg, type ChimeDevice, type ChimeParams, type CollectNvrDiagnosticsOptions, CompositeRtspServer, type CompositeRtspServerOptions, CompositeStream, type CompositeStreamOptions, type CompositeStreamPipOptions, DUAL_LENS_DUAL_MOTION_MODELS, DUAL_LENS_MODELS, DUAL_LENS_SINGLE_MOTION_MODELS, type DayNightThresholdConfig, type DebugConfig, type DebugOptions, type DeviceAbilities, type DeviceCapabilities, type DeviceCapabilitiesCacheEntry, type DeviceCapabilitiesDebugInfo, type DeviceCapabilitiesResult, type DeviceInfoResponse, type DeviceInputData, type DeviceObjectType, type DeviceStatusResponse, type DeviceSupportFlags, type DeviceType, type DiagnosticsCollectorResult, type DiagnosticsStreamKind, type DiscoveredDevice, type DiscoveryOptions, type DownloadRecordingParams, type DualLensChannelAnalysis, type DualLensChannelInfo, type EmailTaskConfig, type EncryptionProtocol, type Events, type EventsResponse, type FloodlightTaskConfig, type FtpTaskConfig, type GetRecordingVideoResult, type GetRecordingVideoStats, type GetVideoclipsParams, type GetVodUrlParams, Go2rtcTcpServer, type Go2rtcTcpServerOptions, H264RtpDepacketizer, H265RtpDepacketizer, type HardwiredChimeState, type HddInfoListConfig, type HlsCodec, type HlsHttpResponse, type HlsServerStatus, type HlsSession, HlsSessionManager, type HlsSessionManagerOptions, type HlsSessionParams, Intercom, type IntercomOptions, type JsonObject, type JsonPrimitive, type JsonValue, type LastSleepProbe, type LogLevel, type Logger, type LoggerCallback, type LoginResponseValue, type MaxEncryption, type MediaStream, type MjpegFrame, MjpegTransformer, type MjpegTransformerOptions, type ModelFixtureCaptureResult, type MotionAlarmConfig, type MotionEvent, NVR_HUB_EXACT_TYPES, NVR_HUB_MODEL_PATTERNS, type NativeVideoStreamVariant, type NvrChannelsSummaryCacheEntry, type OnlineUserListConfig, type OsdChannel, type OsdConfig, type OsdTime, type ParsedRecordingFileName, type PipPosition, type PirConfig, type PirState, type PlaybackSnapshotStreamInfo, type PtzCommand, type PtzPosition, type PtzPreset, type RecEncConfig, type RecordingAudioCodec, type RecordingDetectionClass, type RecordingDevType, type RecordingFile, type RecordingPlaybackUrls, type RecordingStreamType, type RecordingVideoCodec, type RecordingVodFlags, type RecordingVodStreamHint, type RecordingsCacheEntry, type RecordingsQueueItem, type ReolinkAiNotification, ReolinkBaichuanApi, type ReolinkBaichuanChannelIdentity, type ReolinkBaichuanChannelInfo, type ReolinkBaichuanDeviceSummary, type ReolinkBaichuanNetworkInfo, type ReolinkBaichuanPorts, ReolinkCgiApi, type ReolinkCmdRequest, type ReolinkCmdResponse, type ReolinkCmdResponseExt, type ReolinkDayNightNotification, type ReolinkDeviceInfo, type ReolinkDeviceInfoTag, type ReolinkEvent, ReolinkHttpClient, type ReolinkHttpClientOptions, type ReolinkJson, type ReolinkMotionNotification, type ReolinkNvrChannelInfo, type ReolinkNvrDeviceGroupSummary, type ReolinkNvrDeviceGroupsResult, type ReolinkSimpleEvent, type ReolinkSimpleEventType, type ReolinkSupportedStream, type ReolinkVideoStreamOptionsResult, type ReolinkVisitorNotification, type ReplayHttpServer, type ReplayHttpServerOptions, type ResponseMediaStreamOptions, type Rfc4571ApiFactoryContext, type Rfc4571Client, Rfc4571Muxer, type Rfc4571ReplayServer, type Rfc4571ReplayServerOptions, type Rfc4571TcpServer, type Rfc4571TcpServerOptions, type RtpPacketizationOptions, type RtspCreateOptions, type RtspProxyServerOptions, type RtspStreamProfile, type RunAllDiagnosticsConsecutivelyParams, type RunAllDiagnosticsConsecutivelyResult, type RunMultifocalDiagnosticsConsecutivelyParams, type RunMultifocalDiagnosticsConsecutivelyResult, type SirenState, type SirenStatusConfig, type SleepState, type SleepStatus, type StreamMetadata, type StreamProfile, type StreamSamplingOptions, type StreamSamplingSelection, type SupportConfig, type SupportInfo, type SupportItem, type SystemGeneralConfig, type TalkAbility$1 as TalkAbility, type TalkAudioConfig, type TalkConfig, type TalkSession$1 as TalkSession, type TalkSessionInfo, type TimelapseCfgConfig, type TwoWayAudioConfig, type VideoCodec, type VideoInputConfig, type VideoParamSets, type VideoStreamOptions, type VideoStreamOptionsCacheEntry, type VideoType, type VideoclipClientInfo, type VideoclipModeDecision, type VideoclipThumbnailResult, type VideoclipTranscodeMode, type VodFile, type VodSearchResponse, type VodSearchResult, type VodSearchStatus, type WakeUpOptions, type WebRTCAnswer, type WebRTCIceCandidate, type WebRTCOffer, type WebRTCSessionInfo, type WhiteLedConfig, type WhiteLedState, type WirelessChimeSilentState, type ZoomFocusStatus, type ZoomFocusTriplet, abilitiesHasAny, aesDecrypt, aesEncrypt, asLogger, autoDetectDeviceType, bcDecrypt, bcEncrypt, bcHeaderHasPayloadOffset, buildAacAudioSpecificConfigHex, buildAbilityInfoExtensionXml, buildBinaryExtensionXml, buildChannelExtensionXml, buildFloodlightManualXml, buildHlsRedirectUrl, buildLoginXml, buildLogoutXml, buildPreviewStopXml, buildPreviewStopXmlV11, buildPreviewXml, buildPreviewXmlV11, buildPtzControlXml, buildPtzPresetXml, buildPtzPresetXmlV2, buildRfc4571Sdp, buildRtspPath, buildRtspUrl, buildSirenManualXml, buildSirenTimesXml, buildStartZoomFocusXml, buildWhiteLedStateXml, captureModelFixtures, collectCgiDiagnostics, collectMultifocalDiagnostics, collectNativeDiagnostics, collectNvrDiagnostics, computeDeviceCapabilities, computeExpectedStreamCompatibility, convertToAnnexB as convertH265ToAnnexB, convertToAnnexB$1 as convertToAnnexB, convertToLengthPrefixed, createBaichuanEndpointsServer, createDebugGateLogger, createDiagnosticsBundle, createLogger, createMjpegBoundary, createNativeStream, createNullLogger, createReplayHttpServer, createRfc4571TcpServer, createRfc4571TcpServerForReplay, createRtspProxyServer, createTaggedLogger, decideVideoclipTranscodeMode, decodeHeader, deriveAesKey, detectIosClient, detectVideoCodecFromNal, discoverReolinkDevices, discoverViaArpTable, discoverViaDhcpListener, discoverViaHttpScan, discoverViaOnvif, discoverViaTcpPortScan, discoverViaUdpBroadcast, discoverViaUdpDirect, encodeHeader, extractH264ParamSetsFromAccessUnit, extractH265ParamSetsFromAccessUnit, extractPpsFromAnnexB, extractSpsFromAnnexB, extractVpsFromAnnexB, flattenAbilitiesForChannel, formatMjpegFrame, getConstructedVideoStreamOptions, getGlobalLogger, getH265NalType, getMjpegContentType, getSupportItemForChannel, getVideoStream, getVideoclipClientInfo, getXmlText, hasStartCodes as hasH265StartCodes, hasStartCodes$1 as hasStartCodes, isDualLenseModel, isH264KeyframeAnnexB, isH265Irap, isH265KeyframeAnnexB, isNvrHubModel, isTcpFailureThatShouldFallbackToUdp, isValidH264AnnexBAccessUnit, isValidH265AnnexBAccessUnit, maskUid, md5HexUpper, md5StrModern, normalizeUid, packetizeAacAdtsFrame, packetizeAacRawFrame, packetizeH264, packetizeH265, parseAdtsHeader, parseBcMedia, parseRecordingFileName, parseSupportXml, printNvrDiagnostics, runAllDiagnosticsConsecutively, runMultifocalDiagnosticsConsecutively, sampleStreams, sanitizeFixtureData, setGlobalLogger, splitAnnexBToNalPayloads$1 as splitAnnexBToNalPayloads, splitAnnexBToNals, splitAnnexBToNalPayloads as splitH265AnnexBToNalPayloads, testChannelStreams, xmlEscape, xmlIndicatesFloodlight, zipDirectory };
+export { type AIDetectionState, type AIEvent, type AIState, type AbilityInfo, type AccessUserListConfig, AesStreamDecryptor, type AiAlarmConfig, type AiConfig, type AiDenoiseConfig, type AiKey, type AiTypesCacheEntry, type AnyBuffer, type AudioAlarmParams, type AudioCfgConfig, type AudioConfig, type AudioNoiseConfig, type AudioTaskConfig, type AutoDetectInputs, type AutoDetectMode, type AutoDetectResult, type AutoFocusConfig, AutodiscoveryClient, type AutodiscoveryClientOptions, BC_AES_IV, BC_CLASS_FILE_DOWNLOAD, BC_CLASS_LEGACY, BC_CLASS_MODERN_20, BC_CLASS_MODERN_24, BC_CLASS_MODERN_24_ALT, BC_CMD_ID_ABILITY_INFO, BC_CMD_ID_ALARM_EVENT_LIST, BC_CMD_ID_AUDIO_ALARM_PLAY, BC_CMD_ID_CHANNEL_INFO_ALL, BC_CMD_ID_CMD_123, BC_CMD_ID_CMD_209, BC_CMD_ID_CMD_265, BC_CMD_ID_CMD_440, BC_CMD_ID_COVER_PREVIEW, BC_CMD_ID_COVER_RESPONSE, BC_CMD_ID_COVER_STANDALONE_458, BC_CMD_ID_COVER_STANDALONE_459, BC_CMD_ID_COVER_STANDALONE_460, BC_CMD_ID_COVER_STANDALONE_461, BC_CMD_ID_COVER_STANDALONE_462, BC_CMD_ID_DING_DONG_CTRL, BC_CMD_ID_DING_DONG_OPT, BC_CMD_ID_FILE_INFO_LIST_CLOSE, BC_CMD_ID_FILE_INFO_LIST_DL_VIDEO, BC_CMD_ID_FILE_INFO_LIST_DOWNLOAD, BC_CMD_ID_FILE_INFO_LIST_GET, BC_CMD_ID_FILE_INFO_LIST_OPEN, BC_CMD_ID_FILE_INFO_LIST_REPLAY, BC_CMD_ID_FILE_INFO_LIST_STOP, BC_CMD_ID_FIND_REC_VIDEO_CLOSE, BC_CMD_ID_FIND_REC_VIDEO_GET, BC_CMD_ID_FIND_REC_VIDEO_OPEN, BC_CMD_ID_FLOODLIGHT_STATUS_LIST, BC_CMD_ID_GET_ABILITY_SUPPORT, BC_CMD_ID_GET_ACCESS_USER_LIST, BC_CMD_ID_GET_AI_ALARM, BC_CMD_ID_GET_AI_CFG, BC_CMD_ID_GET_AI_DENOISE, BC_CMD_ID_GET_AUDIO_ALARM, BC_CMD_ID_GET_AUDIO_CFG, BC_CMD_ID_GET_AUDIO_TASK, BC_CMD_ID_GET_AUTO_FOCUS, BC_CMD_ID_GET_BATTERY_INFO, BC_CMD_ID_GET_BATTERY_INFO_LIST, BC_CMD_ID_GET_DAY_NIGHT_THRESHOLD, BC_CMD_ID_GET_DAY_RECORDS, BC_CMD_ID_GET_DING_DONG_CFG, BC_CMD_ID_GET_DING_DONG_LIST, BC_CMD_ID_GET_DING_DONG_SILENT, BC_CMD_ID_GET_EMAIL_TASK, BC_CMD_ID_GET_ENC, BC_CMD_ID_GET_FTP_TASK, BC_CMD_ID_GET_HDD_INFO_LIST, BC_CMD_ID_GET_KIT_AP_CFG, BC_CMD_ID_GET_LED_STATE, BC_CMD_ID_GET_MOTION_ALARM, BC_CMD_ID_GET_ONLINE_USER_LIST, BC_CMD_ID_GET_OSD_DATETIME, BC_CMD_ID_GET_PIR_INFO, BC_CMD_ID_GET_PRIVACY_MASK, BC_CMD_ID_GET_PTZ_POSITION, BC_CMD_ID_GET_PTZ_PRESET, BC_CMD_ID_GET_PUSH_TASK, BC_CMD_ID_GET_RECORD, BC_CMD_ID_GET_RECORD_CFG, BC_CMD_ID_GET_REC_ENC_CFG, BC_CMD_ID_GET_SIREN_STATUS, BC_CMD_ID_GET_SLEEP_STATE, BC_CMD_ID_GET_STREAM_INFO_LIST, BC_CMD_ID_GET_SUPPORT, BC_CMD_ID_GET_SYSTEM_GENERAL, BC_CMD_ID_GET_TIMELAPSE_CFG, BC_CMD_ID_GET_VIDEO_INPUT, BC_CMD_ID_GET_WHITE_LED, BC_CMD_ID_GET_WIFI, BC_CMD_ID_GET_WIFI_SIGNAL, BC_CMD_ID_GET_ZOOM_FOCUS, BC_CMD_ID_LOGIN, BC_CMD_ID_LOGOUT, BC_CMD_ID_PING, BC_CMD_ID_PTZ_CONTROL, BC_CMD_ID_PTZ_CONTROL_PRESET, BC_CMD_ID_PUSH_COORDINATE_POINT_LIST, BC_CMD_ID_PUSH_DINGDONG_LIST, BC_CMD_ID_PUSH_NET_INFO, BC_CMD_ID_PUSH_SERIAL, BC_CMD_ID_PUSH_SLEEP_STATUS, BC_CMD_ID_PUSH_VIDEO_INPUT, BC_CMD_ID_QUICK_REPLY_PLAY, BC_CMD_ID_SET_AI_ALARM, BC_CMD_ID_SET_AI_CFG, BC_CMD_ID_SET_AI_DENOISE, BC_CMD_ID_SET_AUDIO_CFG, BC_CMD_ID_SET_AUDIO_TASK, BC_CMD_ID_SET_AUTO_FOCUS, BC_CMD_ID_SET_DAY_NIGHT_THRESHOLD, BC_CMD_ID_SET_DING_DONG_CFG, BC_CMD_ID_SET_DING_DONG_SILENT, BC_CMD_ID_SET_EMAIL_TASK, BC_CMD_ID_SET_ENC, BC_CMD_ID_SET_LED_STATE, BC_CMD_ID_SET_MOTION_ALARM, BC_CMD_ID_SET_PIR_INFO, BC_CMD_ID_SET_PRIVACY_MASK, BC_CMD_ID_SET_PUSH_TASK, BC_CMD_ID_SET_RECORD, BC_CMD_ID_SET_RECORD_CFG, BC_CMD_ID_SET_VIDEO_INPUT, BC_CMD_ID_SET_WHITE_LED_STATE, BC_CMD_ID_SET_WHITE_LED_TASK, BC_CMD_ID_SET_ZOOM_FOCUS, BC_CMD_ID_SUPPORT, BC_CMD_ID_TALK, BC_CMD_ID_TALK_ABILITY, BC_CMD_ID_TALK_CONFIG, BC_CMD_ID_TALK_RESET, BC_CMD_ID_UDP_KEEP_ALIVE, BC_CMD_ID_VIDEO, BC_CMD_ID_VIDEO_STOP, BC_MAGIC, BC_MAGIC_REV, BC_TCP_DEFAULT_PORT, BC_XML_KEY, type BaichuanCachedPush, BaichuanClient, type BaichuanClientOptions, type BaichuanCoordinatePointListPush, type BaichuanDingdongListPush, type BaichuanEndpointsServerOptions, BaichuanEventEmitter, type BaichuanFrame, BaichuanFrameParser, type BaichuanGetOsdDatetimeResult, type BaichuanHeader, BaichuanHlsServer, type BaichuanHlsServerOptions, BaichuanHttpStreamServer, type BaichuanHttpStreamServerOptions, type BaichuanLedState, BaichuanMjpegServer, type BaichuanMjpegServerOptions, type BaichuanNetInfoPush, type BaichuanOsdChannelName, type BaichuanOsdDatetime, type BaichuanRecordCfg, type BaichuanRecordSchedule, BaichuanRtspServer, type BaichuanRtspServerOptions, type BaichuanSerialPush, type BaichuanSettingsPushCacheEntry, type BaichuanSleepState, type BaichuanSleepStatusPush, type BaichuanStreamEncodeTable, type BaichuanStreamInfo, type BaichuanStreamInfoList, type BaichuanTransport, type BaichuanVideoInputPush, BaichuanVideoStream, type BaichuanVideoStreamOptions, BaichuanWebRTCServer, type BaichuanWebRTCServerOptions, type BaichuanWifi, type BaichuanWifiSignal, type BatteryInfo, type BatteryInfoResponse, type BcMedia, type BcMediaAac, type BcMediaAdpcm, BcMediaAnnexBDecoder, type BcMediaAnnexBDecoderStats, type BcMediaAnnexBInfo, type BcMediaAudioFrame, type BcMediaAudioType, BcMediaCodec, type BcMediaIframe, type BcMediaInfoV1, type BcMediaInfoV2, type BcMediaPframe, type BcMediaType, type BcMediaVideoFrame, type BcMediaVideoType, type BcUdpDiscoveryMethod, BcUdpStream, type BcUdpStreamOptions, type CgiAbility, type CgiAbilityChn, type CgiAbilityLeaf, type CgiAiAlarm, type CgiAiCfg, type CgiAiKey, type CgiAiStateValue, type CgiAudioAlarm, type CgiAudioAlarmPlayParam, type CgiAudioCfg, type CgiAudioNoise, type CgiAutoFocus, type CgiBattery, type CgiChannelStatusEntry, type CgiChnTypeInfoValue, type CgiDetectionState, type CgiDevInfo, type CgiDeviceInfoEntries, type CgiEmail, type CgiEnc, type CgiEncStream, type CgiEncValue, type CgiGetAbilityResponse, type CgiGetAbilityValue, type CgiGetAiAlarmValue, type CgiGetAiCfgValue, type CgiGetAiStateResponse, type CgiGetAudioAlarmValue, type CgiGetAudioCfgValue, type CgiGetAudioNoiseValue, type CgiGetAutoFocusValue, type CgiGetChannelstatusResponse, type CgiGetChannelstatusValue, type CgiGetChnTypeInfoResponse, type CgiGetDevInfoResponse, type CgiGetDevInfoValue, type CgiGetEmailValue, type CgiGetEncResponse, type CgiGetImageValue, type CgiGetIrLightsValue, type CgiGetIspValue, type CgiGetMaskValue, type CgiGetMdAlarmValue, type CgiGetOsdValue, type CgiGetPushValue, type CgiGetRecValue, type CgiGetRtspUrlResponse, type CgiGetRtspUrlValue, type CgiGetVideoclipsParams, type CgiImage, type CgiIrLights, type CgiIsp, type CgiMask, type CgiMaskShelter, type CgiMdAlarm, type CgiMdAlarmScope, type CgiMdAlarmSens, type CgiNetPort, type CgiOsd, type CgiPirInfo, type CgiPtzPreset, type CgiPush, type CgiRec, type CgiRecSchedule, type CgiSetAiAlarmParam, type CgiSetAiCfgParam, type CgiSetAudioAlarmParam, type CgiSetAudioCfgParam, type CgiSetAudioNoiseParam, type CgiSetAutoFocusParam, type CgiSetEmailParam, type CgiSetEncParam, type CgiSetImageParam, type CgiSetIrLightsParam, type CgiSetIspParam, type CgiSetMaskParam, type CgiSetMdAlarmParam, type CgiSetOsdParam, type CgiSetPirInfoParam, type CgiSetPushParam, type CgiSetRecParam, type CgiSetWhiteLedParam, type CgiWhiteLed, type ChannelPushCacheEntry, type ChannelPushDataEntry, type ChannelRecordingFile, type ChannelStreamMetadata, type ChimeAlarmCfg, type ChimeCfg, type ChimeDevice, type ChimeParams, type CollectNvrDiagnosticsOptions, CompositeRtspServer, type CompositeRtspServerOptions, CompositeStream, type CompositeStreamOptions, type CompositeStreamPipOptions, type CompressionStream, DUAL_LENS_DUAL_MOTION_MODELS, DUAL_LENS_MODELS, DUAL_LENS_SINGLE_MOTION_MODELS, type DayNightThresholdConfig, type DebugConfig, type DebugOptions, type DeviceAbilities, type DeviceCapabilities, type DeviceCapabilitiesCacheEntry, type DeviceCapabilitiesDebugInfo, type DeviceCapabilitiesResult, type DeviceInfoResponse, type DeviceInputData, type DeviceObjectType, type DeviceStatusResponse, type DeviceSupportFlags, type DeviceType, type DiagnosticsCollectorResult, type DiagnosticsStreamKind, type DiscoveredDevice, type DiscoveryOptions, type DownloadRecordingParams, type DualLensChannelAnalysis, type DualLensChannelInfo, type EmailTaskConfig, type EncConfig, type EncryptionProtocol, type Events, type EventsResponse, type FloodlightTaskConfig, type FtpTaskConfig, type GetRecordingVideoResult, type GetRecordingVideoStats, type GetVideoclipsParams, type GetVodUrlParams, Go2rtcTcpServer, type Go2rtcTcpServerOptions, H264RtpDepacketizer, H265RtpDepacketizer, type HardwiredChimeState, type HddInfoListConfig, type HlsCodec, type HlsHttpResponse, type HlsServerStatus, type HlsSession, HlsSessionManager, type HlsSessionManagerOptions, type HlsSessionParams, Intercom, type IntercomOptions, type IrLightsConfig, type IspConfig, type JsonObject, type JsonPrimitive, type JsonValue, type LastSleepProbe, type LogLevel, type Logger, type LoggerCallback, type LoginResponseValue, type MaskConfig, type MaxEncryption, type MediaStream, type MjpegFrame, MjpegTransformer, type MjpegTransformerOptions, type ModelFixtureCaptureResult, type MotionAlarmConfig, type MotionEvent, MpegTsMuxer, type MpegTsMuxerOptions, NVR_HUB_EXACT_TYPES, NVR_HUB_MODEL_PATTERNS, type NativeVideoStreamVariant, type NvrChannelsSummaryCacheEntry, type OnlineUserListConfig, type OsdChannel, type OsdConfig, type OsdTime, type ParsedRecordingFileName, type PipPosition, type PirConfig, type PirState, type PlaybackSnapshotStreamInfo, type PtzCommand, type PtzPosition, type PtzPreset, type RecEncConfig, type RecordingAudioCodec, type RecordingDetectionClass, type RecordingDevType, type RecordingFile, type RecordingPlaybackUrls, type RecordingStreamType, type RecordingVideoCodec, type RecordingVodFlags, type RecordingVodStreamHint, type RecordingsCacheEntry, type RecordingsQueueItem, type ReolinkAiNotification, ReolinkBaichuanApi, type ReolinkBaichuanChannelIdentity, type ReolinkBaichuanChannelInfo, type ReolinkBaichuanDeviceSummary, type ReolinkBaichuanNetworkInfo, type ReolinkBaichuanPorts, ReolinkCgiApi, type ReolinkCmdRequest, type ReolinkCmdResponse, type ReolinkCmdResponseExt, type ReolinkDayNightNotification, type ReolinkDeviceInfo, type ReolinkDeviceInfoTag, type ReolinkEvent, ReolinkHttpClient, type ReolinkHttpClientOptions, type ReolinkJson, type ReolinkMotionNotification, type ReolinkNvrChannelInfo, type ReolinkNvrDeviceGroupSummary, type ReolinkNvrDeviceGroupsResult, type ReolinkSimpleEvent, type ReolinkSimpleEventType, type ReolinkSupportedStream, type ReolinkVideoStreamOptionsResult, type ReolinkVisitorNotification, type ReplayHttpServer, type ReplayHttpServerOptions, type ResponseMediaStreamOptions, type Rfc4571ApiFactoryContext, type Rfc4571Client, Rfc4571Muxer, type Rfc4571ReplayServer, type Rfc4571ReplayServerOptions, type Rfc4571TcpServer, type Rfc4571TcpServerOptions, type RtpPacketizationOptions, type RtspCreateOptions, type RtspProxyServerOptions, type RtspStreamProfile, type RunAllDiagnosticsConsecutivelyParams, type RunAllDiagnosticsConsecutivelyResult, type RunMultifocalDiagnosticsConsecutivelyParams, type RunMultifocalDiagnosticsConsecutivelyResult, type SirenState, type SirenStatusConfig, type SleepInferenceDecision, type SleepInferenceInput, type SleepInferencePending, type SleepState, type SleepStatus, type StreamMetadata, type StreamProfile, type StreamSamplingOptions, type StreamSamplingSelection, type SupportConfig, type SupportInfo, type SupportItem, type SystemGeneralConfig, type TalkAbility$1 as TalkAbility, type TalkAudioConfig, type TalkConfig, type TalkSession$1 as TalkSession, type TalkSessionInfo, type TimelapseCfgConfig, type TwoWayAudioConfig, type VideoCodec, type VideoInputConfig, type VideoParamSets, type VideoStreamOptions, type VideoStreamOptionsCacheEntry, type VideoType, type VideoclipClientInfo, type VideoclipModeDecision, type VideoclipThumbnailResult, type VideoclipTranscodeMode, type VodFile, type VodSearchResponse, type VodSearchResult, type VodSearchStatus, type WakeUpOptions, type WebRTCAnswer, type WebRTCIceCandidate, type WebRTCOffer, type WebRTCSessionInfo, type WhiteLedConfig, type WhiteLedState, type WirelessChimeSilentState, type ZoomFocusStatus, type ZoomFocusTriplet, abilitiesHasAny, aesDecrypt, aesEncrypt, applyStreamPatch, applyXmlTagPatch, asLogger, autoDetectDeviceType, bcDecrypt, bcEncrypt, bcHeaderHasPayloadOffset, buildAacAudioSpecificConfigHex, buildAbilityInfoExtensionXml, buildBinaryExtensionXml, buildChannelExtensionXml, buildFloodlightManualXml, buildHlsRedirectUrl, buildLoginXml, buildLogoutXml, buildPreviewStopXml, buildPreviewStopXmlV11, buildPreviewXml, buildPreviewXmlV11, buildPtzControlXml, buildPtzPresetXml, buildPtzPresetXmlV2, buildRfc4571Sdp, buildRtspPath, buildRtspUrl, buildSirenManualXml, buildSirenTimesXml, buildStartZoomFocusXml, buildWhiteLedStateXml, captureModelFixtures, collectCgiDiagnostics, collectMultifocalDiagnostics, collectNativeDiagnostics, collectNvrDiagnostics, computeDeviceCapabilities, computeExpectedStreamCompatibility, convertToAnnexB as convertH265ToAnnexB, convertToAnnexB$1 as convertToAnnexB, convertToLengthPrefixed, createBaichuanEndpointsServer, createDebugGateLogger, createDiagnosticsBundle, createLogger, createMjpegBoundary, createNativeStream, createNullLogger, createReplayHttpServer, createRfc4571TcpServer, createRfc4571TcpServerForReplay, createRtspProxyServer, createTaggedLogger, decideSleepInferenceTransition, decideVideoclipTranscodeMode, decodeHeader, deriveAesKey, detectIosClient, detectVideoCodecFromNal, discoverReolinkDevices, discoverViaArpTable, discoverViaDhcpListener, discoverViaHttpScan, discoverViaOnvif, discoverViaTcpPortScan, discoverViaUdpBroadcast, discoverViaUdpDirect, encodeHeader, ensureXmlHeader, extractH264ParamSetsFromAccessUnit, extractH265ParamSetsFromAccessUnit, extractPpsFromAnnexB, extractSpsFromAnnexB, extractVpsFromAnnexB, flattenAbilitiesForChannel, formatMjpegFrame, getConstructedVideoStreamOptions, getGlobalLogger, getH265NalType, getMjpegContentType, getSupportItemForChannel, getVideoStream, getVideoclipClientInfo, getXmlText, hasStartCodes as hasH265StartCodes, hasStartCodes$1 as hasStartCodes, isDualLenseModel, isH264KeyframeAnnexB, isH265Irap, isH265KeyframeAnnexB, isNvrHubModel, isTcpFailureThatShouldFallbackToUdp, isValidH264AnnexBAccessUnit, isValidH265AnnexBAccessUnit, maskUid, md5HexUpper, md5StrModern, normalizeDayNightMode, normalizeOpenClose, normalizeUid, packetizeAacAdtsFrame, packetizeAacRawFrame, packetizeH264, packetizeH265, parseAdtsHeader, parseBcMedia, parseRecordingFileName, parseSupportXml, patchNestedTag, printNvrDiagnostics, runAllDiagnosticsConsecutively, runMultifocalDiagnosticsConsecutively, sampleStreams, sanitizeFixtureData, setGlobalLogger, splitAnnexBToNalPayloads$1 as splitAnnexBToNalPayloads, splitAnnexBToNals, splitAnnexBToNalPayloads as splitH265AnnexBToNalPayloads, testChannelStreams, xmlEscape, xmlIndicatesFloodlight, zipDirectory };