@camstack/types 0.1.14 → 0.1.15

package/dist/capabilities/audio-metrics.cap.d.ts

@@ -0,0 +1,174 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Per-class audio metrics aggregated over a sliding window.
+ */
+declare const AudioClassSummarySchema: z.ZodObject<{
+    className: z.ZodString;
+    hits: z.ZodNumber;
+    avgScore: z.ZodNumber;
+    peakScore: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Per-camera audio metrics snapshot — emitted by the analytics frame
+ * handler on every `pipeline.audio-inference-result` event and
+ * mirrored into the `audio-metrics` device-state slice. Symmetric
+ * with `zone-analytics` snapshots for video — every consumer
+ * (admin UI panel, automations, alert rules) reads via the
+ * canonical `device.state.audioMetrics.value` reactive handle.
+ *
+ * Aggregates are computed over a rolling `windowSec` window
+ * (default 60s). Past that window, classes drop out of `byClass`
+ * and the level history shifts forward.
+ */
+declare const AudioMetricsSnapshotSchema: z.ZodObject<{
+    ts: z.ZodNumber;
+    windowSec: z.ZodNumber;
+    level: z.ZodObject<{
+        rms: z.ZodNumber;
+        dbfs: z.ZodNumber;
+    }, z.core.$strip>;
+    peakDbfs: z.ZodNumber;
+    avgDbfs: z.ZodNumber;
+    current: z.ZodNullable<z.ZodObject<{
+        className: z.ZodString;
+        score: z.ZodNumber;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>>;
+    byClass: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        className: z.ZodString;
+        hits: z.ZodNumber;
+        avgScore: z.ZodNumber;
+        peakScore: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type AudioMetricsSnapshot = z.infer<typeof AudioMetricsSnapshotSchema>;
+export type AudioClassSummary = z.infer<typeof AudioClassSummarySchema>;
+/**
+ * One sample on the audio-metrics history time-series. Captures the
+ * subset of the live snapshot useful for charting: dB level, peak/avg
+ * over the rolling window, and the dominant above-threshold class
+ * (when any). Per-class hit breakdown lives on the snapshot but is
+ * elided from the history sample to keep the buffer compact —
+ * consumers needing class drill-down should pull `getCurrentSnapshot`.
+ */
+declare const AudioMetricsHistoryPointSchema: z.ZodObject<{
+    ts: z.ZodNumber;
+    dbfs: z.ZodNullable<z.ZodNumber>;
+    peakDbfs: z.ZodNumber;
+    avgDbfs: z.ZodNumber;
+    topClass: z.ZodNullable<z.ZodString>;
+    topScore: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type AudioMetricsHistoryPoint = z.infer<typeof AudioMetricsHistoryPointSchema>;
+/**
+ * Audio-metrics history payload — a series of `AudioMetricsHistoryPoint`
+ * samples capped at `maxPoints` (default 1024). When the requested
+ * `windowSec / sampleEveryMs` would exceed the cap, the provider
+ * subsamples by bucketed averaging and reports the effective sample
+ * spacing on `effectiveSampleEveryMs` so the UI can label the x-axis.
+ */
+declare const AudioMetricsHistorySchema: z.ZodObject<{
+    points: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        ts: z.ZodNumber;
+        dbfs: z.ZodNullable<z.ZodNumber>;
+        peakDbfs: z.ZodNumber;
+        avgDbfs: z.ZodNumber;
+        topClass: z.ZodNullable<z.ZodString>;
+        topScore: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    effectiveSampleEveryMs: z.ZodNumber;
+    windowMsActual: z.ZodNumber;
+}, z.core.$strip>;
+export type AudioMetricsHistory = z.infer<typeof AudioMetricsHistorySchema>;
+/**
+ * Audio Metrics capability — sliding-window aggregates over the
+ * pipeline audio inference results. Hosted by `addon-pipeline-analytics`
+ * (same addon that owns `zone-analytics`); the runtime-state slice
+ * gives operators a live read on dB level + dominant classes without
+ * a custom event subscription.
+ */
+export declare const audioMetricsCapability: {
+    readonly name: "audio-metrics";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly methods: {
+        /** Latest snapshot for this device. Null until the analytics
+         *  pipeline has processed at least one audio window. */
+        readonly getCurrentSnapshot: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            ts: z.ZodNumber;
+            windowSec: z.ZodNumber;
+            level: z.ZodObject<{
+                rms: z.ZodNumber;
+                dbfs: z.ZodNumber;
+            }, z.core.$strip>;
+            peakDbfs: z.ZodNumber;
+            avgDbfs: z.ZodNumber;
+            current: z.ZodNullable<z.ZodObject<{
+                className: z.ZodString;
+                score: z.ZodNumber;
+                timestamp: z.ZodNumber;
+            }, z.core.$strip>>;
+            byClass: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                className: z.ZodString;
+                hits: z.ZodNumber;
+                avgScore: z.ZodNumber;
+                peakScore: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Time-series view of recent audio-metrics samples. The provider
+         * keeps an in-memory ring of ~1Hz samples (matching the slice-
+         * write rate) capped at `MAX_HISTORY_POINTS_KEPT` (provider-side).
+         * `windowSec` selects how far back to read; `sampleEveryMs`
+         * downsamples by bucketed averaging when finer than the kept
+         * granularity. Empty `points` array on freshly-booted providers
+         * with no audio yet — same convention as `getCurrentSnapshot`.
+         */
+        readonly getHistory: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            windowSec: z.ZodOptional<z.ZodNumber>;
+            sampleEveryMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            points: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                ts: z.ZodNumber;
+                dbfs: z.ZodNullable<z.ZodNumber>;
+                peakDbfs: z.ZodNumber;
+                avgDbfs: z.ZodNumber;
+                topClass: z.ZodNullable<z.ZodString>;
+                topScore: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            effectiveSampleEveryMs: z.ZodNumber;
+            windowMsActual: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+    /** Reactive runtime-state mirror — live `device.state.audioMetrics.value`. */
+    readonly runtimeState: z.ZodObject<{
+        ts: z.ZodNumber;
+        windowSec: z.ZodNumber;
+        level: z.ZodObject<{
+            rms: z.ZodNumber;
+            dbfs: z.ZodNumber;
+        }, z.core.$strip>;
+        peakDbfs: z.ZodNumber;
+        avgDbfs: z.ZodNumber;
+        current: z.ZodNullable<z.ZodObject<{
+            className: z.ZodString;
+            score: z.ZodNumber;
+            timestamp: z.ZodNumber;
+        }, z.core.$strip>>;
+        byClass: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            className: z.ZodString;
+            hits: z.ZodNumber;
+            avgScore: z.ZodNumber;
+            peakScore: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+};
+export type IAudioMetricsProvider = InferProvider<typeof audioMetricsCapability>;
+export { AudioMetricsSnapshotSchema, AudioClassSummarySchema, AudioMetricsHistoryPointSchema, AudioMetricsHistorySchema, };
+//# sourceMappingURL=audio-metrics.cap.d.ts.map

package/dist/capabilities/audio-metrics.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-metrics.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/audio-metrics.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;;GAEG;AACH,QAAA,MAAM,uBAAuB;;;;;iBAQ3B,CAAA;AAEF;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;iBAuB9B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAC7E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;;;;;;;GAOG;AACH,QAAA,MAAM,8BAA8B;;;;;;;iBAelC,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF;;;;;;GAMG;AACH,QAAA,MAAM,yBAAyB;;;;;;;;;;;iBAO7B,CAAA;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;QAM/B;gEACwD;;;;;;;;;;;;;;;;;;;;;;;;QAKxD;;;;;;;;WAQG;;;;;;;;;;;;;;;;;;IAgBL,8EAA8E;;;;;;;;;;;;;;;;;;;;;;CAEvC,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEhF,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,EACvB,8BAA8B,EAC9B,yBAAyB,GAC1B,CAAA"}

package/dist/capabilities/auth-provider.cap.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const AuthResultSchema: z.ZodObject<{
+    userId: z.ZodString;
+    username: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const authProviderCapability: {
+    readonly name: "auth-provider";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly methods: {
+        readonly validateCredentials: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            username: z.ZodString;
+            password: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            userId: z.ZodString;
+            username: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodOptional<z.ZodString>;
+            roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>, "mutation">;
+        readonly getLoginUrl: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            state: z.ZodString;
+        }, z.core.$strip>, z.ZodString, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly handleCallback: import("./capability-definition.js").CapabilityMethodSchema<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodObject<{
+            userId: z.ZodString;
+            username: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodOptional<z.ZodString>;
+            roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, "mutation">;
+        readonly validateToken: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            token: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            userId: z.ZodString;
+            username: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodOptional<z.ZodString>;
+            roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IAuthProvider = InferProvider<typeof authProviderCapability>;
+export { AuthResultSchema };
+//# sourceMappingURL=auth-provider.cap.d.ts.map

package/dist/capabilities/auth-provider.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-provider.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/auth-provider.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,QAAA,MAAM,gBAAgB;;;;;;iBAMpB,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAeM,CAAA;AAEzC,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAExE,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

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

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const BackupEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    sizeBytes: z.ZodNumber;
+    locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * backup — singleton capability for backup management.
+ *
+ * Implemented by `local-backup` addon. Future providers (S3, rsync)
+ * can replace it by registering the same capability.
+ */
+export declare const backupCapability: {
+    readonly name: "backup";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        readonly trigger: import("./capability-definition.js").CapabilityMethodSchema<z.ZodOptional<z.ZodObject<{
+            locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodNumber;
+            sizeBytes: z.ZodNumber;
+            locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, "mutation">;
+        readonly list: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodNumber;
+            sizeBytes: z.ZodNumber;
+            locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly restore: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            backupId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly delete: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            backupId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+};
+export type IBackupProvider = InferProvider<typeof backupCapability>;
+export { BackupEntrySchema };
+//# sourceMappingURL=backup.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"backup.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/backup.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,QAAA,MAAM,iBAAiB;;;;;;iBAMrB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEpE,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

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

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Battery status snapshot. Emitted by providers whose device is
+ * battery-operated (cameras with `DeviceFeature.BatteryOperated`,
+ * future sensor/button accessories). Consumers build their own "low
+ * battery" alerting on top — the cap deliberately does NOT enforce a
+ * threshold.
+ */
+export declare const BatteryStatusSchema: z.ZodObject<{
+    percentage: z.ZodNumber;
+    charging: z.ZodEnum<{
+        none: "none";
+        dc: "dc";
+        solar: "solar";
+    }>;
+    sleeping: z.ZodBoolean;
+    lastUpdated: z.ZodNumber;
+}, z.core.$strip>;
+export type BatteryStatus = z.infer<typeof BatteryStatusSchema>;
+export declare const batteryCapability: {
+    readonly name: "battery";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch];
+    readonly methods: {};
+    readonly events: {
+        /**
+         * Emitted whenever the cached status changes (firmware push OR
+         * poll observes a delta). The DeviceEventPropagator mirrors this
+         * event on the parent chain — subscribing to a camera's source
+         * receives battery events from child accessories automatically.
+         */
+        readonly onStatusChanged: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                status: z.ZodObject<{
+                    percentage: z.ZodNumber;
+                    charging: z.ZodEnum<{
+                        none: "none";
+                        dc: "dc";
+                        solar: "solar";
+                    }>;
+                    sleeping: z.ZodBoolean;
+                    lastUpdated: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            percentage: z.ZodNumber;
+            charging: z.ZodEnum<{
+                none: "none";
+                dc: "dc";
+                solar: "solar";
+            }>;
+            sleeping: z.ZodBoolean;
+            lastUpdated: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — every provider that registers this cap
+     * stores the same shape under `device.runtimeState[battery]`.
+     * Cross-provider uniformity: a Reolink Argus, a Frigate sensor
+     * proxy, an ONVIF battery cam all read/write the same keys.
+     * Consumers (BatteryBadge, snapshot wrapper sleep gate) read once
+     * via `device.runtimeState.getCapState('battery')` regardless of
+     * the underlying driver.
+     */
+    readonly runtimeState: z.ZodObject<{
+        percentage: z.ZodNumber;
+        charging: z.ZodEnum<{
+            none: "none";
+            dc: "dc";
+            solar: "solar";
+        }>;
+        sleeping: z.ZodBoolean;
+        lastUpdated: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IBatteryProvider = InferProvider<typeof batteryCapability>;
+//# sourceMappingURL=battery.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"battery.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/battery.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;iBAkB9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,iBAAiB;;;;;;;QAO1B;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUL;;;;;;;;OAQG;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

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

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Dimmable-light brightness control. Co-exists with `switch` on the
+ * same device — the switch toggles on/off, this cap sets the level
+ * applied when the light is on. Modeled after Scrypted's `Brightness`
+ * interface so drivers can map their per-vendor dim controls cleanly.
+ *
+ * The cap is intentionally minimal: a single `setBrightness({deviceId,
+ * percentage})` mutation plus the auto-injected `getStatus`. Drivers
+ * that expose richer controls (color temperature, scenes, schedules)
+ * should surface those via the device's `getSettingsUISchema()`
+ * instead of bloating this cap.
+ */
+export declare const BrightnessStatusSchema: z.ZodObject<{
+    percentage: z.ZodNumber;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type BrightnessStatus = z.infer<typeof BrightnessStatusSchema>;
+export declare const brightnessCapability: {
+    readonly name: "brightness";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Light];
+    readonly methods: {
+        readonly setBrightness: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            percentage: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly events: {
+        /**
+         * Emitted whenever the brightness changes — operator action OR
+         * firmware push. Subscribers (UI sliders, automation engines) react
+         * without polling.
+         */
+        readonly onBrightnessChanged: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                percentage: z.ZodNumber;
+                lastChangedAt: z.ZodNumber;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            percentage: z.ZodNumber;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "command-driven";
+    };
+    /**
+     * Runtime-state slice — the last applied brightness level, mirrored
+     * by the kernel. Read via `device.state.brightness.value` so UI
+     * sliders surface the current level without polling the provider.
+     */
+    readonly runtimeState: z.ZodObject<{
+        percentage: z.ZodNumber;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IBrightnessProvider = InferProvider<typeof brightnessCapability>;
+//# sourceMappingURL=brightness.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"brightness.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/brightness.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;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB;;;iBAKjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;QAgB7B;;;;WAIG;;;;;;;;;;;;;;;;IAWL;;;;OAIG;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/capabilities/camera-credentials.cap.d.ts

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * camera-credentials — device-scoped cap exposing the camera's network
+ * + auth surface in a vendor-neutral shape.
+ *
+ * Why it exists: cross-vendor wrappers (the planned ONVIF generic addon
+ * for PTZ / intercom / events; future homekit / mqtt bridges) need the
+ * camera's IP + port + creds without each wrapper re-implementing
+ * vendor-specific config-blob extraction. With this cap, every camera
+ * provider returns a uniform CameraCredentials and consumers stay
+ * vendor-agnostic.
+ *
+ * Implementations:
+ *   - Each camera-providing addon registers this cap natively per
+ *     device (Reolink, Hikvision, RTSP, Frigate, ONVIF self).
+ *   - Returns a snapshot from the persisted device config blob — no
+ *     extra round-trip to the camera, no probing.
+ *   - The cap is admin-only (`auth: 'admin'`) — credentials must not
+ *     leak through user-scoped paths.
+ *
+ * Sensitive data handling:
+ *   - getCredentials returns the full snapshot to admin callers only.
+ *   - Wrappers are expected to use the value to construct a per-call
+ *     client and NOT to log / event-bus-emit the password field.
+ *   - The cap status payload (mirrored to runtime-state) carries
+ *     non-sensitive metadata only — host + ports + protocol hints. The
+ *     password / username live on `getCredentials` exclusively.
+ *
+ * See `docs/onvif-generic-addon-plan.md` for the consuming wrapper
+ * design.
+ */
+export declare const CameraCredentialsSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodOptional<z.ZodNumber>;
+    onvifPort: z.ZodOptional<z.ZodNumber>;
+    rtspPort: z.ZodOptional<z.ZodNumber>;
+    https: z.ZodOptional<z.ZodBoolean>;
+    username: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    onvifProfile: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CameraCredentials = z.infer<typeof CameraCredentialsSchema>;
+/**
+ * Non-sensitive camera-credentials status — host + ports + protocol
+ * hints only. Mirrors what shows up in the bindings UI / device
+ * aggregate. The full credentials (with password) are exposed only via
+ * `getCredentials` to admin callers.
+ */
+export declare const CameraCredentialsStatusSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodNullable<z.ZodNumber>;
+    onvifPort: z.ZodNullable<z.ZodNumber>;
+    rtspPort: z.ZodNullable<z.ZodNumber>;
+    https: z.ZodNullable<z.ZodBoolean>;
+    hasUsername: z.ZodBoolean;
+    hasPassword: z.ZodBoolean;
+    onvifProfile: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type CameraCredentialsStatus = z.infer<typeof CameraCredentialsStatusSchema>;
+export declare const cameraCredentialsCapability: {
+    readonly name: "camera-credentials";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly methods: {
+        /**
+         * Return the camera's full credential bundle for admin consumers.
+         * Each provider implementation returns a snapshot of its persisted
+         * config — no I/O to the camera. Returns null when the device is
+         * not owned by this addon (deviceId mismatch).
+         */
+        readonly getCredentials: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            host: z.ZodString;
+            port: z.ZodOptional<z.ZodNumber>;
+            onvifPort: z.ZodOptional<z.ZodNumber>;
+            rtspPort: z.ZodOptional<z.ZodNumber>;
+            https: z.ZodOptional<z.ZodBoolean>;
+            username: z.ZodOptional<z.ZodString>;
+            password: z.ZodOptional<z.ZodString>;
+            onvifProfile: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>, "query">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            host: z.ZodString;
+            port: z.ZodNullable<z.ZodNumber>;
+            onvifPort: z.ZodNullable<z.ZodNumber>;
+            rtspPort: z.ZodNullable<z.ZodNumber>;
+            https: z.ZodNullable<z.ZodBoolean>;
+            hasUsername: z.ZodBoolean;
+            hasPassword: z.ZodBoolean;
+            onvifProfile: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        readonly kind: "command-driven";
+    };
+};
+export type ICameraCredentialsProvider = InferProvider<typeof cameraCredentialsCapability>;
+//# sourceMappingURL=camera-credentials.cap.d.ts.map

package/dist/capabilities/camera-credentials.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-credentials.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/camera-credentials.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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;iBAiBlC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;iBASxC,CAAA;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEnF,eAAO,MAAM,2BAA2B;;;;;;QAMpC;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWkC,CAAA;AAEzC,MAAM,MAAM,0BAA0B,GAAG,aAAa,CAAC,OAAO,2BAA2B,CAAC,CAAA"}