@camstack/types 0.1.39 → 0.1.40

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

@@ -0,0 +1,206 @@
+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 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBO,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

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/sso-bridge.cap.d.ts

@@ -25,8 +25,8 @@ declare const SsoBridgeClaimsSchema: z.ZodObject<{
     scopes: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"category">;
         target: z.ZodEnum<{
-            system: "system";
             device: "device";
+            system: "system";
         }>;
         access: z.ZodArray<z.ZodEnum<{
             view: "view";
@@ -81,8 +81,8 @@ export declare const ssoBridgeCapability: {
                 scopes: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                     type: z.ZodLiteral<"category">;
                     target: z.ZodEnum<{
-                        system: "system";
                         device: "device";
+                        system: "system";
                     }>;
                     access: z.ZodArray<z.ZodEnum<{
                         view: "view";
@@ -136,8 +136,8 @@ export declare const ssoBridgeCapability: {
             scopes: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"category">;
                 target: z.ZodEnum<{
-                    system: "system";
                     device: "device";
+                    system: "system";
                 }>;
                 access: z.ZodArray<z.ZodEnum<{
                     view: "view";

package/dist/capabilities/stream-catalog.cap.d.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { type InferNativeProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * One publishable camera stream as its OWNING PROVIDER describes it — the same
+ * payload the (legacy) push `streamBroker.publishCameraStream` carried, minus
+ * `deviceId`.
+ *
+ * The stream-broker PULLS this catalog per camera (on start, on a configurable
+ * reconcile poll, and on device / stream-params events) to (re)build its
+ * cam-stream registry, instead of relying on providers to push. Pull is
+ * authoritative (RPC); the poll is the backstop for any missed event. This
+ * makes the broker self-heal after a restart — it re-derives the full catalog
+ * from the providers rather than waiting to be re-fed.
+ *
+ * `url` is the dial source where the provider can resolve it synchronously
+ * (rtsp / rtmp / http). For lazy sources (Reolink rfc4571) it carries the
+ * `lazy:rfc4571:` sentinel; the real URL is still materialised at DIAL time via
+ * the broker's `onRequestStreamSourceRefresh` round-trip — unchanged by the
+ * pull model. `push-annexb` sources carry no URL (the provider pushes frames).
+ */
+export declare const CamStreamDescriptorSchema: z.ZodObject<{
+    camStreamId: z.ZodString;
+    kind: z.ZodEnum<{
+        "pull-rtsp": "pull-rtsp";
+        "pull-rtmp": "pull-rtmp";
+        "pull-http": "pull-http";
+        "pull-rfc4571": "pull-rfc4571";
+        "push-annexb": "push-annexb";
+    }>;
+    url: z.ZodOptional<z.ZodString>;
+    codec: z.ZodOptional<z.ZodString>;
+    resolution: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    fps: z.ZodOptional<z.ZodNumber>;
+    label: z.ZodOptional<z.ZodString>;
+    deviceFeatures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    autoEligible: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type CamStreamDescriptor = z.infer<typeof CamStreamDescriptorSchema>;
+/**
+ * `stream-catalog` — device-scoped, provider-implemented. The pull counterpart
+ * of the removed `publishCameraStream` push: a camera provider returns the full
+ * set of stream descriptors it can offer for the device, synchronously, so the
+ * broker can reconcile its registry against the authoritative provider state.
+ */
+export declare const streamCatalogCapability: {
+    readonly name: "stream-catalog";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly methods: {
+        readonly getCatalog: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            camStreamId: z.ZodString;
+            kind: z.ZodEnum<{
+                "pull-rtsp": "pull-rtsp";
+                "pull-rtmp": "pull-rtmp";
+                "pull-http": "pull-http";
+                "pull-rfc4571": "pull-rfc4571";
+                "push-annexb": "push-annexb";
+            }>;
+            url: z.ZodOptional<z.ZodString>;
+            codec: z.ZodOptional<z.ZodString>;
+            resolution: z.ZodOptional<z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>>;
+            fps: z.ZodOptional<z.ZodNumber>;
+            label: z.ZodOptional<z.ZodString>;
+            deviceFeatures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            autoEligible: z.ZodOptional<z.ZodBoolean>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IStreamCatalogProvider = InferNativeProvider<typeof streamCatalogCapability>;
+//# sourceMappingURL=stream-catalog.cap.d.ts.map

package/dist/capabilities/stream-catalog.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-catalog.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/stream-catalog.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;AAGrD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;iBAcpC,CAAA;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWK,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,mBAAmB,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

package/dist/capabilities/user-management.cap.d.ts

@@ -9,8 +9,8 @@ declare const UserSummarySchema: z.ZodObject<{
     scopes: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"category">;
         target: z.ZodEnum<{
-            system: "system";
             device: "device";
+            system: "system";
         }>;
         access: z.ZodArray<z.ZodEnum<{
             view: "view";
@@ -55,8 +55,8 @@ declare const CreateUserInputSchema: z.ZodObject<{
     scopes: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"category">;
         target: z.ZodEnum<{
-            system: "system";
             device: "device";
+            system: "system";
         }>;
         access: z.ZodArray<z.ZodEnum<{
             view: "view";
@@ -97,8 +97,8 @@ declare const UpdateUserInputSchema: z.ZodObject<{
     scopes: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"category">;
         target: z.ZodEnum<{
-            system: "system";
             device: "device";
+            system: "system";
         }>;
         access: z.ZodArray<z.ZodEnum<{
             view: "view";
@@ -168,8 +168,8 @@ declare const ScopedTokenSummarySchema: z.ZodObject<{
     scopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"category">;
         target: z.ZodEnum<{
-            system: "system";
             device: "device";
+            system: "system";
         }>;
         access: z.ZodArray<z.ZodEnum<{
             view: "view";
@@ -211,8 +211,8 @@ declare const CreateScopedTokenInputSchema: z.ZodObject<{
     scopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"category">;
         target: z.ZodEnum<{
-            system: "system";
             device: "device";
+            system: "system";
         }>;
         access: z.ZodArray<z.ZodEnum<{
             view: "view";
@@ -256,8 +256,8 @@ declare const CreateScopedTokenResultSchema: z.ZodObject<{
         scopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             type: z.ZodLiteral<"category">;
             target: z.ZodEnum<{
-                system: "system";
                 device: "device";
+                system: "system";
             }>;
             access: z.ZodArray<z.ZodEnum<{
                 view: "view";
@@ -302,8 +302,8 @@ declare const OauthSessionSummarySchema: z.ZodObject<{
     scopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"category">;
         target: z.ZodEnum<{
-            system: "system";
             device: "device";
+            system: "system";
         }>;
         access: z.ZodArray<z.ZodEnum<{
             view: "view";
@@ -363,8 +363,8 @@ export declare const userManagementCapability: {
             scopes: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"category">;
                 target: z.ZodEnum<{
-                    system: "system";
                     device: "device";
+                    system: "system";
                 }>;
                 access: z.ZodArray<z.ZodEnum<{
                     view: "view";
@@ -409,8 +409,8 @@ export declare const userManagementCapability: {
             scopes: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"category">;
                 target: z.ZodEnum<{
-                    system: "system";
                     device: "device";
+                    system: "system";
                 }>;
                 access: z.ZodArray<z.ZodEnum<{
                     view: "view";
@@ -451,8 +451,8 @@ export declare const userManagementCapability: {
             scopes: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"category">;
                 target: z.ZodEnum<{
-                    system: "system";
                     device: "device";
+                    system: "system";
                 }>;
                 access: z.ZodArray<z.ZodEnum<{
                     view: "view";
@@ -496,8 +496,8 @@ export declare const userManagementCapability: {
             scopes: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"category">;
                 target: z.ZodEnum<{
-                    system: "system";
                     device: "device";
+                    system: "system";
                 }>;
                 access: z.ZodArray<z.ZodEnum<{
                     view: "view";
@@ -548,8 +548,8 @@ export declare const userManagementCapability: {
             scopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"category">;
                 target: z.ZodEnum<{
-                    system: "system";
                     device: "device";
+                    system: "system";
                 }>;
                 access: z.ZodArray<z.ZodEnum<{
                     view: "view";
@@ -596,8 +596,8 @@ export declare const userManagementCapability: {
             scopes: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"category">;
                 target: z.ZodEnum<{
-                    system: "system";
                     device: "device";
+                    system: "system";
                 }>;
                 access: z.ZodArray<z.ZodEnum<{
                     view: "view";
@@ -685,8 +685,8 @@ export declare const userManagementCapability: {
             scopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"category">;
                 target: z.ZodEnum<{
-                    system: "system";
                     device: "device";
+                    system: "system";
                 }>;
                 access: z.ZodArray<z.ZodEnum<{
                     view: "view";
@@ -729,8 +729,8 @@ export declare const userManagementCapability: {
                 scopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                     type: z.ZodLiteral<"category">;
                     target: z.ZodEnum<{
-                        system: "system";
                         device: "device";
+                        system: "system";
                     }>;
                     access: z.ZodArray<z.ZodEnum<{
                         view: "view";
@@ -782,8 +782,8 @@ export declare const userManagementCapability: {
             scopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"category">;
                 target: z.ZodEnum<{
-                    system: "system";
                     device: "device";
+                    system: "system";
                 }>;
                 access: z.ZodArray<z.ZodEnum<{
                     view: "view";
@@ -829,8 +829,8 @@ export declare const userManagementCapability: {
             scopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"category">;
                 target: z.ZodEnum<{
-                    system: "system";
                     device: "device";
+                    system: "system";
                 }>;
                 access: z.ZodArray<z.ZodEnum<{
                     view: "view";
@@ -902,8 +902,8 @@ export declare const userManagementCapability: {
             scopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"category">;
                 target: z.ZodEnum<{
-                    system: "system";
                     device: "device";
+                    system: "system";
                 }>;
                 access: z.ZodArray<z.ZodEnum<{
                     view: "view";
@@ -963,8 +963,8 @@ export declare const userManagementCapability: {
             scopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"category">;
                 target: z.ZodEnum<{
-                    system: "system";
                     device: "device";
+                    system: "system";
                 }>;
                 access: z.ZodArray<z.ZodEnum<{
                     view: "view";
@@ -1005,8 +1005,8 @@ export declare const userManagementCapability: {
             scopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"category">;
                 target: z.ZodEnum<{
-                    system: "system";
                     device: "device";
+                    system: "system";
                 }>;
                 access: z.ZodArray<z.ZodEnum<{
                     view: "view";

package/dist/capabilities/webrtc-session.cap.d.ts

@@ -155,6 +155,7 @@ export declare const webrtcSessionCapability: {
                 downlinkMbps: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
                 prefersTier: z.ZodOptional<z.ZodOptional<z.ZodString>>;
             }, z.core.$strip>>;
+            relayOnly: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>, z.ZodObject<{
             sessionId: z.ZodString;
             sdpOffer: z.ZodString;
@@ -189,6 +190,7 @@ export declare const webrtcSessionCapability: {
             }, z.core.$strip>], "kind">>;
             sdpOffer: z.ZodString;
             sessionId: z.ZodOptional<z.ZodString>;
+            relayOnly: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>, z.ZodObject<{
             sessionId: z.ZodString;
             sdpAnswer: z.ZodString;
@@ -198,6 +200,38 @@ export declare const webrtcSessionCapability: {
             sessionId: z.ZodString;
             sdpAnswer: z.ZodString;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * Trickle ICE — add a remote (client) ICE candidate to a live session.
+         * Lets the client send its SDP offer/answer IMMEDIATELY (before ICE
+         * gathering finishes) and deliver candidates as they arrive, so the
+         * connection establishes in ~0s instead of waiting for full gathering.
+         * The dual of `getIceCandidates`. Mirrors Scrypted's signaling.
+         */
+        readonly addIceCandidate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            sessionId: z.ZodString;
+            candidate: z.ZodString;
+            sdpMid: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            sdpMLineIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * Trickle ICE — poll the server's gathered ICE candidates for a session.
+         * The server answers immediately (no gathering wait) and the client polls
+         * this to receive host/srflx/relay candidates as werift gathers them,
+         * adding each to its PeerConnection. Returns all candidates gathered so
+         * far; the client dedupes. `done` flips true once gathering completes.
+         */
+        readonly getIceCandidates: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            sessionId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            candidates: z.ZodArray<z.ZodObject<{
+                candidate: z.ZodString;
+                sdpMid: z.ZodNullable<z.ZodString>;
+                sdpMLineIndex: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+            done: z.ZodBoolean;
+        }, z.core.$strip>, "query">;
         readonly closeSession: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             sessionId: z.ZodString;

package/dist/capabilities/webrtc-session.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webrtc-session.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/webrtc-session.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;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;2BAInC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,qDAAqD;AACrD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBnC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;QAQhC;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAKH;;;;;;WAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;QAUH;;;;;;;;;;;;WAYG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA4BH,kFAAkF;;;;;;;;;;CAS7C,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}
+{"version":3,"file":"webrtc-session.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/webrtc-session.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;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;2BAInC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,qDAAqD;AACrD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBnC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;QAQhC;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAKH;;;;;;WAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAuBH;;;;;;;;;;;;WAYG;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmCH;;;;;;WAMG;;;;;;;;QAYH;;;;;;WAMG;;;;;;;;;;;;;;;;QAwBH,kFAAkF;;;;;;;;;;CAS7C,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

package/dist/enums/event-category.d.ts

@@ -192,6 +192,15 @@ export declare enum EventCategory {
      * Payload: `{ deviceId, camStreamId, brokerId }`.
      */
     StreamBrokerOnRequestStreamSourceRefresh = "stream-broker.onRequestStreamSourceRefresh",
+    /**
+     * A camera provider changed a device's stream parameters (codec /
+     * resolution / bitrate / a stream added or removed). A LOW-LATENCY NUDGE
+     * for the stream-broker's catalog reconcile: it carries NO authoritative
+     * data — the broker re-PULLS that device's `stream-catalog` cap on receipt
+     * (the 30s reconcile poll is the backstop if this nudge is dropped). Emitted
+     * by providers from `stream-params.setProfile`. Payload: `{ deviceId }`.
+     */
+    StreamParamsChanged = "stream-params.changed",
     /**
      * Generic per-device runtime-state change. Fired by `device-manager`
      * whenever a persisted slice in any cap's `runtimeState` shape
@@ -336,6 +345,15 @@ export declare enum EventCategory {
     /** Fired by the `local-network` cap when the host's interface set
      *  changes (new IP from DHCP, VPN connect, docker bridge added). */
     LocalNetworkChanged = "network.local.changed",
+    /**
+     * Fired by a `mesh-network` provider (Tailscale, …) when its
+     * mesh-reachable host changes (join / leave / MagicDNS or 100.x IP
+     * change). Lets `local-network` fold the mesh endpoint into its
+     * connection-endpoint list without a cross-package import. Payload
+     * carries the preferred host (`host: ''` = no longer reachable),
+     * the hub port, and the scheme. Telemetry-grade (D8): consumers
+     * pull-reconcile from the provider's `getStatus` on reconnect. */
+    MeshNetworkChanged = "network.mesh.changed",
     BackupCompleted = "backup.completed",
     BackupRestored = "backup.restored",
     NotificationDispatched = "notification.dispatched",
@@ -366,6 +384,15 @@ export declare enum EventCategory {
      * Battery cam went to sleep. See `DeviceAwake`.
      */
     DeviceSleeping = "device.sleeping",
-    RetentionCleanup = "retention.cleanup"
+    RetentionCleanup = "retention.cleanup",
+    /**
+     * Progress snapshot emitted by `BulkUpdateCoordinator` on every state
+     * transition (item status change, phase change, completion, cancel).
+     * Payload is `BulkUpdateState`. Admin UI subscribes via `useLiveEvent`
+     * to drive the sticky `BulkUpdateBanner` and per-row `AddonRowBadge`.
+     *
+     * Spec: docs/superpowers/specs/2026-05-21-addons-bulk-update-progress-design.md
+     */
+    AddonsBulkUpdateProgress = "addons.bulk-update-progress"
 }
 //# sourceMappingURL=event-category.d.ts.map