@apocaliss92/nodelink-js 0.4.7 → 0.4.10

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;
@@ -1311,6 +1363,7 @@ export 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;
@@ -1330,10 +1383,20 @@ export 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;
@@ -1344,6 +1407,8 @@ export 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
      */
@@ -1369,6 +1434,7 @@ export declare class BaichuanRtspServer extends EventEmitter<{
      */
     private generateWwwAuthenticateHeader;
     private clearNoClientAutoStopTimer;
+    private clearNoFrameDeadlineTimer;
     private setFlowVideoType;
     /**
      * Start the RTSP server.
@@ -1381,6 +1447,21 @@ export 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.
      */
@@ -1481,13 +1562,34 @@ export declare 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,
@@ -1500,6 +1602,18 @@ export declare 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).
@@ -1511,6 +1625,18 @@ export declare 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;
 }
 
 export declare type BaichuanSerialPush = {
@@ -1899,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;
@@ -1963,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;
@@ -1979,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;
@@ -1995,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;
@@ -2062,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;
@@ -2734,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;
 } & {
@@ -2752,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>;
@@ -2805,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;
@@ -2833,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";
 };
@@ -2857,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";
 };
@@ -2907,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 = {
@@ -2924,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;
@@ -2936,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;
 };
@@ -3281,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. */
@@ -3415,6 +3896,8 @@ export declare function createNativeStream(api: ReolinkBaichuanApi, channel: num
     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;
@@ -3525,6 +4008,22 @@ export declare type DebugOptions = {
     };
 };
 
+/**
+ * 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).
+ */
+export declare function decideSleepInferenceTransition(input: SleepInferenceInput): SleepInferenceDecision;
+
 /**
  * Determine if H.265 should be transcoded to H.264 based on client capabilities.
  *
@@ -3939,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;
@@ -3955,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;
@@ -4217,6 +4743,7 @@ export 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>;
@@ -4228,18 +4755,45 @@ export 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;
@@ -4554,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;
@@ -4578,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.
@@ -4631,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).
  */
@@ -4780,8 +5463,99 @@ export declare interface MotionEvent {
     source?: "md" | "pir" | "unknown";
 }
 
+/**
+ * Stateful MPEG-TS muxer.  Each instance has its own continuity counters —
+ * create one per output stream (or per client connection for prebuffer replay).
+ */
+export 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;
+}
+
+/**
+ * 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);
+ */
+export declare 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;
+}
+
+declare type NativeFrame = {
+    audio: boolean;
+    data: Buffer;
+    codec: string | null;
+    sampleRate: number | null;
+    microseconds: number | null;
+    videoType?: "H264" | "H265";
+    isKeyframe?: boolean;
+};
+
 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).
  */
@@ -4926,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";
 
 /**
@@ -4948,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;
     };
 }
@@ -5218,7 +6010,17 @@ export 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;
@@ -7007,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).
@@ -8073,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>>>;
@@ -8941,6 +9961,31 @@ export declare interface SirenStatusConfig {
     };
 }
 
+export declare 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;
+}
+
+export declare 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;
+}
+
+export declare interface SleepInferencePending {
+    state: SleepState;
+    count: number;
+}
+
 export declare type SleepState = "awake" | "sleeping" | "unknown";
 
 /**