@apocaliss92/nodelink-js 0.4.8 → 0.4.11

package/dist/index.d.ts

@@ -179,6 +179,25 @@ 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: {
+    bitRate?: number;
+    frameRate?: number;
+    videoEncType?: "h264" | "h265";
+} | undefined): 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.
+ */
+export declare function applyXmlTagPatch(xml: string, tag: string, value: string | number | boolean | undefined): string;
+
 export declare function asLogger(logger?: LoggerLike): Logger_2;
 
 export declare interface AudioAlarmParams {
@@ -218,6 +237,22 @@ export declare type AudioConfig = {
     channels: number;
 };
 
+/**
+ * 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.
+ */
+export declare interface AudioNoiseConfig {
+    body?: {
+        aiDenoise?: {
+            channelId?: number | undefined;
+            enable?: number | undefined;
+            level?: number | undefined;
+            [key: string]: unknown;
+        };
+    };
+}
+
 /**
  * AudioTask configuration - controls siren/alarm on motion detection.
  * Retrieved via cmdId=232 (GET) and set via cmdId=231 (SET).
@@ -383,6 +418,23 @@ export declare interface AutodiscoveryClientOptions extends DiscoveryOptions {
     onDeviceUpdated?: (device: DiscoveredDevice) => void;
 }
 
+/**
+ * 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.
+ */
+export declare interface AutoFocusConfig {
+    body?: {
+        AutoFocus?: {
+            channelId?: number | undefined;
+            disable?: number | undefined;
+            [key: string]: unknown;
+        };
+    };
+}
+
 export declare type BaichuanCachedPush<T> = {
     updatedAtMs: number;
     value: T;
@@ -1973,12 +2025,16 @@ export declare const BC_CMD_ID_AUDIO_ALARM_PLAY = 263;
 
 export declare const BC_CMD_ID_CHANNEL_INFO_ALL = 145;
 
+/** @deprecated Use {@link BC_CMD_ID_SET_LED_STATE} (209). */
 export declare const BC_CMD_ID_CMD_123 = 123;
 
+/** @deprecated Use {@link BC_CMD_ID_SET_LED_STATE} (209). */
 export declare const BC_CMD_ID_CMD_209 = 209;
 
+/** @deprecated Use {@link BC_CMD_ID_SET_AUDIO_CFG} (265). */
 export declare const BC_CMD_ID_CMD_265 = 265;
 
+/** @deprecated Use {@link BC_CMD_ID_SET_AI_DENOISE} (440). */
 export declare const BC_CMD_ID_CMD_440 = 440;
 
 export declare const BC_CMD_ID_COVER_PREVIEW = 298;
@@ -2037,6 +2093,8 @@ export declare const BC_CMD_ID_GET_AUDIO_CFG = 264;
 
 export declare const BC_CMD_ID_GET_AUDIO_TASK = 232;
 
+export declare const BC_CMD_ID_GET_AUTO_FOCUS = 224;
+
 export declare const BC_CMD_ID_GET_BATTERY_INFO = 253;
 
 export declare const BC_CMD_ID_GET_BATTERY_INFO_LIST = 252;
@@ -2053,6 +2111,8 @@ export declare const BC_CMD_ID_GET_DING_DONG_SILENT = 609;
 
 export declare const BC_CMD_ID_GET_EMAIL_TASK = 217;
 
+export declare const BC_CMD_ID_GET_ENC = 56;
+
 export declare const BC_CMD_ID_GET_FTP_TASK = 70;
 
 export declare const BC_CMD_ID_GET_HDD_INFO_LIST = 102;
@@ -2069,10 +2129,14 @@ export declare const BC_CMD_ID_GET_OSD_DATETIME = 44;
 
 export declare const BC_CMD_ID_GET_PIR_INFO = 212;
 
+export declare const BC_CMD_ID_GET_PRIVACY_MASK = 52;
+
 export declare const BC_CMD_ID_GET_PTZ_POSITION = 433;
 
 export declare const BC_CMD_ID_GET_PTZ_PRESET = 190;
 
+export declare const BC_CMD_ID_GET_PUSH_TASK = 219;
+
 export declare const BC_CMD_ID_GET_REC_ENC_CFG = 507;
 
 export declare const BC_CMD_ID_GET_RECORD = 81;
@@ -2136,16 +2200,40 @@ export declare const BC_CMD_ID_SET_AI_ALARM = 343;
 
 export declare const BC_CMD_ID_SET_AI_CFG = 300;
 
+export declare const BC_CMD_ID_SET_AI_DENOISE = 440;
+
+export declare const BC_CMD_ID_SET_AUDIO_CFG = 265;
+
 export declare const BC_CMD_ID_SET_AUDIO_TASK = 231;
 
+export declare const BC_CMD_ID_SET_AUTO_FOCUS = 225;
+
+export declare const BC_CMD_ID_SET_DAY_NIGHT_THRESHOLD = 297;
+
 export declare const BC_CMD_ID_SET_DING_DONG_CFG = 487;
 
 export declare const BC_CMD_ID_SET_DING_DONG_SILENT = 610;
 
+export declare const BC_CMD_ID_SET_EMAIL_TASK = 216;
+
+export declare const BC_CMD_ID_SET_ENC = 57;
+
+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_PIR_INFO = 213;
 
+export declare const BC_CMD_ID_SET_PRIVACY_MASK = 53;
+
+export declare const BC_CMD_ID_SET_PUSH_TASK = 218;
+
+export declare const BC_CMD_ID_SET_RECORD = 82;
+
+export declare const BC_CMD_ID_SET_RECORD_CFG = 55;
+
+export declare const BC_CMD_ID_SET_VIDEO_INPUT = 25;
+
 export declare const BC_CMD_ID_SET_WHITE_LED_STATE = 288;
 
 export declare const BC_CMD_ID_SET_WHITE_LED_TASK = 290;
@@ -2808,12 +2896,42 @@ export declare type CgiAbilityLeaf = {
     ver: number;
 };
 
+export declare type CgiAiAlarm = {
+    channel: number;
+    ai_type: string;
+    sensitivity?: number;
+    stayTime?: number;
+} & Record<string, JsonValue>;
+
+export declare type CgiAiCfg = {
+    channel: number;
+    AiTrack?: number;
+    smartTrack?: number;
+    trackType?: Record<string, number>;
+} & Record<string, JsonValue>;
+
 export declare type CgiAiKey = "dog_cat" | "face" | "other" | "package" | "people" | "vehicle";
 
 export declare type CgiAiStateValue = Partial<Record<CgiAiKey, CgiDetectionState>> & {
     channel: number;
 };
 
+export declare 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>;
+
 export declare type CgiAudioAlarmPlayParam = ({
     channel: number;
 } & {
@@ -2826,6 +2944,28 @@ export declare type CgiAudioAlarmPlayParam = ({
     manual_switch: number;
 });
 
+export declare type CgiAudioCfg = {
+    channel: number;
+    /** 0 = unmuted, 1 = muted. */
+    mute?: number;
+    /** 0..100. */
+    volume?: number;
+} & Record<string, JsonValue>;
+
+export declare type CgiAudioNoise = {
+    channel: number;
+    enable?: number;
+    /** 0 = disabled, 1..N = strength tier (model-specific). */
+    level?: number;
+} & Record<string, JsonValue>;
+
+export declare 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>;
+
 export declare type CgiBattery = {
     batteryPercent?: number;
 } & Record<string, JsonValue>;
@@ -2879,6 +3019,29 @@ export declare type CgiDevInfo = {
     wifi?: number;
 };
 
+export declare 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>;
+
 export declare type CgiEnc = {
     audio: number;
     channel: number;
@@ -2907,10 +3070,34 @@ export declare type CgiGetAbilityResponse = ReolinkCmdResponseExt<CgiGetAbilityV
 
 export declare type CgiGetAbilityValue = CgiAbility;
 
+export declare type CgiGetAiAlarmValue = {
+    AiAlarm?: CgiAiAlarm;
+} & Record<string, JsonValue>;
+
+export declare type CgiGetAiCfgValue = {
+    AiCfg?: CgiAiCfg;
+} & Record<string, JsonValue>;
+
 export declare type CgiGetAiStateResponse = ReolinkCmdResponseExt<CgiAiStateValue> & {
     cmd: "GetAiState";
 };
 
+export declare type CgiGetAudioAlarmValue = {
+    Audio?: CgiAudioAlarm;
+} & Record<string, JsonValue>;
+
+export declare type CgiGetAudioCfgValue = {
+    AudioCfg?: CgiAudioCfg;
+} & Record<string, JsonValue>;
+
+export declare type CgiGetAudioNoiseValue = {
+    AudioNoise?: CgiAudioNoise;
+} & Record<string, JsonValue>;
+
+export declare type CgiGetAutoFocusValue = {
+    AutoFocus?: CgiAutoFocus;
+} & Record<string, JsonValue>;
+
 export declare type CgiGetChannelstatusResponse = ReolinkCmdResponseExt<CgiGetChannelstatusValue> & {
     cmd: "GetChannelstatus";
 };
@@ -2931,16 +3118,48 @@ export declare type CgiGetDevInfoValue = {
     DevInfo: CgiDevInfo;
 };
 
+export declare type CgiGetEmailValue = {
+    Email?: CgiEmail;
+} & Record<string, JsonValue>;
+
 export declare type CgiGetEncResponse = ReolinkCmdResponseExt<CgiEncValue> & {
     cmd: "GetEnc";
     initial?: CgiEncValue;
     range?: JsonValue;
 };
 
+export declare type CgiGetImageValue = {
+    Image?: CgiImage;
+} & Record<string, JsonValue>;
+
+export declare type CgiGetIrLightsValue = {
+    IrLights?: CgiIrLights;
+} & Record<string, JsonValue>;
+
+export declare type CgiGetIspValue = {
+    Isp?: CgiIsp;
+} & Record<string, JsonValue>;
+
+export declare type CgiGetMaskValue = {
+    Mask?: CgiMask;
+} & Record<string, JsonValue>;
+
+export declare type CgiGetMdAlarmValue = {
+    MdAlarm?: CgiMdAlarm;
+} & Record<string, JsonValue>;
+
 export declare type CgiGetOsdValue = {
     Osd?: CgiOsd;
 } & Record<string, JsonValue>;
 
+export declare type CgiGetPushValue = {
+    Push?: CgiPush;
+} & Record<string, JsonValue>;
+
+export declare type CgiGetRecValue = {
+    Rec?: CgiRec;
+} & Record<string, JsonValue>;
+
 export declare type CgiGetRtspUrlResponse = ReolinkCmdResponseExt<CgiGetRtspUrlValue> & {
     cmd: "GetRtspUrl";
 };
@@ -2981,6 +3200,81 @@ export declare interface CgiGetVideoclipsParams {
     streamUrlType?: "FLV" | "RTMP" | "Playback";
 }
 
+export declare type CgiImage = {
+    channel: number;
+    bright?: number;
+    contrast?: number;
+    saturation?: number;
+    hue?: number;
+    sharpen?: number;
+    mirroring?: number;
+    flip?: number;
+} & Record<string, JsonValue>;
+
+export declare type CgiIrLights = {
+    channel: number;
+    /** "Auto" | "Off" — modern firmwares; some legacy support "On". */
+    state?: string;
+} & Record<string, JsonValue>;
+
+export declare 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>;
+
+export declare type CgiMask = {
+    channel: number;
+    enable?: number;
+    shelterList?: CgiMaskShelter[];
+} & Record<string, JsonValue>;
+
+export declare type CgiMaskShelter = {
+    enabled?: number;
+    position?: {
+        x?: number;
+        y?: number;
+        w?: number;
+        h?: number;
+    };
+} & Record<string, JsonValue>;
+
+export declare type CgiMdAlarm = {
+    channel: number;
+    type?: string;
+    enable?: number;
+    scope?: CgiMdAlarmScope;
+    sens?: CgiMdAlarmSens[];
+} & Record<string, JsonValue>;
+
+export declare type CgiMdAlarmScope = {
+    cols?: number;
+    rows?: number;
+    table?: string;
+} & Record<string, JsonValue>;
+
+export declare type CgiMdAlarmSens = {
+    id?: number;
+    beginHour?: number;
+    beginMin?: number;
+    endHour?: number;
+    endMin?: number;
+    sensitivity?: number;
+} & Record<string, JsonValue>;
+
 export declare type CgiNetPort = Record<string, JsonValue>;
 
 export declare type CgiOsd = {
@@ -2998,6 +3292,83 @@ export declare type CgiPtzPreset = {
     enable?: number;
 } & Record<string, JsonValue>;
 
+export declare type CgiPush = {
+    schedule?: {
+        channel?: number;
+        enable?: number;
+        table?: string;
+    };
+    scheduleEnable?: number;
+    enable?: number;
+} & Record<string, JsonValue>;
+
+export declare type CgiRec = {
+    schedule?: CgiRecSchedule;
+    scheduleEnable?: number;
+    enable?: number;
+    packTime?: string;
+    postRec?: string;
+} & Record<string, JsonValue>;
+
+export declare type CgiRecSchedule = {
+    channel: number;
+    enable?: number;
+    /** 7×24 weekly schedule mask, "1"/"0" per slot — present on V20+. */
+    table?: string;
+} & Record<string, JsonValue>;
+
+export declare type CgiSetAiAlarmParam = {
+    AiAlarm: CgiAiAlarm;
+};
+
+export declare type CgiSetAiCfgParam = {
+    AiCfg: CgiAiCfg;
+};
+
+export declare type CgiSetAudioAlarmParam = {
+    Audio: CgiAudioAlarm;
+};
+
+export declare type CgiSetAudioCfgParam = {
+    AudioCfg: CgiAudioCfg;
+};
+
+export declare type CgiSetAudioNoiseParam = {
+    AudioNoise: CgiAudioNoise;
+};
+
+export declare type CgiSetAutoFocusParam = {
+    AutoFocus: CgiAutoFocus;
+};
+
+export declare type CgiSetEmailParam = {
+    Email: CgiEmail;
+};
+
+export declare type CgiSetEncParam = {
+    Enc: CgiEnc;
+};
+
+export declare type CgiSetImageParam = {
+    Image: CgiImage;
+};
+
+export declare type CgiSetIrLightsParam = {
+    IrLights: CgiIrLights;
+};
+
+export declare type CgiSetIspParam = {
+    Isp: CgiIsp;
+};
+
+export declare type CgiSetMaskParam = {
+    Mask: CgiMask;
+};
+
+export declare type CgiSetMdAlarmParam = {
+    MdAlarm: CgiMdAlarm;
+};
+
 export declare type CgiSetOsdParam = {
     Osd: {
         channel: number;
@@ -3010,6 +3381,14 @@ export declare type CgiSetPirInfoParam = {
     pirInfo: CgiPirInfo;
 };
 
+export declare type CgiSetPushParam = {
+    Push: CgiPush;
+};
+
+export declare type CgiSetRecParam = {
+    Rec: CgiRec;
+};
+
 export declare type CgiSetWhiteLedParam = {
     WhiteLed: CgiWhiteLed;
 };
@@ -3355,6 +3734,34 @@ export declare interface CompositeStreamPipOptions {
     rtspTransport?: 'tcp' | 'udp';
 }
 
+/**
+ * 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).
+ */
+declare interface CompressionStream_2 {
+    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;
+}
+export { CompressionStream_2 as CompressionStream }
+
 export declare function computeDeviceCapabilities(params: {
     channel: number;
     /** Device model name/type (best-effort). Used for heuristic capability detection. */
@@ -4031,6 +4438,27 @@ export declare interface EmailTaskConfig {
     };
 }
 
+/**
+ * Encoding configuration (getEnc response).
+ * cmdId=56 (GetEnc) — payload is wrapped in `Compression`, not `Enc`.
+ */
+export declare interface EncConfig {
+    body?: {
+        Compression?: {
+            channelId?: number | undefined;
+            isNoTranslateFrame?: number | undefined;
+            mainStream?: CompressionStream_2 | undefined;
+            subStream?: CompressionStream_2 | undefined;
+            thirdStream?: CompressionStream_2 | undefined;
+            separateCfg?: {
+                encodeCfg?: number;
+                [key: string]: unknown;
+            } | undefined;
+            [key: string]: unknown;
+        };
+    };
+}
+
 export declare function encodeHeader(h: Omit<BaichuanHeader, "magic"> & {
     magic?: AnyBuffer;
 }): AnyBuffer;
@@ -4047,6 +4475,12 @@ export declare type EncryptionProtocol = {
     key: Buffer;
 };
 
+/**
+ * Prepend the XML declaration if the body doesn't already start with
+ * one. Reolink rejects payloads without it on most setX commands.
+ */
+export declare function ensureXmlHeader(xml: string): string;
+
 export declare interface Events {
     channel?: number;
     ai?: AIState;
@@ -4674,6 +5108,27 @@ export declare interface IntercomOptions {
     api: ReolinkBaichuanApi;
 }
 
+/**
+ * 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.
+ */
+export declare 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;
+        };
+    };
+}
+
 export declare const isDualLenseModel: (model: string) => boolean;
 
 export declare function isH264KeyframeAnnexB(annexB: Buffer): boolean;
@@ -4698,6 +5153,87 @@ export declare function isH265KeyframeAnnexB(annexB: Buffer): boolean;
  */
 export declare const isNvrHubModel: (model?: string) => boolean;
 
+/**
+ * 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.
+ */
+export declare 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;
+        };
+    };
+}
+
 /**
  * Check if a TCP error should trigger UDP fallback.
  * Only transport/connection errors should fallback, not authentication errors.
@@ -4751,6 +5287,33 @@ export declare type LoginResponseValue = {
 
 export declare type LogLevel = "silent" | "error" | "warn" | "info" | "debug";
 
+/**
+ * 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`.
+ */
+export declare 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;
+        };
+    };
+}
+
 /**
  * Mask UID for logging (show first 4 and last 4 characters).
  */
@@ -4980,6 +5543,19 @@ declare type NativeFrame = {
 
 export declare type NativeVideoStreamVariant = "default" | "autotrack" | "telephoto";
 
+/**
+ * Normalize human-friendly day/night labels to the camera's expected
+ * lowercase form. Mirrors reolink_aio's `SetIsp` post-processing
+ * (`& → And`, capitalize first letter).
+ */
+export 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.
+ */
+export declare function normalizeOpenClose(input: string): string;
+
 /**
  * Normalize UID string (trim and return undefined if empty).
  */
@@ -5124,6 +5700,13 @@ export declare function parseRecordingFileName(fileName: string): ParsedRecordin
 
 export declare function parseSupportXml(xml: string): SupportInfo | undefined;
 
+/**
+ * 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.
+ */
+export declare function patchNestedTag(xml: string, parent: string, child: string, value: string | number | boolean | undefined): string;
+
 export declare type PipPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right" | "center" | "top-center" | "bottom-center" | "left-center" | "right-center";
 
 /**
@@ -5146,6 +5729,17 @@ export declare 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;
     };
 }
@@ -7215,6 +7809,185 @@ export 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).
@@ -8281,6 +9054,45 @@ export 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>>>;