@camstack/addon-provider-reolink 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,924 @@
+export { ReolinkProviderAddon } from './addon.js';
+import * as _apocaliss92_nodelink_js from '@apocaliss92/nodelink-js';
+import { Rfc4571TcpServer, ReolinkBaichuanApi } from '@apocaliss92/nodelink-js';
+import * as _camstack_types from '@camstack/types';
+import { BaseDevice, ICameraDevice, DeviceType, DeviceFeature, DeviceContext, StreamSourceEntry, ConfigUISchemaWithValues } from '@camstack/types';
+import { z } from 'zod';
+
+/**
+ * Reolink accessory base layer — kind enum, parent-host contract,
+ * shared `BaseDevice` glue every kind-specific subclass extends.
+ *
+ * Each accessory kind (Siren, Floodlight, PIR, Autotrack) lives in its
+ * own file (`./siren.ts`, `./floodlight.ts`, …) with its own Zod
+ * schema, settings UI, and cap-registration logic — they're
+ * independent device classes that share only the parent reference and
+ * the `channel` field.
+ *
+ * Why split per file:
+ *   - Each kind owns a different subset of the lib's Baichuan
+ *     surface (`setSiren`, `setWhiteLedState`, `setPirInfo`,
+ *     `setAutotracking{,Settings}`) — keeping the dispatch in one
+ *     monolithic switch obscures the per-kind contract.
+ *   - Per-accessory settings UIs are different schemas; co-locating
+ *     each schema with its consumer makes the kind self-contained
+ *     (the file you read to understand "what does the siren expose"
+ *     is `siren.ts`, full stop).
+ *   - Adding a new kind (e.g. a future SpotlightAccessory) is one
+ *     new file + one factory case, no edits to existing kinds.
+ */
+
+/**
+ * Anything an accessory subclass needs from the parent camera. The
+ * subclass receives this rather than a direct `ReolinkCamera`
+ * reference so:
+ *   - The accessory file doesn't import the camera class (avoids
+ *     circular import the camera class doesn't need).
+ *   - Tests can stub the host with a tiny fake instead of standing
+ *     up a full camera.
+ *   - The contract is explicit: subclasses use the parent's
+ *     Baichuan socket via `ensureApi()` and read its display name
+ *     for naming.
+ */
+/**
+ * Aux-device reference exposed by each accessory to its parent.
+ * Mirrors scrypted-reolink-native's `alignAuxDevicesState` pattern:
+ * the parent camera owns the periodic align scheduling (cadence,
+ * sleep-gate, cooldown), the accessory owns the slice projection
+ * + cooldown timestamp. Single 30s background poll thus replaces N
+ * per-accessory timers AND can be sleep-gated centrally.
+ */
+interface ReolinkAccessoryRef {
+    readonly kind: string;
+    readonly id: number;
+    /** Read latest state from firmware and write into the slice. Best-
+     *  effort: per-accessory failures are logged + swallowed by the
+     *  caller (parent's alignAuxDevicesState). */
+    refreshFromAlign(): Promise<void>;
+    /** True when a recent operator setState/setMotionTrigger call
+     *  marked the cooldown — caller should skip align this round to
+     *  avoid clobbering the just-applied state with a stale firmware
+     *  read (camera takes 10s+ to reflect changes in some endpoints). */
+    isInCooldown(): boolean;
+}
+
+declare const reolinkCameraSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodDefault<z.ZodNumber>;
+    username: z.ZodDefault<z.ZodString>;
+    password: z.ZodString;
+    transport: z.ZodDefault<z.ZodEnum<{
+        tcp: "tcp";
+        udp: "udp";
+    }>>;
+    uid: z.ZodOptional<z.ZodString>;
+    udpDiscoveryMethod: z.ZodOptional<z.ZodEnum<{
+        "local-broadcast": "local-broadcast";
+        "local-direct": "local-direct";
+        remote: "remote";
+        map: "map";
+        relay: "relay";
+    }>>;
+    channel: z.ZodOptional<z.ZodNumber>;
+    deviceCache: z.ZodOptional<z.ZodObject<{
+        deviceType: z.ZodOptional<z.ZodEnum<{
+            camera: "camera";
+            "udp-camera": "udp-camera";
+            "battery-cam": "battery-cam";
+            nvr: "nvr";
+            multifocal: "multifocal";
+        }>>;
+        channelCount: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodString>;
+        serialNumber: z.ZodOptional<z.ZodString>;
+        mac: z.ZodOptional<z.ZodString>;
+        hardwareVersion: z.ZodOptional<z.ZodString>;
+        firmwareVersion: z.ZodOptional<z.ZodString>;
+        motionSnapshot: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            sensitivity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        aiSensitivitySnapshot: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            sensitivity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            stayTime: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>>;
+        aiDetectTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        imageSnapshot: z.ZodOptional<z.ZodObject<{
+            bright: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            contrast: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            saturation: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            hue: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            irCutSwap: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            dayNight: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        encSnapshot: z.ZodOptional<z.ZodObject<{
+            audio: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            mainStream: z.ZodOptional<z.ZodObject<{
+                bitRate: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                frameRate: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                videoEncType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                width: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                height: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strip>>;
+            subStream: z.ZodOptional<z.ZodObject<{
+                bitRate: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                frameRate: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                videoEncType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                width: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                height: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        maskSnapshot: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strip>>;
+        audioNoiseSnapshot: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            level: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        autoFocusSnapshot: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            supported: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$loose>>;
+    debugGeneral: z.ZodDefault<z.ZodBoolean>;
+    debugSocketLogs: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        debugRtsp: "debugRtsp";
+        traceNativeStream: "traceNativeStream";
+        traceRecordings: "traceRecordings";
+        traceTalk: "traceTalk";
+        traceEvents: "traceEvents";
+    }>>>;
+    motionEnabled: z.ZodOptional<z.ZodBoolean>;
+    motionSensitivity: z.ZodOptional<z.ZodNumber>;
+    aiPersonSensitivity: z.ZodOptional<z.ZodNumber>;
+    aiVehicleSensitivity: z.ZodOptional<z.ZodNumber>;
+    aiAnimalSensitivity: z.ZodOptional<z.ZodNumber>;
+    aiFaceSensitivity: z.ZodOptional<z.ZodNumber>;
+    aiPackageSensitivity: z.ZodOptional<z.ZodNumber>;
+    imgBright: z.ZodOptional<z.ZodNumber>;
+    imgContrast: z.ZodOptional<z.ZodNumber>;
+    imgSaturation: z.ZodOptional<z.ZodNumber>;
+    imgHue: z.ZodOptional<z.ZodNumber>;
+    imgSharpen: z.ZodOptional<z.ZodNumber>;
+    ispDayNight: z.ZodOptional<z.ZodString>;
+    ispExposure: z.ZodOptional<z.ZodString>;
+    ispHdr: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+    ispBinningMode: z.ZodOptional<z.ZodNumber>;
+    ispDayNightThreshold: z.ZodOptional<z.ZodNumber>;
+    irLightsState: z.ZodOptional<z.ZodEnum<{
+        On: "On";
+        Off: "Off";
+        Auto: "Auto";
+    }>>;
+    irLightsBrightness: z.ZodOptional<z.ZodNumber>;
+    audioVolume: z.ZodOptional<z.ZodNumber>;
+    audioTalkAndReplyVolume: z.ZodOptional<z.ZodNumber>;
+    audioVisitorVolume: z.ZodOptional<z.ZodNumber>;
+    streamMainBitRate: z.ZodOptional<z.ZodNumber>;
+    streamMainFrameRate: z.ZodOptional<z.ZodNumber>;
+    streamSubBitRate: z.ZodOptional<z.ZodNumber>;
+    streamSubFrameRate: z.ZodOptional<z.ZodNumber>;
+    streamAudioEnabled: z.ZodOptional<z.ZodBoolean>;
+    privacyMaskEnabled: z.ZodOptional<z.ZodBoolean>;
+    audioNoiseLevel: z.ZodOptional<z.ZodNumber>;
+    autoFocusEnabled: z.ZodOptional<z.ZodBoolean>;
+    intercomBlocksPerPayload: z.ZodOptional<z.ZodNumber>;
+    intercomMaxBacklogMs: z.ZodOptional<z.ZodNumber>;
+    intercomGain: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+
+/**
+ * Reolink camera device — connects via Baichuan protocol and pushes
+ * Annex-B H.264/H.265 directly to the stream broker.
+ *
+ * Lifecycle (Slice 1):
+ *   1. `publishToBroker()` registers `main` + `sub` cam streams as
+ *      `kind: 'push-annexb'` so the broker emits demand events.
+ *   2. The owning addon listens for `stream-broker.onCamStreamDemand`
+ *      events and forwards them to `onCamStreamDemand()` here.
+ *   3. We login (lazy), open a `BaichuanVideoStream` for the requested
+ *      stream, fetch the broker handle, and forward every
+ *      `videoAccessUnit` event as `pushEncodedPacket`.
+ *   4. On `onCamStreamIdle()` we stop the stream. The Baichuan socket
+ *      stays alive while at least one stream is active — battery-aware
+ *      sleep handling lands in Slice 3.
+ */
+declare class ReolinkCamera extends BaseDevice<typeof reolinkCameraSchema> implements ICameraDevice {
+    readonly type: DeviceType.Camera;
+    /**
+     * Features derived from the post-probe `feature-probe` runtime-state
+     * slice. Surfaced via `device-manager.getDevice` so any service in
+     * the cluster (stream-broker, snapshot orchestrator, pipeline-runner)
+     * can derive policy from a single source.
+     *
+     * Returns a fresh array on each read so consumers can't mutate the
+     * underlying state. The set is small (≤6 entries) so allocation cost
+     * is negligible vs the staleness of caching.
+     */
+    get features(): readonly DeviceFeature[];
+    /** Lazy-connected Baichuan API. Spans the lifetime of every active stream. */
+    private api;
+    /**
+     * Stable bound handler for `api.onSimpleEvent` — created ONCE in
+     * the class so every `onSimpleEvent` / `offSimpleEvent` call uses
+     * the SAME function reference. The lib's `simpleEventListeners`
+     * is a `Set` and dedupes by reference, so passing inline arrows
+     * `(e) => this.handleSimpleEvent(e)` on each subscribe call (as
+     * the previous code did across login / adoptApi / watchdog
+     * paths) silently accumulated multiple listeners — same event
+     * dispatched N times on the camstack side, and `offSimpleEvent`
+     * couldn't remove the old one without the original ref. Net
+     * effect was that subscriptions drifted out of sync with the
+     * camera's TCP push channel: device 15 (Daniel) went silent for
+     * 2+ hours while device 8 (battery doorbell) kept pushing
+     * normally because its short connection lifecycle naturally
+     * reset the listener set.
+     */
+    private readonly handleSimpleEventBound;
+    /**
+     * Plugin-level event-health interval — fallback layer over the
+     * lib's internal 5-minute watchdog. Mirrors Scrypted's
+     * `startEventCheck` (`baichuan-base.ts:719-783`): every 60 s,
+     * if `eventSubscriptionActive` is false on a live socket OR no
+     * event has arrived in 10 min, force a full unsub/resub cycle.
+     */
+    private eventHealthCheckTimer;
+    /**
+     * Counter of consecutive event-health re-subscribes that did NOT
+     * recover an event. Drives the log-level degradation (first one is
+     * `info` so operators see something; the long tail drops to
+     * `debug`) and the polling backoff (60s → 5min → 15min so a
+     * chronically-silent camera doesn't spam the logs every minute).
+     * Reset to 0 the moment a simpleEvent arrives.
+     */
+    private consecutiveStaleHealthChecks;
+    /** Wall-clock ms when the next health check is allowed to fire.
+     *  Used by `runEventHealthCheckTick` to short-circuit between
+     *  backoff windows without changing the underlying interval. */
+    private nextEventHealthCheckAt;
+    /** Active video streams keyed by camStreamId. */
+    private readonly active;
+    /** Login lock — concurrent demand events must not race the login flow. */
+    private loginPromise;
+    /** True once we've discovered (via getBatteryInfo) that this is a battery cam. */
+    private isBattery;
+    /** Reconnect attempt counter — drives exponential backoff. */
+    private reconnectAttempts;
+    /** Pending reconnect timer; cleared on successful reconnect or removeDevice. */
+    private reconnectTimer;
+    /**
+     * Read-through to the `battery.sleeping` runtime-state slice with
+     * a `false` default for non-battery cams (no slice). Internal
+     * shorthand — driver code uses `this.state.battery.sleeping = b` to write
+     * (proxy on `BaseDevice`); reads via this getter to avoid sprinkling
+     * `?? false` everywhere conditional logic checks the flag.
+     */
+    private get sleeping();
+    /**
+     * Wall-clock ms when `this.sleeping` last flipped. Drives a
+     * hysteresis window that filters out the lib's UDP sleep-inference
+     * flapping. The lib runs an internal `getSleepStatus` every 2s on
+     * UDP/battery cameras and emits awake/sleeping events from socket
+     * I/O patterns alone — those events do NOT reflect real firmware
+     * state, especially on battery cams with idle-disconnect where
+     * socket activity drops periodically. Without this window every
+     * inferred flip would close active streams + emit a cap event.
+     */
+    private sleepStateChangedAt;
+    /**
+     * Min time between observed sleep transitions before we honour
+     * another flip. Picked >= the lib's full UDP inference cycle
+     * (~12s on battery cams with idle-disconnect) so a single
+     * inference flap doesn't pass through. 30s is also longer than
+     * `getIdleDisconnectTimeoutMs` (default 30s in the lib), which
+     * means a transient socket close → reopen pattern can't drive
+     * us through a full state cycle either.
+     */
+    private static readonly SLEEP_HYSTERESIS_MS;
+    /** Background timer that runs the passive sleep poll (battery cams only). */
+    private sleepPollTimer;
+    /** Periodic timer driving `alignAuxDevicesState()` on wired cams.
+     *  Battery cams use the wake transition path instead. */
+    private alignAuxTimer;
+    /** Aux accessory references registered by spawned children
+     *  (siren / floodlight / pir). The parent's centralised align
+     *  method iterates these to refresh their slices on a single
+     *  cadence — replaces the old per-accessory setInterval. Mirrors
+     *  scrypted-reolink-native's `motionSiren` / `floodlight` / `pir`
+     *  field refs + their `alignAuxDevicesState` method. */
+    private readonly auxAccessoryRefs;
+    /**
+     * Reliability watchdogs (Slice 10). Both timers are armed after a
+     * successful login (`ensureApi` / `adoptApi`) and torn down on
+     * `disconnectAll` / `removeDevice`.
+     *
+     * - `pingWatchdogTimer` — every 30s `api.ping()`s the live socket;
+     *   3 consecutive failures tear down the api so the next demand
+     *   triggers a fresh login (recovers from D2C_DISC / ECONNRESET
+     *   storms that would otherwise leave a half-open socket).
+     * - `eventWatchdogTimer` — every 60s checks how long since the last
+     *   simple event; 10 minutes silent → unsubscribe + resubscribe
+     *   (plugin-level fallback to the library's own watchdog).
+     */
+    private pingWatchdogTimer;
+    private consecutivePingFailures;
+    private eventWatchdogTimer;
+    /** Wall-clock ms when the most-recent simple event arrived; 0 = none yet. */
+    private lastEventAt;
+    /** Wall-clock ms when the watchdogs first armed (used as the no-event baseline). */
+    private watchdogStartedAt;
+    /** True once we've registered the battery capability provider. */
+    private batteryRegistered;
+    /**
+     * Cam-stream ids we've successfully published to the broker. Used by
+     * `publishToBroker` to retract entries that fall out of the camera's
+     * offer between probes, and by `removeDevice` to clean up exhaustively
+     * (instead of guessing from a synthetic id list).
+     */
+    private readonly publishedStreamIds;
+    /**
+     * Transient diagnostics for the device's "Sessions" settings tab.
+     * `null` until the first refresh completes. Re-populated ONLY by
+     * `refreshSessionsSnapshot()` triggered by the operator clicking
+     * the tab's Refresh button (`_refreshSessions` sentinel patch in
+     * `applySettingsPatch`). The earlier auto-fetch on stale was
+     * removed because `getOnlineUserList` (cmd 120) wakes a sleeping
+     * battery cam — and the Settings panel polls every ~2.5s, which
+     * was keeping the doorbell awake just by leaving the tab open.
+     */
+    private sessionsSnapshot;
+    /** Single-flight guard so concurrent reads share one round-trip. */
+    private sessionsRefreshInFlight;
+    constructor(ctx: DeviceContext);
+    /**
+     * Resolved Baichuan channel for per-channel cmd_ids. Children
+     * under a Hub carry their channel in the persisted config (set
+     * during `adoptDevice`). Standalone cameras default to 0 so the
+     * pre-Hub behavior is preserved verbatim.
+     */
+    private getChannel;
+    /**
+     * `true` iff this camera is a child of a Hub. Drives the
+     * connection delegation in `ensureApi` and gates the standalone
+     * lifecycle (own subscription, watchdog, reconnect loop). The
+     * persisted `channel` field is the discriminator — adoption sets
+     * it; standalone autodetect never touches it.
+     */
+    private isHubChild;
+    /**
+     * Resolve the parent Hub via the addon's device manager. Cached
+     * lazily — the lookup is async but cheap, and the parent device
+     * doesn't change over the camera's lifetime. Returns `null` for
+     * standalone cameras.
+     */
+    private getParentHub;
+    private cachedParentHub;
+    /**
+     * Phase 3 (kernel-driven) — populate the `feature-probe` runtime
+     * state slice. Runs ONCE after `register` and BEFORE
+     * `getAccessoryChildren()`, so siren / floodlight / PIR accessory
+     * spawn sees the post-probe firmware truth. Failures are swallowed
+     * (transient login race / battery cam asleep); next `reprobe()` call
+     * retries.
+     */
+    onProbe(): Promise<void>;
+    /**
+     * Phase 5 (kernel-driven) — fired after `onProbe()` + accessory
+     * reconciliation. Publishes streams to the broker. Best-effort; the
+     * provider's `system.ready-state` listener re-publishes if the broker
+     * isn't ready yet. Skipped when the device is soft-disabled.
+     */
+    onActivate(): Promise<void>;
+    /** Debounce timestamp for the on-demand snapshot retry kicked from
+     *  `getSettingsUISchema`. Prevents the form open from spamming
+     *  refresh calls on incomplete caches (battery cam still sleeping,
+     *  legacy firmware that doesn't support some endpoints). */
+    private lastSettingsSnapshotRetryAt;
+    private static readonly SETTINGS_SNAPSHOT_RETRY_MIN_MS;
+    /** True when any settings-snapshot field that drives a UI section
+     *  is missing from the persisted cache. Drives the on-demand retry
+     *  in `getSettingsUISchema`. */
+    private hasIncompleteSettingsCache;
+    /**
+     * Probe `getVideoInput` + `getMotionAlarm` and persist into the
+     * `deviceCache` snapshots. Fires once on `onCreated`; future
+     * settings opens read straight from the persisted snapshot. Image
+     * is readonly in the UI (lib lacks `setVideoInput`); motion is
+     * writable via `setMotionAlarm` so its snapshot also drives the
+     * dispatch's known-good baseline.
+     */
+    private refreshParentSettingsSnapshot;
+    /**
+     * Declare on-camera accessory child devices the kernel should
+     * auto-spawn after `onCreated`. Each entry maps directly to a
+     * concrete accessory class via the existing `createAccessoryDevice`
+     * factory; the closure captures `this` for the child's
+     * `(ctx, parent)` constructor — accessories share the parent's
+     * Baichuan socket via `parent.ensureApi()`.
+     *
+     * Restoring an existing accessory is automatic: the kernel detects
+     * the persisted row by the deterministic stableId and skips the
+     * pre-persist step. Adding a new accessory between boots (operator
+     * enabled `hasFloodlight` via re-detection) appears on the next
+     * parent register.
+     */
+    getAccessoryChildren(): readonly _camstack_types.AccessoryChildSpec[];
+    /**
+     * Register per-device native capability providers (Slice 5+).
+     * Currently exposes `snapshot` via the Baichuan getSnapshot command;
+     * PTZ + intercom land in Slices 7 + 9 once we know the camera's
+     * abilities (see `config.features`).
+     */
+    private registerNativeCapabilities;
+    /**
+     * Idempotent guard for the PTZ provider — registered once per device
+     * instance lifetime. `removeDevice` tears down the instance, so a
+     * fresh device wires PTZ from scratch. `disconnectAll` does NOT
+     * change `hasPtz`, so we don't have to unregister/reregister around
+     * the api lifecycle.
+     */
+    private ptzRegistered;
+    /** Idempotent guard for the `ptz-autotrack` cap. Registered once
+     *  per device instance once the abilities probe flagged
+     *  `hasAutotrack`. */
+    private ptzAutotrackRegistered;
+    /** Single-flight guard for the autotrack camera refresh — back-to-back
+     *  `getStatus`/`getSettings` calls within the same tick fold into one
+     *  Baichuan round-trip. */
+    private autotrackRefreshInFlight;
+    /**
+     * Single-flight guard for snapshot fetches (Slice 10). When two
+     * consumers hit `getSnapshot` concurrently we issue ONE Baichuan
+     * request and let both await its result — saves a doubled wake on
+     * battery cams and halves load for regular ones. Pattern mirrors
+     * `takePictureInFlight` in scrypted-reolink-native.
+     */
+    private snapshotInFlight;
+    /**
+     * Map a nodelink `BatteryInfo` push payload into the camstack
+     * `BatteryStatus` shape (Slice 13). `sleeping` honours the runtime
+     * `this.sleeping` flag — the BatteryInfo's own `sleeping` field is
+     * present on some firmwares but absent on others, so the runtime
+     * tracker is more reliable.
+     */
+    private mapBatteryInfo;
+    /**
+     * Register the battery cap provider on battery-flagged devices
+     * (Slice 13). The wrapper `snapshot.addon.ts` calls
+     * `batteryCapability.getStatus({deviceId})` to decide whether to
+     * serve cached frames instead of waking the camera; without this
+     * provider the wrapper assumes "awake" and would wake the cam.
+     */
+    private registerBatteryIfSupported;
+    private refreshBatteryFromApi;
+    /**
+     * Decide whether to honour a sleep-state transition. Returns
+     * `false` when the lib's UDP inference is still inside the
+     * hysteresis window (8s by default) so we don't flap. The first
+     * transition AFTER an api login / restart is always honoured —
+     * no prior-flip timestamp gating it.
+     *
+     * @param next - the desired next value of `this.sleeping`
+     * @returns `true` if the caller should commit the new state
+     */
+    private acceptSleepingTransition;
+    private updateBatteryCache;
+    /**
+     * Battery cams require an explicit wake before cmd_id 109 will
+     * answer reliably. The lib documents this pattern in
+     * `predownloadRecordingMp4` (`ensureAwake` → `wakeUp` →
+     * operation → retry with longer wait on failure). `getSnapshot`
+     * itself only re-`login()`s, which over BCUDP can complete before
+     * the camera firmware is fully up — the snapshot then times out
+     * because the video subsystem isn't ready yet.
+     *
+     * Probe live testing (scripts/probe-reolink-snapshot.mts) confirmed:
+     *   awake state: getSnapshot in ~1s
+     *   wakeUp + getSnapshot: ~2.7s total (wakeUp 1.7s + snapshot 1s)
+     * The added latency is the cost we pay to actually return a frame
+     * instead of timing out.
+     */
+    /**
+     * Refresh the diagnostic Sessions snapshot from the live Baichuan
+     * api: who's currently logged into the camera, how many sockets we
+     * hold open, and whether the camera is currently rate-limiting our
+     * reconnect attempts. Single-flight (concurrent calls reuse the same
+     * round-trip) and tolerant of partial failures — each lib call's
+     * error is recorded but does not poison the rest of the snapshot.
+     *
+     * Side-effect: writes `this.sessionsSnapshot`. Best-effort: when
+     * `ensureApi()` fails (camera offline, sleeping battery cam) the
+     * snapshot still updates with a populated `error` field plus a
+     * fallback `socketPool` block so the operator sees the failure
+     * surface instead of stale data.
+     */
+    private refreshSessionsSnapshot;
+    /**
+     * Build the contents of the "Sessions" tab from `this.sessionsSnapshot`.
+     * Always returns at least the Refresh button so the operator can force
+     * a fetch when the snapshot is empty (cold start) or stale beyond the
+     * displayed timestamp. Section + tab layout details mirror the rest
+     * of the device-settings UI (one card per logical block).
+     *
+     * NO auto-fetch. `getOnlineUserList` (cmd 120) wakes a sleeping
+     * battery cam, and the Settings panel polls every ~2.5s — auto-
+     * triggering on stale would keep the doorbell awake indefinitely
+     * just because the operator left the tab open. The operator's
+     * explicit "Refresh" click is the sole trigger; it lands as
+     * `_refreshSessions` action sentinel through `applySettingsPatch`.
+     */
+    private buildSessionsTabSections;
+    private fetchSnapshotWithSingleFlight;
+    /**
+     * Idempotency for the doorbell provider. The cap is registered once
+     * per device-instance lifetime — `removeDevice` rebuilds the device
+     * from scratch.
+     */
+    private doorbellRegistered;
+    /** Push counter mirrored into the doorbell cap status. */
+    private doorbellPressCountSinceStart;
+    private doorbellLastPressedAt;
+    private registerDoorbellIfSupported;
+    /** One-time registration guard for `intercom` cap. */
+    private intercomRegistered;
+    /**
+     * Active intercom orchestrator. The `intercom` cap is
+     * `singleton`-mode device-scoped — at most one talk session is
+     * open at a time per camera (mirrors how Reolink's own UI
+     * behaves). The orchestrator owns the WebRTC peer + audio-codec
+     * decode session + Reolink talk channel for that one active
+     * session; `null` when idle.
+     */
+    private intercomOrchestrator;
+    /**
+     * Register the `intercom` cap when the camera advertises two-way
+     * audio support. Server-WebRTC-shaped: `startSession` returns an
+     * SDP offer, `handleAnswer` applies the browser's response, the
+     * orchestrator pumps Opus RTP through the `audio-codec` cap (Opus
+     * → PCM s16le @ camera rate, with resampling) and feeds the PCM
+     * into `ReolinkIntercomSession` for IMA ADPCM encoding + transport
+     * onto the camera's dedicated talk channel.
+     *
+     * The `audio-codec` cap is REQUIRED — without it (no audio-codec
+     * addon installed) intercom can't function. We register the cap
+     * regardless and surface the missing dep as a clear error from
+     * `startSession`; this preserves the "cap visible in bindings/docs"
+     * UX without falsely claiming readiness when audio decode isn't
+     * available.
+     */
+    private registerIntercomIfSupported;
+    /**
+     * Resolve the `audio-codec` cap router off `ctx.api`. Throws a
+     * clear error when the cap isn't mounted (no audio-codec addon
+     * installed) so the operator gets actionable feedback at
+     * `startSession` time rather than a generic dispatch failure.
+     *
+     * The shape we surface is the narrow `IntercomAudioCodecApi` used
+     * by the orchestrator — we don't expose the full router because
+     * intercom only needs decode + push + pull + close.
+     */
+    private resolveAudioCodecApi;
+    /**
+     * Battery-cam pre-wake hook for the intercom orchestrator. Mirrors
+     * scrypted-reolink-native's `intercom.ts:90-106`: ask the lib for
+     * the current sleep status (passive — no traffic), and if the cam
+     * is asleep issue an explicit `wakeUp(channel, {waitAfterWakeMs:2000})`
+     * + a 1s settle delay before letting the talk-session handshake
+     * fire. Without this, the handshake against a sleeping UDP/battery
+     * cam silently times out and the operator gets a generic "talk
+     * session open failed" error.
+     */
+    private wakeForIntercom;
+    /**
+     * Translate a Reolink Baichuan `doorbell` simple-event into a
+     * camstack-side doorbell press: bump the counters, emit the cap
+     * event, and bridge to the typed `EventCategory.DoorbellOnPressed`
+     * so non-cap consumers (UI toast, notifier) can subscribe without
+     * holding a cap reference.
+     */
+    private emitDoorbellPressed;
+    /**
+     * Register the `ptz-autotrack` cap when the abilities probe flagged
+     * `hasAutotrack`. The cap surface (`getStatus` / `setEnabled` /
+     * `getSettings` / `setSettings`) maps directly onto the lib's
+     * `getAutotracking` / `setAutotracking` / `setAutotrackingSettings`
+     * Baichuan commands.
+     *
+     * Source of truth is `runtimeState['ptz-autotrack']` — the kernel
+     * persists this slice across restarts and validates it against the
+     * cap's runtimeState schema. The four cap methods become trampolines:
+     * read from the slice, refresh from the camera when stale, write
+     * back to the slice. No private cache fields, no config-blob dance.
+     */
+    private registerPtzAutotrackIfSupported;
+    private registerPtzIfSupported;
+    /**
+     * Translate normalized (-1..1) pan/tilt/zoom to one or more discrete
+     * Baichuan PTZ commands. Camstack ptz uses ONVIF-style continuous
+     * motion vectors; Reolink Baichuan needs discrete directional
+     * commands (Left/Right/Up/Down/ZoomIn/ZoomOut). Magnitudes map to
+     * speed (0–63 typical). Continuous=true issues 'start' (camera moves
+     * until next 'stop'); continuous=false issues 'start' followed by an
+     * autoStop after a short window so a single tap of an arrow key
+     * results in a tiny nudge.
+     */
+    private runPtz;
+    getStreamSources(): Promise<readonly StreamSourceEntry[]>;
+    private channelCount;
+    /**
+     * Publish Reolink streams to the stream-broker. Reolink cameras
+     * typically expose the same logical channel over THREE containers —
+     * native Baichuan push, RTSP, RTMP. We publish all of them so the
+     * operator can pick any in the assignment UI; native streams are
+     * `autoEligible: true` (the recommended path) and RTSP / RTMP mirrors
+     * are `autoEligible: false` (selectable, but never the default).
+     *
+     * Stream IDs are kind-prefixed (`native:main`, `rtsp:main`, …) so the
+     * broker treats them as distinct rows even though they share the
+     * same camera profile.
+     *
+     * The lib's `buildVideoStreamOptions()` is the single source of truth
+     * for the camera's offer — it returns nativeStreams + rtspStreams +
+     * rtmpStreams with full metadata (width/height/frameRate/bitRate/
+     * videoEncType) in a single call. We resolve it lazily on every
+     * publish instead of caching it in `deviceCache`: the cache layer
+     * was a constant source of bugs (transient probe failures wiped
+     * the persisted entry, leaving the device stuck with `desired.size === 0`
+     * until manual recovery). Calling the lib directly is cheap (it
+     * caches internally) and self-healing across firmware upgrades.
+     *
+     * Re-publish is idempotent — the broker keys entries by
+     * `(deviceId, camStreamId)`. Streams from a previous publish that no
+     * longer appear in the latest snapshot are explicitly retracted so
+     * the broker registry stays in sync.
+     *
+     * Native streams need a per-(channel, profile) RFC 4571 TCP server on
+     * loopback — handed off to `ensureRfc4571Server`, which uses the lib's
+     * shared-server pool (`sharedRfc4571Servers` keyed by `(deviceId,
+     * channel, profile, variant, …)`). Without `deviceId` the lib falls
+     * back to the unshared path: every call opens a fresh
+     * BaichuanVideoStream on the same control socket, and 3 concurrent
+     * stream probes overload the camera's session table → ECONNRESET.
+     * With it, main + sub + ext coexist freely.
+     */
+    publishToBroker(): Promise<void>;
+    private publishOne;
+    /**
+     * Materialize the upstream rfc4571 streaming session for one
+     * camStreamId on demand. Called from the
+     * `StreamBrokerOnRequestStreamSourceRefresh` listener when the broker
+     * is about to dial a `lazy:rfc4571:` placeholder URL (or when an
+     * established session went stale and the lib's loopback teardown ran).
+     *
+     * The flow:
+     *   1. Parse camStreamId → (channel, profile)
+     *   2. Open the rfc4571 server via `ensureRfc4571Server`. THIS is the
+     *      single point where a new TCP session to the NVR is opened —
+     *      `publishToBroker` no longer triggers it.
+     *   3. Re-publish the broker entry with the real `tcp://...` URL +
+     *      the lib's accurate SDP (the lib has SPS/PPS now). The broker
+     *      picks up the fresh URL on its next `sourceProvider()` call.
+     *
+     * Idempotent: subsequent calls reuse the cached server when still
+     * listening; if the lib idle-tore-down between calls we recreate.
+     */
+    materializeStreamSocket(camStreamId: string): Promise<void>;
+    removeDevice(): Promise<void>;
+    /**
+     * Spin up a loopback RFC 4571 TCP server for one (channel, profile)
+     * tuple if we don't already have one. Returns the running server with
+     * its `host`/`port`/`sdp`/`username`/`password`. Idempotent — repeat
+     * calls return the existing instance.
+     *
+     * The lib's server manages the underlying Baichuan socket lifecycle
+     * (open on first client connect, close on idle teardown), which keeps
+     * battery cams asleep until a real consumer pulls the stream.
+     */
+    ensureRfc4571Server(camStreamId: string, channel: number, profile: 'main' | 'sub' | 'ext'): Promise<Rfc4571TcpServer | null>;
+    /** Map a camStreamId back to its broker profile (for `ActiveStream.profile`). */
+    private profileForCamStream;
+    /**
+     * Adapt the camstack scoped logger to the `Console` shape the lib expects.
+     * Drops the structured `meta` object — the lib only formats the message,
+     * not our hierarchical log fields.
+     */
+    private libLoggerAdapter;
+    /**
+     * Close every running RFC 4571 server (Slice 9). Used when the camera
+     * reports sleep / device removal. Keeps the api alive so we still
+     * receive `awake` events; the servers will be re-spawned the next
+     * time `publishToBroker` runs (after restore / reconnect).
+     */
+    private closeActiveStreams;
+    /**
+     * Periodic passive sleep-status poll (Slice 9, battery cams only).
+     * Calls `api.getSleepStatus()` which inspects recent socket I/O —
+     * no network traffic emitted, no risk of waking the camera. Used to
+     * reconcile our `this.sleeping` flag when push events miss the
+     * `sleeping`/`awake` transition (firmware quirks, NAT timeouts).
+     */
+    private startSleepPoll;
+    private stopSleepPoll;
+    /** Implements `ReolinkAccessoryHost.registerAccessoryChild`. Called
+     *  from each accessory's constructor. Idempotent — re-registering the
+     *  same kind overwrites the prior ref (covers a replay-on-restart
+     *  scenario where the parent ctor lands before the child ctor of an
+     *  already-spawned accessory). */
+    registerAccessoryChild(ref: ReolinkAccessoryRef): void;
+    /** Pull-once refresh of every registered aux accessory's slice.
+     *  Best-effort: per-accessory failures are logged + swallowed by the
+     *  individual `refreshFromAlign` impls; this loop never throws. */
+    private alignAuxDevicesState;
+    /** Start periodic align for wired cams. No-op for battery cams (wake
+     *  path handles it). Idempotent. */
+    private startAlignAuxPolling;
+    private stopAlignAuxPolling;
+    /**
+     * Shared wake-transition handler invoked by both the simpleEvent
+     * `awake` push (canonical fast path) and the sleep poll's
+     * `sleeping → awake` flip (backstop). Mirrors Scrypted's
+     * `updateSleepingState`'s wake branch (camera.ts:3543-3560) — fan
+     * out the refreshes that depend on the camera being responsive:
+     *  - aux accessories (siren/floodlight/PIR) re-read their
+     *    firmware state via `alignAuxDevicesState('wake')`
+     *  - parent settings snapshot (image / motion / AI / enc / mask /
+     *    audioNoise / autoFocus) re-reads via
+     *    `refreshParentSettingsSnapshot()` so the Settings UI shows
+     *    camera-current values instead of the snapshot taken before
+     *    the cam went to sleep.
+     * Both calls are best-effort; per-call failures land in their own
+     * debug logs and never break the wake-transition flow.
+     */
+    private onWakeTransition;
+    private static readonly PING_INTERVAL_MS;
+    private static readonly PING_MAX_FAILURES;
+    private static readonly EVENT_CHECK_INTERVAL_MS;
+    private static readonly EVENT_STALE_THRESHOLD_MS;
+    /**
+     * Arm the connection-liveness ping watchdog and the event-watchdog.
+     * Battery cams skip the ping watchdog — they keep `setIdleDisconnect=true`
+     * so the api intentionally goes silent and a ping would just wake the
+     * camera and burn battery for no signal.
+     *
+     * Idempotent: re-arming clears prior timers first so we don't end up
+     * with parallel watchdogs after a reconnect cycle.
+     */
+    private startWatchdogs;
+    private stopWatchdogs;
+    private runPingWatchdog;
+    private runEventWatchdog;
+    /**
+     * Subscribe (or re-subscribe) `handleSimpleEventBound` against
+     * the Baichuan API. Single-source-of-truth for the listener
+     * lifecycle:
+     *
+     *   1. Always `offSimpleEvent(handleSimpleEventBound)` first —
+     *      Set-dedup is a no-op on the first call (handler isn't
+     *      registered yet) but on re-subscribes it cleanly removes
+     *      the prior registration so the lib's listener Set never
+     *      grows past one entry per device.
+     *   2. Verify the connection is ready (socket + login). The
+     *      lib's own `ensureSimpleEventSubscribed` checks this too,
+     *      but failing fast at the camstack layer keeps the
+     *      re-subscribe attempts in lock-step with the connection
+     *      state we observe — important for the `event-health`
+     *      interval that fires every 60s.
+     *   3. Register via `onSimpleEvent(handleSimpleEventBound)`.
+     *      Lib starts/refreshes its own subscribe + 5min watchdog.
+     *
+     * Mirrors `subscribeToEventsInternal` in Scrypted's
+     * `baichuan-base.ts:837-888` — same pattern, same rationale.
+     */
+    private resubscribeSimpleEvents;
+    /**
+     * Plugin-level event-health watchdog. Fires every 60s while the
+     * api is alive. Two recovery paths:
+     *
+     *   - If we've never received an event AND the watchdog baseline
+     *     is older than EVENT_STALE_THRESHOLD_MS, force a full
+     *     re-subscribe. Catches "subscribe call succeeded but the
+     *     camera silently rejected the registration" — the lib's
+     *     own watchdog uses the same trigger but a re-arm at the
+     *     plugin level recovers from cases where the lib's internal
+     *     state has drifted.
+     *   - If the connection went down between our `runEventWatchdog`
+     *     ticks (every 30s by default), the next tick of THIS check
+     *     re-subscribes the moment the socket comes back up.
+     */
+    private startEventHealthCheck;
+    private stopEventHealthCheck;
+    /** Stop every active stream and close the Baichuan API. */
+    disconnectAll(): Promise<void>;
+    getSettingsUISchema(): ConfigUISchemaWithValues;
+    applySettingsPatch(patch: Record<string, unknown>): Promise<void>;
+    /**
+     * Optionally inject an already-logged-in Baichuan api — used by
+     * `onCreateDevice` to reuse the api instance returned by
+     * `autoDetectDeviceType` (Slice 15 socket reuse). Skips the next
+     * connect cycle entirely.
+     */
+    adoptApi(api: ReolinkBaichuanApi): void;
+    /**
+     * Expose the lazy-login Baichuan API to accessory children. The
+     * children share the parent's socket and credentials — there's no
+     * separate auth flow per accessory. `ReolinkAccessory` calls this
+     * inside its `applyOn` / `fetchOn` to reach the camera firmware.
+     */
+    /** Implements `ReolinkAccessoryHost.isBatteryCam` so spawned
+     *  accessory children skip background polling on a sleeping
+     *  battery cam (Baichuan polls on a sleeping camera return 400 +
+     *  drain the battery). Reads from the runtime feature-probe slice
+     *  populated during `onProbe()`; falls back to false when the probe
+     *  hasn't completed yet. */
+    isBatteryCam(): boolean;
+    /** Implements `ReolinkAccessoryHost.isSleeping`. Reads the canonical
+     *  source of truth — the `battery.sleeping` runtime-state slice — so
+     *  hub-children (whose simpleEvents are routed in by the Hub) and
+     *  top-level battery cams (whose own subscription / sleep poll write
+     *  the slice) share one signal. Always returns `false` for non-
+     *  battery cams (`this.sleeping` getter falls back to `false` when
+     *  the slice is absent). */
+    isSleeping(): boolean;
+    ensureApi(): Promise<ReolinkBaichuanApi>;
+    /**
+     * Bridge Reolink hardware events to the camstack event bus. Mirrors
+     * the dispatch shape of scrypted-reolink-native's `onSimpleEvent`
+     * (`camera.ts:1979-2033`): online and sleeping are TWO ORTHOGONAL
+     * axes, each driven exclusively by their own firmware push events.
+     *
+     * - 'motion' + AI types (people, vehicle, animal, face, package):
+     *   emit `EventCategory.MotionOnMotionChanged` (`source: 'onboard'`)
+     *   so the runner's phase machine reacts via `reportMotion`. The
+     *   runner is the sole writer of the `motion` runtime-state slice
+     *   (no direct slice writes here — keeps onboard symmetric with the
+     *   analyzer path). AI subtype also lands on
+     *   `EventCategory.DetectionCameraNative`.
+     * - 'awake' / 'sleeping': emit DeviceAwake / DeviceSleeping. Battery
+     *   power-state only — does NOT touch online state.
+     * - 'online' / 'offline': emit DeviceOnline / DeviceOffline + flip
+     *   `this.online`. The ONLY emit site for these — socket close,
+     *   reconnect, RFC4571 idle teardown all leave online state alone.
+     * - 'battery': refresh cache, emit cap event.
+     * - 'doorbell', 'daynight', 'other': informational debug log only.
+     */
+    /** Reusable event-source identity for every emit on this device. */
+    private eventSource;
+    /**
+     * Build the `DebugOptions` blob forwarded to `ReolinkBaichuanApi`'s
+     * constructor. Mirrors Scrypted's `getBaichuanDebugOptions` at
+     * `camera.ts:1778-1786`. Returns `undefined` when no flags are set
+     * so the lib falls back to its own defaults instead of an empty
+     * object override.
+     */
+    private getBaichuanDebugOptions;
+    /**
+     * Public entry point for simpleEvent dispatch. Used both by the
+     * camera's own subscription (`handleSimpleEventBound`) when the
+     * camera holds its own Baichuan socket AND by `ReolinkHub.routeSimpleEvent`
+     * when the camera lives under a Hub and inherits the parent's
+     * single subscription.
+     */
+    handleSimpleEvent(event: _apocaliss92_nodelink_js.ReolinkSimpleEvent): void;
+    /**
+     * Probe device abilities + channel count and persist into the camera
+     * config. Best-effort — unsupported camera firmwares may return
+     * partial data; we record what we can and skip the rest.
+     *
+     * Writes the result into the `feature-probe` runtime-state slice
+     * (the canonical store for hasPtz/hasIntercom/etc) and persists
+     * channelCount + deviceType in the config blob (so the camera
+     * lifecycle has them before next-boot rehydrate completes).
+     *
+     * Called by the kernel via `onProbe()` once after register, and by
+     * `reprobe()` on demand.
+     */
+    private probeAndPersistFeatures;
+    /**
+     * Pull `getInfo` and patch the device-meta `metadata` blob with the
+     * resolved manufacturer / model / firmware / hardware / serial / uid.
+     * Idempotent — `setMetadata` shallow-merges and emits a change event
+     * only when at least one field flipped, so re-running the probe on
+     * every reconnect doesn't churn the bus.
+     */
+    private populateMetadataFromFirmware;
+    /**
+     * Tear down the current API and schedule a reconnect with exponential
+     * backoff. Active streams are cleared — when the broker re-issues
+     * demand events on next consumer activity, ensureApi() reconnects
+     * lazily and the demand path re-arms BaichuanVideoStream instances.
+     *
+     * **Battery-camera path**: when the camera is sleeping (or already
+     * believed to be sleeping), a `close`/`error` from the Baichuan
+     * client is the EXPECTED steady state — the lib disconnects the
+     * idle UDP socket on its own, the camera is asleep, and there is
+     * nothing to reconnect to. Aggressively reconnecting in that state
+     * is what was waking up the doorbell every ~60 s in production
+     * logs. Mirror Scrypted's reolink-native handler: drop the api
+     * reference, but DO NOT schedule a reconnect timer. The next
+     * `awake` push (or a snapshot demand from the operator) will
+     * lazily call `ensureApi()` and re-establish the client.
+     */
+    private scheduleReconnect;
+}
+
+export { ReolinkCamera, reolinkCameraSchema };