@camstack/types 1.2.243 → 1.2.245

package/dist/capabilities/recording-onboard.cap.d.ts

@@ -0,0 +1,705 @@
+import { z } from 'zod';
+import { DeviceType } from '../device/device-type.js';
+import { type InferNativeProvider } from './capability-definition.js';
+/**
+ * Vendor-neutral **onboard** recording + storage cap — what the CAMERA
+ * writes to the CAMERA's own card, on the camera's own schedule.
+ *
+ * This is NOT `recording.cap.ts`. That one is CamStack's recorder: our
+ * footage ledger, our storage locations, our retention. This one has a
+ * different authority — the camera's firmware — and per D62 it stores
+ * nothing of its own. Every value here is read from the camera and every
+ * write goes back to the camera; there is no CamStack-side mirror that
+ * could disagree with the device.
+ *
+ * ## One shape, two firmwares
+ *
+ * Measured 2026-09-22 against the live fleet:
+ *
+ * | fact | Hikvision (ISAPI) | Reolink (Baichuan) |
+ * | --- | --- | --- |
+ * | storage | `ContentMgmt/Storage` `<hdd>` rows: status, capacity, freeSpace (MB) | `getHddInfoList` (cmd 102): `mount`, `format`, `capacity` GB + `capacityM` MB remainder |
+ * | tracks | several (101 **and** 103 on both 1436 and 3833), each with its own schedule | one per channel |
+ * | schedule | per track, 7 `ScheduleAction` blocks: DayOfWeek + TimeOfDay range + ONE `ActionRecordingMode` | per trigger type, a 168-char weekly HOUR mask |
+ * | triggers | `CMR`, `MOTION` | `Normal`, `MD`, `people`, `vehicle`, `dog_cat`, `crossline`, `intrude`, `loitering` |
+ * | pre-record | `PreRecordTimeSeconds` | `preRecordTime` |
+ * | post-record | `PostRecordTimeSeconds` | `recordDelayTime` |
+ * | overwrite | per track `LoopEnable` | `cycle`, with `cycleList` enumerating the accepted values |
+ * | segment length | not exposed on V5.7.1 | `packageTime` (minutes) |
+ *
+ * The two schedule models look different and are the same thing in
+ * different coordinates: both answer "for this trigger, during which
+ * weekly windows does the camera record". {@link RecordWindow} is that
+ * question in one shape — Hikvision's ranges map straight onto it,
+ * Reolink's mask expands into hour-aligned windows.
+ *
+ * ## Union, not intersection
+ *
+ * **The same fields exist on every camera.** What differs per device is
+ * which VALUES that device accepts, and that is what {@link
+ * RecordingOnboardOptions} reports — a `{ readable, writable, reason }`
+ * per field plus the schedule's own limits. A control a camera cannot
+ * honour is rendered DISABLED WITH ITS REASON, never missing and never
+ * dead: disabled must not look like broken.
+ *
+ * ## Refusal by name
+ *
+ * A write a camera cannot honour is refused with a sentence the operator
+ * can read — never accepted and dropped. Both providers refuse through
+ * {@link describeOnboardRefusal}, so the vocabulary is one function and
+ * one test, not two hand-written vendor opinions.
+ *
+ * Follows the D14 `deviceConfig` archetype (see `stream-params.cap.ts`):
+ * `getOptions` advertises per-camera availability, `getStatus` (auto-
+ * injected from `status`) reports the live values, and a single
+ * `setSettings` mutation applies a partial change. No hand-written
+ * settings-contribution methods.
+ */
+/**
+ * What makes the camera start recording during a window.
+ *
+ * The union of both vendors' vocabularies. `continuous` is Hikvision's
+ * `CMR` and Reolink's `Normal`; `motion` is `MOTION` / `MD`. The
+ * object-class triggers are Reolink-only today and the smart-event ones
+ * (`lineCrossing`, `intrusion`, `loitering`) are Reolink-only on the
+ * firmwares measured — a camera that cannot record on a trigger simply
+ * does not list it in `options.schedule.triggers`, and a window naming
+ * it is REFUSED, not dropped.
+ */
+export declare const RecordTriggerSchema: z.ZodEnum<{
+    person: "person";
+    vehicle: "vehicle";
+    animal: "animal";
+    motion: "motion";
+    loitering: "loitering";
+    continuous: "continuous";
+    lineCrossing: "lineCrossing";
+    intrusion: "intrusion";
+    alarmInput: "alarmInput";
+}>;
+/**
+ * One weekly recording window: "on `day`, from `startMinute` to
+ * `endMinute`, record on `trigger`".
+ *
+ * `day` is 0 = Monday … 6 = Sunday (ISO order, which is also the order
+ * both firmwares enumerate). Minutes are local camera time since
+ * midnight; `endMinute` may be 1440, meaning end of day — that is
+ * Hikvision's literal `24:00` and Reolink's 24th mask slot, and
+ * collapsing it to 0 would turn a whole-day window into an empty one.
+ */
+export declare const RecordWindowSchema: z.ZodObject<{
+    trigger: z.ZodEnum<{
+        person: "person";
+        vehicle: "vehicle";
+        animal: "animal";
+        motion: "motion";
+        loitering: "loitering";
+        continuous: "continuous";
+        lineCrossing: "lineCrossing";
+        intrusion: "intrusion";
+        alarmInput: "alarmInput";
+    }>;
+    day: z.ZodNumber;
+    startMinute: z.ZodNumber;
+    endMinute: z.ZodNumber;
+}, z.core.$strip>;
+/** Status of one physical volume, as the camera itself describes it. */
+export declare const OnboardStorageVolumeSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        error: "error";
+        ok: "ok";
+        offline: "offline";
+        unformatted: "unformatted";
+    }>;
+    capacityMb: z.ZodNullable<z.ZodNumber>;
+    freeMb: z.ZodNullable<z.ZodNumber>;
+    writable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Whether the camera has usable onboard storage.
+ *
+ * Three states, never two: an unreadable answer is `unknown`, never
+ * folded into `absent`. Folding a failed read into "no card" is how a
+ * healthy camera gets reported as broken, and the inverse is how a
+ * camera with no card reports `ok` and then an empty list (D393).
+ */
+export declare const OnboardStorageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"present">;
+    volumes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            error: "error";
+            ok: "ok";
+            offline: "offline";
+            unformatted: "unformatted";
+        }>;
+        capacityMb: z.ZodNullable<z.ZodNumber>;
+        freeMb: z.ZodNullable<z.ZodNumber>;
+        writable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"absent">;
+    reason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"unknown">;
+    reason: z.ZodString;
+}, z.core.$strip>], "kind">;
+/**
+ * One recording track the camera exposes. Read-only.
+ *
+ * Hikvision lists several — 1436 and 3833 each list 101 AND 103, with
+ * DIFFERENT schedules (101 MOTION all day, 103 CMR 00:05–23:57) — so a
+ * cap that reported one number for "the schedule" would be lying on
+ * every Hikvision in the fleet. Reolink has exactly one per channel.
+ *
+ * There is deliberately **no `framerate`**. Hikvision declares it in the
+ * track `Description` and it is WRONG: 1436 says `2.260000 fps` while
+ * the media measures 12.55 fps. `codec` and `resolution` from the same
+ * string ARE right — those are the only two worth surfacing.
+ */
+export declare const OnboardRecordTrackSchema: z.ZodObject<{
+    id: z.ZodString;
+    enabled: z.ZodBoolean;
+    isVideo: z.ZodBoolean;
+    codec: z.ZodNullable<z.ZodString>;
+    resolution: z.ZodNullable<z.ZodString>;
+    overwriteWhenFull: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * What the camera is doing with its own storage, right now.
+ *
+ * Every scalar is nullable and **null means the camera did not answer**,
+ * never a default. A form that seeds `0` from an unanswered read invites
+ * the operator to save that 0 back onto the camera.
+ */
+export declare const RecordingOnboardStatusSchema: z.ZodObject<{
+    storage: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"present">;
+        volumes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                error: "error";
+                ok: "ok";
+                offline: "offline";
+                unformatted: "unformatted";
+            }>;
+            capacityMb: z.ZodNullable<z.ZodNumber>;
+            freeMb: z.ZodNullable<z.ZodNumber>;
+            writable: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"absent">;
+        reason: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    tracks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        enabled: z.ZodBoolean;
+        isVideo: z.ZodBoolean;
+        codec: z.ZodNullable<z.ZodString>;
+        resolution: z.ZodNullable<z.ZodString>;
+        overwriteWhenFull: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    primaryTrackId: z.ZodNullable<z.ZodString>;
+    enabled: z.ZodNullable<z.ZodBoolean>;
+    overwriteWhenFull: z.ZodNullable<z.ZodBoolean>;
+    preRecordSec: z.ZodNullable<z.ZodNumber>;
+    postRecordSec: z.ZodNullable<z.ZodNumber>;
+    segmentMinutes: z.ZodNullable<z.ZodNumber>;
+    windows: z.ZodArray<z.ZodObject<{
+        trigger: z.ZodEnum<{
+            person: "person";
+            vehicle: "vehicle";
+            animal: "animal";
+            motion: "motion";
+            loitering: "loitering";
+            continuous: "continuous";
+            lineCrossing: "lineCrossing";
+            intrusion: "intrusion";
+            alarmInput: "alarmInput";
+        }>;
+        day: z.ZodNumber;
+        startMinute: z.ZodNumber;
+        endMinute: z.ZodNumber;
+    }, z.core.$strip>>;
+    unreadableWindows: z.ZodNumber;
+    recordingToNowhere: z.ZodBoolean;
+    lastFetchedAt: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * The values a camera actually takes for a numeric field, when they are a SET
+ * rather than a range.
+ *
+ * `{min,max,step}` cannot say what these two firmwares do. Measured on 1436
+ * (I91DN) on 2026-09-22 by writing each value and reading it back:
+ *
+ * - pre-record: `0, 5, 10, 15, 20, 25, 30` and `2147483647` (INT32_MAX, the
+ *   camera's "no limit" — `-1` and `4294967295` both land on it);
+ * - post-record: `5, 10, 30, 60, 120, 300, 600`.
+ *
+ * Neither is expressible as a step: the first has a sentinel two billion away
+ * from its neighbours, the second doubles and then jumps. A range that tried
+ * would forbid values the camera takes AND permit values it silently replaces
+ * with 5 — wrong in both directions at once.
+ *
+ * `sentinel` names the member that is not a duration, so a surface can render
+ * "no limit" instead of `2147483647` seconds.
+ */
+declare const AllowedValuesSchema: z.ZodObject<{
+    values: z.ZodArray<z.ZodNumber>;
+    sentinel: z.ZodOptional<z.ZodObject<{
+        value: z.ZodNumber;
+        meaning: z.ZodEnum<{
+            disabled: "disabled";
+            "no-limit": "no-limit";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OnboardAllowedValues = z.infer<typeof AllowedValuesSchema>;
+/**
+ * Per-field availability on ONE camera.
+ *
+ * The field exists on every camera — this says whether this one can be
+ * read and whether it can be written, and `reason` says why not when
+ * either is false. The UI renders the control DISABLED with the reason
+ * rather than hiding it, so a limitation is legible instead of looking
+ * like a missing feature.
+ */
+export declare const OnboardFieldSupportSchema: z.ZodObject<{
+    readable: z.ZodBoolean;
+    writable: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** What this camera's schedule model can express. */
+export declare const OnboardScheduleSupportSchema: z.ZodObject<{
+    support: z.ZodObject<{
+        readable: z.ZodBoolean;
+        writable: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    granularityMinutes: z.ZodNumber;
+    triggers: z.ZodArray<z.ZodEnum<{
+        person: "person";
+        vehicle: "vehicle";
+        animal: "animal";
+        motion: "motion";
+        loitering: "loitering";
+        continuous: "continuous";
+        lineCrossing: "lineCrossing";
+        intrusion: "intrusion";
+        alarmInput: "alarmInput";
+    }>>;
+    supportsOverlappingTriggers: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const RecordingOnboardOptionsSchema: z.ZodObject<{
+    enabled: z.ZodObject<{
+        readable: z.ZodBoolean;
+        writable: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    overwriteWhenFull: z.ZodObject<{
+        readable: z.ZodBoolean;
+        writable: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    preRecordSec: z.ZodObject<{
+        readable: z.ZodBoolean;
+        writable: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    preRecordSecRange: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>>;
+    preRecordSecAllowed: z.ZodOptional<z.ZodObject<{
+        values: z.ZodArray<z.ZodNumber>;
+        sentinel: z.ZodOptional<z.ZodObject<{
+            value: z.ZodNumber;
+            meaning: z.ZodEnum<{
+                disabled: "disabled";
+                "no-limit": "no-limit";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    postRecordSec: z.ZodObject<{
+        readable: z.ZodBoolean;
+        writable: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    postRecordSecRange: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>>;
+    postRecordSecAllowed: z.ZodOptional<z.ZodObject<{
+        values: z.ZodArray<z.ZodNumber>;
+        sentinel: z.ZodOptional<z.ZodObject<{
+            value: z.ZodNumber;
+            meaning: z.ZodEnum<{
+                disabled: "disabled";
+                "no-limit": "no-limit";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    segmentMinutes: z.ZodObject<{
+        readable: z.ZodBoolean;
+        writable: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    segmentMinutesRange: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>>;
+    segmentMinutesAllowed: z.ZodOptional<z.ZodObject<{
+        values: z.ZodArray<z.ZodNumber>;
+        sentinel: z.ZodOptional<z.ZodObject<{
+            value: z.ZodNumber;
+            meaning: z.ZodEnum<{
+                disabled: "disabled";
+                "no-limit": "no-limit";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    schedule: z.ZodObject<{
+        support: z.ZodObject<{
+            readable: z.ZodBoolean;
+            writable: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        granularityMinutes: z.ZodNumber;
+        triggers: z.ZodArray<z.ZodEnum<{
+            person: "person";
+            vehicle: "vehicle";
+            animal: "animal";
+            motion: "motion";
+            loitering: "loitering";
+            continuous: "continuous";
+            lineCrossing: "lineCrossing";
+            intrusion: "intrusion";
+            alarmInput: "alarmInput";
+        }>>;
+        supportsOverlappingTriggers: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * A partial change. Every field optional.
+ *
+ * Unlike the other `deviceConfig` caps, a provider here does **NOT**
+ * silently ignore a field it cannot support — it refuses, by name,
+ * through {@link describeOnboardRefusal}. Silence on a recording setting
+ * is the failure D62 exists to prevent: the operator believes the camera
+ * is recording the way the form says, and it is not.
+ */
+export declare const RecordingOnboardPatchSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    overwriteWhenFull: z.ZodOptional<z.ZodBoolean>;
+    preRecordSec: z.ZodOptional<z.ZodNumber>;
+    postRecordSec: z.ZodOptional<z.ZodNumber>;
+    segmentMinutes: z.ZodOptional<z.ZodNumber>;
+    windows: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        trigger: z.ZodEnum<{
+            person: "person";
+            vehicle: "vehicle";
+            animal: "animal";
+            motion: "motion";
+            loitering: "loitering";
+            continuous: "continuous";
+            lineCrossing: "lineCrossing";
+            intrusion: "intrusion";
+            alarmInput: "alarmInput";
+        }>;
+        day: z.ZodNumber;
+        startMinute: z.ZodNumber;
+        endMinute: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type RecordTrigger = z.infer<typeof RecordTriggerSchema>;
+export type RecordWindow = z.infer<typeof RecordWindowSchema>;
+export type OnboardStorageVolume = z.infer<typeof OnboardStorageVolumeSchema>;
+export type OnboardStorage = z.infer<typeof OnboardStorageSchema>;
+export type OnboardRecordTrack = z.infer<typeof OnboardRecordTrackSchema>;
+export type OnboardFieldSupport = z.infer<typeof OnboardFieldSupportSchema>;
+export type OnboardScheduleSupport = z.infer<typeof OnboardScheduleSupportSchema>;
+export type RecordingOnboardStatus = z.infer<typeof RecordingOnboardStatusSchema>;
+export type RecordingOnboardOptions = z.infer<typeof RecordingOnboardOptionsSchema>;
+export type RecordingOnboardPatch = z.infer<typeof RecordingOnboardPatchSchema>;
+export declare const recordingOnboardCapability: {
+    readonly name: "recording-onboard";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly deviceConfig: {
+        readonly ui: {
+            readonly kind: "derived-form";
+            readonly builderId: "recording-onboard";
+            readonly tab: "recording";
+        };
+    };
+    readonly methods: {
+        readonly getOptions: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            enabled: z.ZodObject<{
+                readable: z.ZodBoolean;
+                writable: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            overwriteWhenFull: z.ZodObject<{
+                readable: z.ZodBoolean;
+                writable: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            preRecordSec: z.ZodObject<{
+                readable: z.ZodBoolean;
+                writable: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            preRecordSecRange: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+                step: z.ZodNumber;
+            }, z.core.$strip>>;
+            preRecordSecAllowed: z.ZodOptional<z.ZodObject<{
+                values: z.ZodArray<z.ZodNumber>;
+                sentinel: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    meaning: z.ZodEnum<{
+                        disabled: "disabled";
+                        "no-limit": "no-limit";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            postRecordSec: z.ZodObject<{
+                readable: z.ZodBoolean;
+                writable: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            postRecordSecRange: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+                step: z.ZodNumber;
+            }, z.core.$strip>>;
+            postRecordSecAllowed: z.ZodOptional<z.ZodObject<{
+                values: z.ZodArray<z.ZodNumber>;
+                sentinel: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    meaning: z.ZodEnum<{
+                        disabled: "disabled";
+                        "no-limit": "no-limit";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            segmentMinutes: z.ZodObject<{
+                readable: z.ZodBoolean;
+                writable: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            segmentMinutesRange: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+                step: z.ZodNumber;
+            }, z.core.$strip>>;
+            segmentMinutesAllowed: z.ZodOptional<z.ZodObject<{
+                values: z.ZodArray<z.ZodNumber>;
+                sentinel: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    meaning: z.ZodEnum<{
+                        disabled: "disabled";
+                        "no-limit": "no-limit";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            schedule: z.ZodObject<{
+                support: z.ZodObject<{
+                    readable: z.ZodBoolean;
+                    writable: z.ZodBoolean;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                granularityMinutes: z.ZodNumber;
+                triggers: z.ZodArray<z.ZodEnum<{
+                    person: "person";
+                    vehicle: "vehicle";
+                    animal: "animal";
+                    motion: "motion";
+                    loitering: "loitering";
+                    continuous: "continuous";
+                    lineCrossing: "lineCrossing";
+                    intrusion: "intrusion";
+                    alarmInput: "alarmInput";
+                }>>;
+                supportsOverlappingTriggers: z.ZodBoolean;
+            }, z.core.$strip>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly setSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            settings: z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                overwriteWhenFull: z.ZodOptional<z.ZodBoolean>;
+                preRecordSec: z.ZodOptional<z.ZodNumber>;
+                postRecordSec: z.ZodOptional<z.ZodNumber>;
+                segmentMinutes: z.ZodOptional<z.ZodNumber>;
+                windows: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    trigger: z.ZodEnum<{
+                        person: "person";
+                        vehicle: "vehicle";
+                        animal: "animal";
+                        motion: "motion";
+                        loitering: "loitering";
+                        continuous: "continuous";
+                        lineCrossing: "lineCrossing";
+                        intrusion: "intrusion";
+                        alarmInput: "alarmInput";
+                    }>;
+                    day: z.ZodNumber;
+                    startMinute: z.ZodNumber;
+                    endMinute: z.ZodNumber;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            storage: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"present">;
+                volumes: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodOptional<z.ZodString>;
+                    status: z.ZodEnum<{
+                        unknown: "unknown";
+                        error: "error";
+                        ok: "ok";
+                        offline: "offline";
+                        unformatted: "unformatted";
+                    }>;
+                    capacityMb: z.ZodNullable<z.ZodNumber>;
+                    freeMb: z.ZodNullable<z.ZodNumber>;
+                    writable: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"absent">;
+                reason: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"unknown">;
+                reason: z.ZodString;
+            }, z.core.$strip>], "kind">;
+            tracks: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                enabled: z.ZodBoolean;
+                isVideo: z.ZodBoolean;
+                codec: z.ZodNullable<z.ZodString>;
+                resolution: z.ZodNullable<z.ZodString>;
+                overwriteWhenFull: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            primaryTrackId: z.ZodNullable<z.ZodString>;
+            enabled: z.ZodNullable<z.ZodBoolean>;
+            overwriteWhenFull: z.ZodNullable<z.ZodBoolean>;
+            preRecordSec: z.ZodNullable<z.ZodNumber>;
+            postRecordSec: z.ZodNullable<z.ZodNumber>;
+            segmentMinutes: z.ZodNullable<z.ZodNumber>;
+            windows: z.ZodArray<z.ZodObject<{
+                trigger: z.ZodEnum<{
+                    person: "person";
+                    vehicle: "vehicle";
+                    animal: "animal";
+                    motion: "motion";
+                    loitering: "loitering";
+                    continuous: "continuous";
+                    lineCrossing: "lineCrossing";
+                    intrusion: "intrusion";
+                    alarmInput: "alarmInput";
+                }>;
+                day: z.ZodNumber;
+                startMinute: z.ZodNumber;
+                endMinute: z.ZodNumber;
+            }, z.core.$strip>>;
+            unreadableWindows: z.ZodNumber;
+            recordingToNowhere: z.ZodBoolean;
+            lastFetchedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "poll";
+    };
+    readonly runtimeState: z.ZodObject<{
+        storage: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"present">;
+            volumes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                status: z.ZodEnum<{
+                    unknown: "unknown";
+                    error: "error";
+                    ok: "ok";
+                    offline: "offline";
+                    unformatted: "unformatted";
+                }>;
+                capacityMb: z.ZodNullable<z.ZodNumber>;
+                freeMb: z.ZodNullable<z.ZodNumber>;
+                writable: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"absent">;
+            reason: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strip>], "kind">;
+        tracks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            enabled: z.ZodBoolean;
+            isVideo: z.ZodBoolean;
+            codec: z.ZodNullable<z.ZodString>;
+            resolution: z.ZodNullable<z.ZodString>;
+            overwriteWhenFull: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        primaryTrackId: z.ZodNullable<z.ZodString>;
+        enabled: z.ZodNullable<z.ZodBoolean>;
+        overwriteWhenFull: z.ZodNullable<z.ZodBoolean>;
+        preRecordSec: z.ZodNullable<z.ZodNumber>;
+        postRecordSec: z.ZodNullable<z.ZodNumber>;
+        segmentMinutes: z.ZodNullable<z.ZodNumber>;
+        windows: z.ZodArray<z.ZodObject<{
+            trigger: z.ZodEnum<{
+                person: "person";
+                vehicle: "vehicle";
+                animal: "animal";
+                motion: "motion";
+                loitering: "loitering";
+                continuous: "continuous";
+                lineCrossing: "lineCrossing";
+                intrusion: "intrusion";
+                alarmInput: "alarmInput";
+            }>;
+            day: z.ZodNumber;
+            startMinute: z.ZodNumber;
+            endMinute: z.ZodNumber;
+        }, z.core.$strip>>;
+        unreadableWindows: z.ZodNumber;
+        recordingToNowhere: z.ZodBoolean;
+        lastFetchedAt: z.ZodNumber;
+    }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — operator-set camera-side
+     * recording config; mutation-driven, and the storage half is the last
+     * thing the camera said about its own card.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
+};
+export type IRecordingOnboardProvider = InferNativeProvider<typeof recordingOnboardCapability>;
+export {};