@camstack/types 0.1.14 → 0.1.16

package/dist/capabilities/motion-trigger.cap.d.ts

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Motion-trigger toggle for accessory devices.
+ *
+ * "Motion trigger" means: when the parent camera detects motion, the
+ * accessory activates automatically. The cap exposes a single boolean
+ * — `enabled` — that drivers map to the vendor-specific firmware
+ * action (Reolink: `setSirenOnMotion`, `setFloodlightOnMotion`; ONVIF
+ * relay: schedule binding; …).
+ *
+ * The accessory still has its own `switch` cap for direct on/off; this
+ * cap is independent. Toggling motion-trigger on does NOT necessarily
+ * toggle the switch on — it just instructs the firmware to flip the
+ * switch when motion fires.
+ *
+ * Driver-specific knobs (motion duration window, brightness while
+ * triggered, schedule windows) live in the device's
+ * `getSettingsUISchema()` instead of bloating this cap — same
+ * principle as `switch` and `brightness` keeping their surface
+ * minimal.
+ */
+export declare const MotionTriggerStatusSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type MotionTriggerStatus = z.infer<typeof MotionTriggerStatusSchema>;
+/**
+ * Persistent slice mirrored across restarts. The provider writes here
+ * on every successful firmware fetch / setMotionTrigger push; the cap
+ * router and admin-ui hero read straight from this snapshot via
+ * `device.state.motionTrigger.value` instead of re-issuing a firmware
+ * round-trip on every UI mount. `lastFetchedAt` lets the framework
+ * helper (`createRuntimeStateBridge`) stale-check before deciding
+ * whether to refresh from the camera.
+ */
+export declare const MotionTriggerRuntimeStateSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+    lastFetchedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type MotionTriggerRuntimeState = z.infer<typeof MotionTriggerRuntimeStateSchema>;
+export declare const motionTriggerCapability: {
+    readonly name: "motion-trigger";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Light, DeviceType.Siren, DeviceType.Switch];
+    readonly methods: {
+        readonly setMotionTrigger: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly events: {
+        readonly onMotionTriggerChanged: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                enabled: z.ZodBoolean;
+                lastChangedAt: z.ZodNumber;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "command-driven";
+    };
+    readonly runtimeState: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        lastChangedAt: z.ZodNumber;
+        lastFetchedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IMotionTriggerProvider = InferProvider<typeof motionTriggerCapability>;
+//# sourceMappingURL=motion-trigger.cap.d.ts.map

package/dist/capabilities/motion-trigger.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion-trigger.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/motion-trigger.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;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,yBAAyB;;;iBAIpC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B;;;;iBAG1C,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAEvF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BK,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

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

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Hardware / firmware motion sensor cap — binary detected state plus
+ * a timestamp of the last observation. Distinct from
+ * `motion-detection.cap.ts` which owns the LOCAL ML motion pipeline;
+ * `motion` is the lightweight readout from on-camera motion (Reolink
+ * `GetMdState`, Baichuan push `type: motion`, ONVIF analytics).
+ *
+ * Native-motion providers also fan out to `detection.camera-native`
+ * with `source: 'onboard'` so cross-cutting system services
+ * (alert-center, advanced-notifier) can subscribe once and receive
+ * motion from every camera.
+ */
+export declare const MotionStatusSchema: z.ZodObject<{
+    detected: z.ZodBoolean;
+    lastDetectedAt: z.ZodNullable<z.ZodNumber>;
+    autoClearAfterMs: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type MotionStatus = z.infer<typeof MotionStatusSchema>;
+/**
+ * Payload of `motion.onMotionChanged` event + the corresponding bus
+ * event `EventCategory.MotionOnMotionChanged`. Single source of truth
+ * — both the cap event surface and the bus payload type alias to this
+ * schema.
+ */
+export declare const MotionOnMotionChangedDataSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    detected: z.ZodBoolean;
+    timestamp: z.ZodNumber;
+    source: z.ZodEnum<{
+        onboard: "onboard";
+        analyzer: "analyzer";
+    }>;
+    regions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        bbox: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            w: z.ZodNumber;
+            h: z.ZodNumber;
+        }, z.core.$strip>;
+        pixelCount: z.ZodNumber;
+        intensity: z.ZodNumber;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+export type MotionOnMotionChangedData = z.infer<typeof MotionOnMotionChangedDataSchema>;
+export declare const motionCapability: {
+    readonly name: "motion";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera, DeviceType.Sensor];
+    readonly methods: {
+        /**
+         * Pull the current motion state synchronously. Convenience shortcut
+         * for consumers that don't need the full status object; equivalent
+         * to `getStatus()?.detected ?? false`. Will likely be folded into
+         * `getStatus` once the auto-injected status surface lands in every
+         * consumer.
+         */
+        readonly isDetected: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+    readonly events: {
+        /**
+         * Fires every time the runner transitions a camera between
+         * `watching` and `active` phases. `source` carries which motion
+         * path drove the transition; `regions` is populated only for
+         * `source: 'analyzer'` (frame-diff regions from the ML motion
+         * detector) — onboard sources don't carry per-frame regions
+         * here (camera-provided zones / AI metadata live in dedicated
+         * channels: `detection.camera-native`, future zone capability).
+         *
+         * Consumers that want all motion pushes (even with `detected`
+         * unchanged) should subscribe to the status subscription via
+         * `device-manager.subscribeDeviceStatusAggregate` instead.
+         */
+        readonly onMotionChanged: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                detected: z.ZodBoolean;
+                timestamp: z.ZodNumber;
+                source: z.ZodEnum<{
+                    onboard: "onboard";
+                    analyzer: "analyzer";
+                }>;
+                regions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    bbox: z.ZodObject<{
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                        w: z.ZodNumber;
+                        h: z.ZodNumber;
+                    }, z.core.$strip>;
+                    pixelCount: z.ZodNumber;
+                    intensity: z.ZodNumber;
+                }, z.core.$strip>>>>;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            detected: z.ZodBoolean;
+            lastDetectedAt: z.ZodNullable<z.ZodNumber>;
+            autoClearAfterMs: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — the last observed motion snapshot, mirrored
+     * by the kernel and readable cross-process via
+     * `device.state.motion.value`. Reads never invoke the provider, so
+     * UIs and other addons can poll the cached state safely.
+     */
+    readonly runtimeState: z.ZodObject<{
+        detected: z.ZodBoolean;
+        lastDetectedAt: z.ZodNullable<z.ZodNumber>;
+        autoClearAfterMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+};
+export type IMotionProvider = InferProvider<typeof motionCapability>;
+//# sourceMappingURL=motion.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"motion.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/motion.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;AAIrD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB;;;;iBAU7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;iBAM1C,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAEvF,eAAO,MAAM,gBAAgB;;;;;;QAMzB;;;;;;WAMG;;;;;;QAOH;;;;;;;;;;;;WAYG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAOL;;;;;OAKG;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/capabilities/native-object-detection.cap.d.ts

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * On-camera AI object detection cap. Surfaces per-device the classes
+ * the firmware can detect and the last-seen instance of each. The
+ * provider also fan-outs these to the global `detection.camera-native`
+ * event bus with `source: 'onboard'` so cross-cutting system services
+ * (alert-center, advanced-notifier, recording-engine) can subscribe
+ * once and receive events from every camera.
+ *
+ * Distinct from `motion-detection` (ML pipeline) and `motion` (hardware
+ * PIR or firmware motion pulse): this cap is specifically the AI
+ * classifier output coming FROM the camera, not the local pipeline.
+ */
+export declare const NativeObjectClassEnum: z.ZodEnum<{
+    person: "person";
+    vehicle: "vehicle";
+    animal: "animal";
+    face: "face";
+    other: "other";
+    package: "package";
+}>;
+export type NativeObjectClass = z.infer<typeof NativeObjectClassEnum>;
+export declare const NativeDetectionSchema: z.ZodObject<{
+    class: z.ZodEnum<{
+        person: "person";
+        vehicle: "vehicle";
+        animal: "animal";
+        face: "face";
+        other: "other";
+        package: "package";
+    }>;
+    timestamp: z.ZodNumber;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type NativeDetection = z.infer<typeof NativeDetectionSchema>;
+export declare const NativeObjectDetectionStatusSchema: z.ZodObject<{
+    lastByClass: z.ZodRecord<z.ZodEnum<{
+        person: "person";
+        vehicle: "vehicle";
+        animal: "animal";
+        face: "face";
+        other: "other";
+        package: "package";
+    }>, z.ZodNullable<z.ZodObject<{
+        class: z.ZodEnum<{
+            person: "person";
+            vehicle: "vehicle";
+            animal: "animal";
+            face: "face";
+            other: "other";
+            package: "package";
+        }>;
+        timestamp: z.ZodNumber;
+        confidence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    supportedClasses: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        person: "person";
+        vehicle: "vehicle";
+        animal: "animal";
+        face: "face";
+        other: "other";
+        package: "package";
+    }>>>;
+}, z.core.$strip>;
+export type NativeObjectDetectionStatus = z.infer<typeof NativeObjectDetectionStatusSchema>;
+export declare const nativeObjectDetectionCapability: {
+    readonly name: "native-object-detection";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly methods: {};
+    readonly events: {
+        readonly onDetected: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                detection: z.ZodObject<{
+                    class: z.ZodEnum<{
+                        person: "person";
+                        vehicle: "vehicle";
+                        animal: "animal";
+                        face: "face";
+                        other: "other";
+                        package: "package";
+                    }>;
+                    timestamp: z.ZodNumber;
+                    confidence: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            lastByClass: z.ZodRecord<z.ZodEnum<{
+                person: "person";
+                vehicle: "vehicle";
+                animal: "animal";
+                face: "face";
+                other: "other";
+                package: "package";
+            }>, z.ZodNullable<z.ZodObject<{
+                class: z.ZodEnum<{
+                    person: "person";
+                    vehicle: "vehicle";
+                    animal: "animal";
+                    face: "face";
+                    other: "other";
+                    package: "package";
+                }>;
+                timestamp: z.ZodNumber;
+                confidence: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            supportedClasses: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                person: "person";
+                vehicle: "vehicle";
+                animal: "animal";
+                face: "face";
+                other: "other";
+                package: "package";
+            }>>>;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+};
+export type INativeObjectDetectionProvider = InferProvider<typeof nativeObjectDetectionCapability>;
+//# sourceMappingURL=native-object-detection.cap.d.ts.map

package/dist/capabilities/native-object-detection.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-object-detection.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/native-object-detection.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;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB;;;;;;;EAEhC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAErE,eAAO,MAAM,qBAAqB;;;;;;;;;;;iBAKhC,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQ5C,CAAA;AAEF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAE3F,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBH,CAAA;AAEzC,MAAM,MAAM,8BAA8B,GAAG,aAAa,CAAC,OAAO,+BAA+B,CAAC,CAAA"}

package/dist/capabilities/network-access.cap.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const NetworkEndpointSchema: z.ZodObject<{
+    url: z.ZodString;
+    hostname: z.ZodString;
+    port: z.ZodNumber;
+    protocol: z.ZodEnum<{
+        http: "http";
+        https: "https";
+    }>;
+}, z.core.$strip>;
+declare const NetworkAccessStatusSchema: z.ZodObject<{
+    connected: z.ZodBoolean;
+    endpoint: z.ZodNullable<z.ZodObject<{
+        url: z.ZodString;
+        hostname: z.ZodString;
+        port: z.ZodNumber;
+        protocol: z.ZodEnum<{
+            http: "http";
+            https: "https";
+        }>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const networkAccessCapability: {
+    readonly name: "network-access";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly methods: {
+        readonly start: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            url: z.ZodString;
+            hostname: z.ZodString;
+            port: z.ZodNumber;
+            protocol: z.ZodEnum<{
+                http: "http";
+                https: "https";
+            }>;
+        }, z.core.$strip>, "mutation">;
+        readonly stop: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodVoid, "mutation">;
+        readonly getEndpoint: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodNullable<z.ZodObject<{
+            url: z.ZodString;
+            hostname: z.ZodString;
+            port: z.ZodNumber;
+            protocol: z.ZodEnum<{
+                http: "http";
+                https: "https";
+            }>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getStatus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            connected: z.ZodBoolean;
+            endpoint: z.ZodNullable<z.ZodObject<{
+                url: z.ZodString;
+                hostname: z.ZodString;
+                port: z.ZodNumber;
+                protocol: z.ZodEnum<{
+                    http: "http";
+                    https: "https";
+                }>;
+            }, z.core.$strip>>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type INetworkAccessProvider = InferProvider<typeof networkAccessCapability>;
+export { NetworkEndpointSchema, NetworkAccessStatusSchema };
+//# sourceMappingURL=network-access.cap.d.ts.map

package/dist/capabilities/network-access.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-access.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/network-access.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,QAAA,MAAM,qBAAqB;;;;;;;;iBAKzB,CAAA;AAEF,QAAA,MAAM,yBAAyB;;;;;;;;;;;;iBAI7B,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWK,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAElF,OAAO,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,CAAA"}

package/dist/capabilities/network-quality.cap.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * network-quality — system-scoped singleton capability tracking RTT,
+ * jitter, and observed/peak bandwidth per device + per client.
+ *
+ * Implementation lives in the server's `NetworkQualityService` (thin
+ * wrapper over the shared `NetworkQualityTracker` from `@camstack/core`).
+ * The provider is registered from `trpc.router.ts` against the existing
+ * service instance — no addon owns this state.
+ *
+ * Phase E of the API consolidation: previously a hand-written core
+ * router. Cap conversion lets the same codegen pipeline produce both
+ * the tRPC router and the canonical UI hooks
+ * (`useNetworkQualityGetDeviceStats`, …).
+ */
+declare const StreamNetworkStatsSchema: z.ZodObject<{
+    nominalBitrateKbps: z.ZodNumber;
+    observedBitrateKbps: z.ZodNumber;
+    peakBitrateKbps: z.ZodNumber;
+    packetLossPercent: z.ZodNumber;
+    lastUpdated: z.ZodNumber;
+}, z.core.$strip>;
+declare const ClientNetworkStatsSchema: z.ZodObject<{
+    rttMs: z.ZodNumber;
+    jitterMs: z.ZodNumber;
+    estimatedBandwidthKbps: z.ZodNumber;
+    lastUpdated: z.ZodNumber;
+}, z.core.$strip>;
+declare const DeviceNetworkStatsSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    streams: z.ZodRecord<z.ZodString, z.ZodObject<{
+        nominalBitrateKbps: z.ZodNumber;
+        observedBitrateKbps: z.ZodNumber;
+        peakBitrateKbps: z.ZodNumber;
+        packetLossPercent: z.ZodNumber;
+        lastUpdated: z.ZodNumber;
+    }, z.core.$strip>>;
+    client: z.ZodOptional<z.ZodObject<{
+        rttMs: z.ZodNumber;
+        jitterMs: z.ZodNumber;
+        estimatedBandwidthKbps: z.ZodNumber;
+        lastUpdated: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const networkQualityCapability: {
+    readonly name: "network-quality";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        readonly getDeviceStats: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            streams: z.ZodRecord<z.ZodString, z.ZodObject<{
+                nominalBitrateKbps: z.ZodNumber;
+                observedBitrateKbps: z.ZodNumber;
+                peakBitrateKbps: z.ZodNumber;
+                packetLossPercent: z.ZodNumber;
+                lastUpdated: z.ZodNumber;
+            }, z.core.$strip>>;
+            client: z.ZodOptional<z.ZodObject<{
+                rttMs: z.ZodNumber;
+                jitterMs: z.ZodNumber;
+                estimatedBandwidthKbps: z.ZodNumber;
+                lastUpdated: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getAllStats: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            streams: z.ZodRecord<z.ZodString, z.ZodObject<{
+                nominalBitrateKbps: z.ZodNumber;
+                observedBitrateKbps: z.ZodNumber;
+                peakBitrateKbps: z.ZodNumber;
+                packetLossPercent: z.ZodNumber;
+                lastUpdated: z.ZodNumber;
+            }, z.core.$strip>>;
+            client: z.ZodOptional<z.ZodObject<{
+                rttMs: z.ZodNumber;
+                jitterMs: z.ZodNumber;
+                estimatedBandwidthKbps: z.ZodNumber;
+                lastUpdated: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly reportClientStats: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            rttMs: z.ZodNumber;
+            jitterMs: z.ZodNumber;
+            estimatedBandwidthKbps: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+};
+export type INetworkQualityProvider = InferProvider<typeof networkQualityCapability>;
+export { StreamNetworkStatsSchema, ClientNetworkStatsSchema, DeviceNetworkStatsSchema, };
+//# sourceMappingURL=network-quality.cap.d.ts.map

package/dist/capabilities/network-quality.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-quality.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/network-quality.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;;;;GAaG;AAEH,QAAA,MAAM,wBAAwB;;;;;;iBAM5B,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;iBAK5B,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;iBAI5B,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBI,CAAA;AAEzC,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEpF,OAAO,EACL,wBAAwB,EACxB,wBAAwB,EACxB,wBAAwB,GACzB,CAAA"}