@camstack/types 0.1.39 → 0.1.41

package/dist/capabilities/privacy-mask.cap.d.ts

@@ -0,0 +1,207 @@
+import { z } from 'zod';
+import { type InferNativeProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Privacy mask = up to `maxRegions` SHAPES the camera blanks out (NOT a
+ * cell grid). Reolink `<shelterList>` zones are rectangles; Hikvision
+ * ISAPI `<RegionCoordinatesList>` zones are free polygons (this camera:
+ * exactly 4 vertices, not necessarily axis-aligned). The cap composes the
+ * shared rect|polygon subset of the MaskShape vocabulary. All coords are
+ * normalized 0..1 (top-left origin).
+ */
+/** A privacy-mask region's geometry — rectangle or free polygon. */
+export declare const PrivacyMaskShapeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"rect">;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"polygon">;
+    points: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "kind">;
+/** A single privacy-mask zone. */
+export declare const PrivacyMaskRegionSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    enabled: z.ZodBoolean;
+    shape: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"rect">;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"polygon">;
+        points: z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+/** Current on-camera privacy-mask state — master enable + zones. */
+export declare const PrivacyMaskStatusSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    regions: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        enabled: z.ZodBoolean;
+        shape: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"rect">;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"polygon">;
+            points: z.ZodArray<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>], "kind">;
+    }, z.core.$strip>>;
+    lastFetchedAt: z.ZodNumber;
+}, z.core.$strip>;
+/** Per-camera availability. */
+export declare const PrivacyMaskOptionsSchema: z.ZodObject<{
+    maxRegions: z.ZodNumber;
+    supportedShapes: z.ZodArray<z.ZodEnum<{
+        polygon: "polygon";
+        rect: "rect";
+        grid: "grid";
+        line: "line";
+    }>>;
+    polygonVertices: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Partial change — every field optional. */
+export declare const PrivacyMaskPatchSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    regions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        enabled: z.ZodBoolean;
+        shape: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"rect">;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"polygon">;
+            points: z.ZodArray<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>], "kind">;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PrivacyMaskShape = z.infer<typeof PrivacyMaskShapeSchema>;
+export type PrivacyMaskRegion = z.infer<typeof PrivacyMaskRegionSchema>;
+export type PrivacyMaskStatus = z.infer<typeof PrivacyMaskStatusSchema>;
+export type PrivacyMaskOptions = z.infer<typeof PrivacyMaskOptionsSchema>;
+export type PrivacyMaskPatch = z.infer<typeof PrivacyMaskPatchSchema>;
+export declare const privacyMaskCapability: {
+    readonly name: "privacy-mask";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly deviceConfig: {
+        readonly ui: {
+            readonly kind: "widget";
+            readonly widgetId: "host/privacy-mask-grid";
+            readonly tab: "image";
+            readonly label: "Privacy Mask";
+        };
+    };
+    readonly methods: {
+        readonly getOptions: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            maxRegions: z.ZodNumber;
+            supportedShapes: z.ZodArray<z.ZodEnum<{
+                polygon: "polygon";
+                rect: "rect";
+                grid: "grid";
+                line: "line";
+            }>>;
+            polygonVertices: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly setMask: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            patch: z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                regions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodNumber;
+                    enabled: z.ZodBoolean;
+                    shape: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"rect">;
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                        width: z.ZodNumber;
+                        height: z.ZodNumber;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"polygon">;
+                        points: z.ZodArray<z.ZodObject<{
+                            x: z.ZodNumber;
+                            y: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>], "kind">;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            regions: z.ZodArray<z.ZodObject<{
+                id: z.ZodNumber;
+                enabled: z.ZodBoolean;
+                shape: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"rect">;
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    width: z.ZodNumber;
+                    height: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"polygon">;
+                    points: z.ZodArray<z.ZodObject<{
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>], "kind">;
+            }, z.core.$strip>>;
+            lastFetchedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "poll";
+    };
+    readonly runtimeState: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        regions: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            enabled: z.ZodBoolean;
+            shape: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"rect">;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"polygon">;
+                points: z.ZodArray<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>], "kind">;
+        }, z.core.$strip>>;
+        lastFetchedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IPrivacyMaskProvider = InferNativeProvider<typeof privacyMaskCapability>;
+//# sourceMappingURL=privacy-mask.cap.d.ts.map

package/dist/capabilities/privacy-mask.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"privacy-mask.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/privacy-mask.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AACxG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAQrD;;;;;;;GAOG;AAEH,oEAAoE;AACpE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;2BAGjC,CAAA;AAEF,kCAAkC;AAClC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;iBAMlC,CAAA;AAEF,oEAAoE;AACpE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;iBAKlC,CAAA;AAEF,+BAA+B;AAC/B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;iBAOnC,CAAA;AAEF,6CAA6C;AAC7C,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;iBAGjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBO,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/dist/capabilities/ptz-autotrack.cap.d.ts

@@ -64,6 +64,7 @@ export type PtzAutotrackRuntimeState = z.infer<typeof PtzAutotrackRuntimeStateSc
 export declare const ptzAutotrackCapability: {
     readonly name: "ptz-autotrack";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly deviceConfig: {

package/dist/capabilities/ptz-autotrack.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ptz-autotrack.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/ptz-autotrack.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAwCrD,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;iBAkBnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;iBAGzC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;QAS/B;;;;WAIG;;;;;;;;;;;;;;;;QAKH;;;;WAIG;;;;;QAMH;;;;;;WAMG;;;;;;;;QAKH;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoBL;;;;;;;OAOG;;;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA"}
+{"version":3,"file":"ptz-autotrack.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/ptz-autotrack.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAwCrD,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;iBAkBnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;iBAGzC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;QAU/B;;;;WAIG;;;;;;;;;;;;;;;;QAKH;;;;WAIG;;;;;QAMH;;;;;;WAMG;;;;;;;;QAKH;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoBL;;;;;;;OAOG;;;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/capabilities/ptz.cap.d.ts

@@ -37,6 +37,7 @@ declare const PtzOptionsSchema: z.ZodObject<{
 export declare const ptzCapability: {
     readonly name: "ptz";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly deviceConfig: {

package/dist/capabilities/ptz.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ptz.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/ptz.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD,QAAA,MAAM,eAAe;;;iBAAiD,CAAA;AACtE,QAAA,MAAM,iBAAiB;;;;iBAAoE,CAAA;AAC3F,QAAA,MAAM,oBAAoB;;;;;iBAKxB,CAAA;AAEF;;2DAE2D;AAC3D,QAAA,MAAM,eAAe;;;;;iBAAuD,CAAA;AAE5E,8DAA8D;AAC9D,QAAA,MAAM,gBAAgB;;;;;;;iBAUpB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoDtB;;;;;WAKG;;;;;;;;QAKH;mDAC2C;;;;;;;;;;;;;;;CAWN,CAAA;AAEzC,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,OAAO,aAAa,CAAC,CAAA;AAC9D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,CAAA"}
+{"version":3,"file":"ptz.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/ptz.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD,QAAA,MAAM,eAAe;;;iBAAiD,CAAA;AACtE,QAAA,MAAM,iBAAiB;;;;iBAAoE,CAAA;AAC3F,QAAA,MAAM,oBAAoB;;;;;iBAKxB,CAAA;AAEF;;2DAE2D;AAC3D,QAAA,MAAM,eAAe;;;;;iBAAuD,CAAA;AAE5E,8DAA8D;AAC9D,QAAA,MAAM,gBAAgB;;;;;;;iBAUpB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqDtB;;;;;WAKG;;;;;;;;QAKH;mDAC2C;;;;;;;;;;;;;;;CAWN,CAAA;AAEzC,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,OAAO,aAAa,CAAC,CAAA;AAC9D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,CAAA"}

package/dist/capabilities/reboot.cap.d.ts

@@ -18,6 +18,7 @@ import { DeviceType } from '../device/device-type.js';
 export declare const rebootCapability: {
     readonly name: "reboot";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Camera, DeviceType.Sensor, DeviceType.Switch];
     readonly methods: {

package/dist/capabilities/reboot.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reboot.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/reboot.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;CAYY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA"}
+{"version":3,"file":"reboot.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/reboot.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;CAaY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

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

@@ -1,43 +1,249 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
-import { DeviceType } from '../device/device-type.js';
-declare const SegmentSchema: z.ZodObject<{
-    id: z.ZodString;
-    startTs: z.ZodNumber;
-    endTs: z.ZodNumber;
-    durationSec: z.ZodNumber;
-    sizeBytes: z.ZodOptional<z.ZodNumber>;
+export declare const RecordingStatusSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    enabled: z.ZodBoolean;
+    activeMode: z.ZodEnum<{
+        off: "off";
+        continuous: "continuous";
+    }>;
+    nodeId: z.ZodString;
+    storageBytes: z.ZodNumber;
 }, z.core.$strip>;
+export type RecordingStatus = z.infer<typeof RecordingStatusSchema>;
+export declare const RecordingRangeSchema: z.ZodObject<{
+    profile: z.ZodString;
+    startMs: z.ZodNumber;
+    endMs: z.ZodNumber;
+}, z.core.$strip>;
+export declare const RecordingAvailabilitySchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    ranges: z.ZodArray<z.ZodObject<{
+        profile: z.ZodString;
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RecordingAvailability = z.infer<typeof RecordingAvailabilitySchema>;
+export declare const RecordingManifestSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    localMasterPath: z.ZodNullable<z.ZodString>;
+    playbackUrl: z.ZodNullable<z.ZodString>;
+    playbackEndpoints: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type RecordingManifest = z.infer<typeof RecordingManifestSchema>;
+/** Recording storage usage for one camera (bytes on disk across all its
+ *  profiles/subtrees/locations on this node). */
+export declare const RecordingDeviceUsageSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    usedBytes: z.ZodNumber;
+}, z.core.$strip>;
+export type RecordingDeviceUsage = z.infer<typeof RecordingDeviceUsageSchema>;
+/** Recording storage usage + capacity for one storage location. */
+export declare const RecordingLocationUsageSchema: z.ZodObject<{
+    locationId: z.ZodNullable<z.ZodString>;
+    usedBytes: z.ZodNumber;
+    availableBytes: z.ZodNullable<z.ZodNumber>;
+    totalBytes: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type RecordingLocationUsage = z.infer<typeof RecordingLocationUsageSchema>;
+/** Aggregate recordings storage usage for a node: global total + per-camera +
+ *  per-location used/available. Stat-based (accurate even for detached cameras),
+ *  computed on demand — not from the name-only playback index. */
+export declare const RecordingStorageUsageSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    totalUsedBytes: z.ZodNumber;
+    devices: z.ZodArray<z.ZodObject<{
+        deviceId: z.ZodNumber;
+        usedBytes: z.ZodNumber;
+    }, z.core.$strip>>;
+    locations: z.ZodArray<z.ZodObject<{
+        locationId: z.ZodNullable<z.ZodString>;
+        usedBytes: z.ZodNumber;
+        availableBytes: z.ZodNullable<z.ZodNumber>;
+        totalBytes: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RecordingStorageUsage = z.infer<typeof RecordingStorageUsageSchema>;
 export declare const recordingCapability: {
     readonly name: "recording";
-    readonly scope: "device";
+    readonly scope: "system";
     readonly mode: "singleton";
-    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly exposesDeviceSettings: true;
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            deviceId: z.ZodNumber;
+            enabled: z.ZodBoolean;
+            activeMode: z.ZodEnum<{
+                off: "off";
+                continuous: "continuous";
+            }>;
+            nodeId: z.ZodString;
+            storageBytes: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "command-driven";
+    };
     readonly methods: {
-        readonly getSegments: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            from: z.ZodOptional<z.ZodNumber>;
-            to: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            startTs: z.ZodNumber;
-            endTs: z.ZodNumber;
-            durationSec: z.ZodNumber;
-            sizeBytes: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
-        readonly getPlaybackUrl: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            segmentId: z.ZodString;
-        }, z.core.$strip>, z.ZodNullable<z.ZodString>, import("./capability-definition.js").CapabilityMethodKind>;
-        readonly getThumbnailAt: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            timestamp: z.ZodNumber;
-        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
-            base64: z.ZodString;
-            contentType: z.ZodString;
-        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getAvailability: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            fromMs: z.ZodNumber;
+            toMs: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            deviceId: z.ZodNumber;
+            ranges: z.ZodArray<z.ZodObject<{
+                profile: z.ZodString;
+                startMs: z.ZodNumber;
+                endMs: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, "query">;
+        readonly getPlaybackManifest: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            fromMs: z.ZodNumber;
+            toMs: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            deviceId: z.ZodNumber;
+            localMasterPath: z.ZodNullable<z.ZodString>;
+            playbackUrl: z.ZodNullable<z.ZodString>;
+            playbackEndpoints: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, "query">;
+        readonly getStorageUsage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            nodeId: z.ZodString;
+            totalUsedBytes: z.ZodNumber;
+            devices: z.ZodArray<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                usedBytes: z.ZodNumber;
+            }, z.core.$strip>>;
+            locations: z.ZodArray<z.ZodObject<{
+                locationId: z.ZodNullable<z.ZodString>;
+                usedBytes: z.ZodNumber;
+                availableBytes: z.ZodNullable<z.ZodNumber>;
+                totalBytes: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, "query">;
+        readonly getDeviceConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            enabled: z.ZodBoolean;
+            profiles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                high: "high";
+                mid: "mid";
+                low: "low";
+            }>>>;
+            segmentSeconds: z.ZodOptional<z.ZodNumber>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"always">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"timeOfDay">;
+                    start: z.ZodString;
+                    end: z.ZodString;
+                    days: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                }, z.core.$strip>], "kind">;
+                mode: z.ZodEnum<{
+                    onMotion: "onMotion";
+                    continuous: "continuous";
+                    onAudioThreshold: "onAudioThreshold";
+                }>;
+                preBufferSec: z.ZodDefault<z.ZodNumber>;
+                postBufferSec: z.ZodDefault<z.ZodNumber>;
+                resetTimeoutOnNewEvent: z.ZodDefault<z.ZodBoolean>;
+                thresholdDbfs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            retention: z.ZodOptional<z.ZodObject<{
+                maxAgeDays: z.ZodOptional<z.ZodNumber>;
+                maxSizeGb: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, "query">;
+        readonly setDeviceConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            config: z.ZodObject<{
+                enabled: z.ZodBoolean;
+                profiles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    high: "high";
+                    mid: "mid";
+                    low: "low";
+                }>>>;
+                segmentSeconds: z.ZodOptional<z.ZodNumber>;
+                rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"always">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"timeOfDay">;
+                        start: z.ZodString;
+                        end: z.ZodString;
+                        days: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                    }, z.core.$strip>], "kind">;
+                    mode: z.ZodEnum<{
+                        onMotion: "onMotion";
+                        continuous: "continuous";
+                        onAudioThreshold: "onAudioThreshold";
+                    }>;
+                    preBufferSec: z.ZodDefault<z.ZodNumber>;
+                    postBufferSec: z.ZodDefault<z.ZodNumber>;
+                    resetTimeoutOnNewEvent: z.ZodDefault<z.ZodBoolean>;
+                    thresholdDbfs: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>>;
+                retention: z.ZodOptional<z.ZodObject<{
+                    maxAgeDays: z.ZodOptional<z.ZodNumber>;
+                    maxSizeGb: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            enabled: z.ZodBoolean;
+            profiles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                high: "high";
+                mid: "mid";
+                low: "low";
+            }>>>;
+            segmentSeconds: z.ZodOptional<z.ZodNumber>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"always">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"timeOfDay">;
+                    start: z.ZodString;
+                    end: z.ZodString;
+                    days: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                }, z.core.$strip>], "kind">;
+                mode: z.ZodEnum<{
+                    onMotion: "onMotion";
+                    continuous: "continuous";
+                    onAudioThreshold: "onAudioThreshold";
+                }>;
+                preBufferSec: z.ZodDefault<z.ZodNumber>;
+                postBufferSec: z.ZodDefault<z.ZodNumber>;
+                resetTimeoutOnNewEvent: z.ZodDefault<z.ZodBoolean>;
+                thresholdDbfs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            retention: z.ZodOptional<z.ZodObject<{
+                maxAgeDays: z.ZodOptional<z.ZodNumber>;
+                maxSizeGb: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, "mutation">;
+        /** Re-scan this device's footage from disk (stat sizes) and reseed the
+         *  index, then return the fresh status. */
+        readonly rescanStorage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            deviceId: z.ZodNumber;
+            enabled: z.ZodBoolean;
+            activeMode: z.ZodEnum<{
+                off: "off";
+                continuous: "continuous";
+            }>;
+            nodeId: z.ZodString;
+            storageBytes: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        /** Apply this device's retention policy to footage now; returns the oldest
+         *  surviving footage start (the retention floor) or null if no footage. */
+        readonly pruneFootage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            floorMs: z.ZodNullable<z.ZodNumber>;
+            deletedBuckets: z.ZodNumber;
+            reclaimedBytes: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
     };
 };
 export type IRecordingProvider = InferProvider<typeof recordingCapability>;
-export { SegmentSchema };
 //# sourceMappingURL=recording.cap.d.ts.map

package/dist/capabilities/recording.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recording.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/recording.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD,QAAA,MAAM,aAAa;;;;;;iBAMjB,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBS,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC1E,OAAO,EAAE,aAAa,EAAE,CAAA"}
+{"version":3,"file":"recording.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/recording.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAGlG,eAAO,MAAM,qBAAqB;;;;;;;;;iBAMhC,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,oBAAoB;;;;iBAI/B,CAAA;AACF,eAAO,MAAM,2BAA2B;;;;;;;iBAGtC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAE/E,eAAO,MAAM,uBAAuB;;;;;iBAelC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;iDACiD;AACjD,eAAO,MAAM,0BAA0B;;;iBAGrC,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,mEAAmE;AACnE,eAAO,MAAM,4BAA4B;;;;;iBASvC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEjF;;kEAEkE;AAClE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;iBAKtC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAE/E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmC5B;mDAC2C;;;;;;;;;;;;;QAM3C;mFAC2E;;;;;;;;;CAWtC,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/capabilities/restreamer.cap.d.ts

@@ -5,8 +5,8 @@ declare const RegisteredStreamSchema: z.ZodObject<{
     label: z.ZodOptional<z.ZodString>;
     codec: z.ZodString;
     type: z.ZodEnum<{
-        audio: "audio";
         video: "video";
+        audio: "audio";
     }>;
     sourceUrl: z.ZodString;
 }, z.core.$strip>;
@@ -28,8 +28,8 @@ export declare const restreamerCapability: {
                 label: z.ZodOptional<z.ZodString>;
                 codec: z.ZodString;
                 type: z.ZodEnum<{
-                    audio: "audio";
                     video: "video";
+                    audio: "audio";
                 }>;
                 sourceUrl: z.ZodString;
             }, z.core.$strip>>>;

package/dist/capabilities/schemas/detection-shared.d.ts

@@ -44,8 +44,21 @@ export declare const SpatialDetectionSchema: z.ZodObject<{
         h: z.ZodNumber;
     }, z.core.$strip>;
 }, z.core.$strip>;
+/**
+ * `data` carries the raw f32le bytes of the PCM samples (4 bytes per
+ * sample, little-endian IEEE 754).  `Uint8Array` is the wire-safe choice
+ * because `@msgpack/msgpack` serialises it as a MsgPack `bin` type that
+ * round-trips losslessly over the UDS transport.  `Float32Array` is NOT
+ * preserved — the encoder serialises it as `bin` (its raw bytes) but
+ * the decoder returns `Uint8Array`, so treating a `Float32Array` as the
+ * wire type causes receivers to read bytes as sample values, producing
+ * wildly wrong RMS/dBFS results (~+43 dBFS instead of ≤0).
+ *
+ * Callers that need float arithmetic reconstruct the view with:
+ *   `new Float32Array(chunk.data.buffer, chunk.data.byteOffset, chunk.data.byteLength / 4)`
+ */
 export declare const AudioChunkInputSchema: z.ZodObject<{
-    data: z.ZodCustom<Float32Array<ArrayBuffer>, Float32Array<ArrayBuffer>>;
+    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
     sampleRate: z.ZodNumber;
     channels: z.ZodNumber;
     timestamp: z.ZodNumber;

package/dist/capabilities/schemas/detection-shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detection-shared.d.ts","sourceRoot":"","sources":["../../../src/capabilities/schemas/detection-shared.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAE7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;;;EAAmD,CAAA;AAEjF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;iBAM3B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;iBAKjC,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;;iBAOhC,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;iBAgBzC,CAAA"}
+{"version":3,"file":"detection-shared.d.ts","sourceRoot":"","sources":["../../../src/capabilities/schemas/detection-shared.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAE7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;;;EAAmD,CAAA;AAEjF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;iBAM3B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;iBAKjC,CAAA;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB;;;;;;iBAOhC,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;iBAgBzC,CAAA"}

package/dist/capabilities/schemas/orchestrator-metrics.d.ts

@@ -19,8 +19,8 @@ export declare const CameraMetricsSchema: z.ZodObject<{
     droppedFrames: z.ZodNumber;
     phase: z.ZodEnum<{
         idle: "idle";
-        watching: "watching";
         active: "active";
+        watching: "watching";
     }>;
 }, z.core.$strip>;
 export declare const CameraMetricsWithDeviceIdSchema: z.ZodObject<{
@@ -36,8 +36,8 @@ export declare const CameraMetricsWithDeviceIdSchema: z.ZodObject<{
     droppedFrames: z.ZodNumber;
     phase: z.ZodEnum<{
         idle: "idle";
-        watching: "watching";
         active: "active";
+        watching: "watching";
     }>;
     deviceId: z.ZodNumber;
 }, z.core.$strip>;