@camstack/types 0.1.39 → 0.1.40

package/dist/{index-CMM1Y9W6.js → index-DnpdVFKv.js}

@@ -1,5 +1,36 @@
 "use strict";
 const zod = require("zod");
+const wiringProbeKindSchema = zod.z.enum(["singleton", "device", "widget"]);
+const wiringProbeResultSchema = zod.z.object({
+  capName: zod.z.string(),
+  kind: wiringProbeKindSchema,
+  deviceId: zod.z.number().optional(),
+  reachable: zod.z.boolean(),
+  latencyMs: zod.z.number(),
+  error: zod.z.string().optional()
+});
+const wiringAddonHealthSchema = zod.z.object({
+  addonId: zod.z.string(),
+  caps: zod.z.array(wiringProbeResultSchema).readonly(),
+  widgets: zod.z.array(wiringProbeResultSchema).readonly()
+});
+const wiringNodeHealthSchema = zod.z.object({
+  nodeId: zod.z.string(),
+  addons: zod.z.array(wiringAddonHealthSchema).readonly()
+});
+const wiringHealthSnapshotSchema = zod.z.object({
+  /** True only when every probed target is reachable. */
+  ok: zod.z.boolean(),
+  /** True when at least one target is unreachable. */
+  degraded: zod.z.boolean(),
+  checkedAt: zod.z.string(),
+  nodes: zod.z.array(wiringNodeHealthSchema).readonly(),
+  summary: zod.z.object({
+    total: zod.z.number(),
+    reachable: zod.z.number(),
+    unreachable: zod.z.number()
+  })
+});
 const MODEL_FORMATS = ["onnx", "coreml", "openvino", "tflite", "pt"];
 const WELL_KNOWN_TABS = [
   { id: "overview", label: "Overview", icon: "layout-dashboard", order: -10 },
@@ -1739,7 +1770,7 @@ const SpatialDetectionSchema = zod.z.object({
   bbox: BoundingBoxSchema
 });
 const AudioChunkInputSchema = zod.z.object({
-  data: zod.z.instanceof(Float32Array),
+  data: zod.z.instanceof(Uint8Array),
   sampleRate: zod.z.number(),
   channels: zod.z.number(),
   timestamp: zod.z.number(),
@@ -2422,7 +2453,23 @@ const RunnerCameraConfigSchema = zod.z.object({
    * whenever its `zones` device-state slice changes, so the runner's
    * copy stays in sync. Empty array → no zone filtering.
    */
-  zones: zod.z.array(ZoneSchema).readonly().default([])
+  zones: zod.z.array(ZoneSchema).readonly().default([]),
+  /**
+   * When true (default) and the camera's `motionSources` contains only
+   * `'onboard'`, the runner dynamically opens the same WASM frame-diff
+   * motion-frames subscription on each `MotionOnMotionChanged
+   * source:'onboard'` event and tears it down after `motionCooldownMs`.
+   * This causes `runMotionAnalysis` to emit `MotionZonesRaw` /
+   * `MotionAnalysis` during active-motion windows without the
+   * substream being held open continuously.
+   *
+   * Set to `false` to disable the dynamic analyzer for this camera
+   * (e.g. very low-bandwidth links where the extra substream is
+   * undesirable). Has no effect when `motionSources` already includes
+   * `'analyzer'` — the analyzer runs continuously in that case and
+   * this gate is bypassed.
+   */
+  onboardMotionDrivesAnalyzer: zod.z.boolean().default(true)
 });
 const RunnerCameraDeviceUIFields = [
   {
@@ -2482,6 +2529,16 @@ const RunnerCameraDeviceUIFields = [
     showValue: true,
     unit: "s",
     displayScale: 1e3
+  },
+  // Only meaningful for onboard-only cameras — when `motionSources`
+  // contains `'analyzer'` the analyzer runs continuously already.
+  {
+    key: "onboardMotionDrivesAnalyzer",
+    type: "boolean",
+    label: "Run motion analyzer on onboard motion",
+    description: "When onboard motion is detected, temporarily start the frame-diff analyzer to emit zone results. Stops after the motion cooldown window.",
+    default: true,
+    showWhen: { field: "motionSources", includes: "onboard" }
   }
 ];
 const RunnerLocalLoadSchema = zod.z.object({
@@ -2660,22 +2717,68 @@ const motionTriggerCapability = {
   },
   runtimeState: MotionTriggerRuntimeStateSchema
 };
+const MaskPointSchema = zod.z.object({
+  x: zod.z.number(),
+  y: zod.z.number()
+});
+const MaskRectShapeSchema = zod.z.object({
+  kind: zod.z.literal("rect"),
+  x: zod.z.number(),
+  y: zod.z.number(),
+  width: zod.z.number(),
+  height: zod.z.number()
+});
+const MaskPolygonShapeSchema = zod.z.object({
+  kind: zod.z.literal("polygon"),
+  points: zod.z.array(MaskPointSchema)
+});
+const MaskGridShapeSchema = zod.z.object({
+  kind: zod.z.literal("grid"),
+  gridWidth: zod.z.number(),
+  gridHeight: zod.z.number(),
+  cells: zod.z.array(zod.z.boolean())
+});
+const MaskLineShapeSchema = zod.z.object({
+  kind: zod.z.literal("line"),
+  points: zod.z.array(MaskPointSchema)
+});
+const MaskShapeSchema = zod.z.discriminatedUnion("kind", [
+  MaskRectShapeSchema,
+  MaskPolygonShapeSchema,
+  MaskGridShapeSchema,
+  MaskLineShapeSchema
+]);
+const MaskShapeKindSchema = zod.z.enum(["rect", "polygon", "grid", "line"]);
+const MaskPolygonVerticesSchema = zod.z.object({
+  min: zod.z.number(),
+  max: zod.z.number()
+});
+const MaskGridDimsSchema = zod.z.object({
+  width: zod.z.number(),
+  height: zod.z.number()
+});
+const MotionZoneRegionSchema = zod.z.object({
+  id: zod.z.number(),
+  enabled: zod.z.boolean(),
+  shape: MaskGridShapeSchema
+});
 const MotionZoneStatusSchema = zod.z.object({
   enabled: zod.z.boolean(),
   sensitivity: zod.z.number(),
-  /** Row-major active-cell grid. Length = gridWidth*gridHeight (see getOptions). */
-  cells: zod.z.array(zod.z.boolean()),
+  /** Grid region(s). Today exactly one `grid` shape. */
+  regions: zod.z.array(MotionZoneRegionSchema),
   lastFetchedAt: zod.z.number()
 });
 const MotionZoneOptionsSchema = zod.z.object({
-  gridWidth: zod.z.number(),
-  gridHeight: zod.z.number(),
+  maxRegions: zod.z.number(),
+  supportedShapes: zod.z.array(MaskShapeKindSchema),
+  grid: MaskGridDimsSchema,
   sensitivity: zod.z.object({ min: zod.z.number(), max: zod.z.number(), step: zod.z.number() })
 });
 const MotionZonePatchSchema = zod.z.object({
   enabled: zod.z.boolean().optional(),
   sensitivity: zod.z.number().optional(),
-  cells: zod.z.array(zod.z.boolean()).optional()
+  regions: zod.z.array(MotionZoneRegionSchema).optional()
 });
 const motionZonesCapability = {
   name: "motion-zones",
@@ -2696,6 +2799,118 @@ const motionZonesCapability = {
   status: { schema: MotionZoneStatusSchema, kind: "poll" },
   runtimeState: MotionZoneStatusSchema
 };
+const NativeObjectClassEnum = zod.z.enum([
+  "person",
+  "vehicle",
+  "animal",
+  "face",
+  "package",
+  "other"
+]);
+const NativeDetectionSchema = zod.z.object({
+  class: NativeObjectClassEnum,
+  timestamp: zod.z.number(),
+  /** Firmware-provided confidence [0..1]. Reolink pushes don't carry it → undefined. */
+  confidence: zod.z.number().min(0).max(1).optional()
+});
+const NativeObjectDetectionStatusSchema = zod.z.object({
+  /**
+   * Last observed instance per class. Missing entries mean the class
+   * is supported but nothing has been seen since the provider started.
+   *
+   * MUST be a partial record: providers seed an empty `{}` on cold-start
+   * and write one class at a time as detections arrive. In Zod 4
+   * `z.record(enum, …)` is EXHAUSTIVE (requires every enum key), so a
+   * partial write throws "expected object, received undefined" for every
+   * unseen class. `z.partialRecord` keeps the enum-key narrowing while
+   * allowing the sparse shape the providers actually write.
+   */
+  lastByClass: zod.z.partialRecord(NativeObjectClassEnum, NativeDetectionSchema.nullable()),
+  /** Classes the firmware is capable of detecting — enumerated at device register. */
+  supportedClasses: zod.z.array(NativeObjectClassEnum).readonly(),
+  /**
+   * Whether forwarding of onboard AI detections is enabled for this device.
+   * Default true (on cold-start) — detections flow unconditionally before
+   * the toggle is saved, so defaulting true preserves existing behaviour.
+   */
+  enabled: zod.z.boolean()
+});
+const NativeObjectDetectionRuntimeStateSchema = NativeObjectDetectionStatusSchema.extend({
+  /** Required by createRuntimeStateBridge — epoch ms of last refresh. */
+  lastFetchedAt: zod.z.number()
+});
+const nativeObjectDetectionCapability = {
+  name: "native-object-detection",
+  scope: "device",
+  mode: "singleton",
+  deviceTypes: [DeviceType.Camera],
+  methods: {
+    setEnabled: method(
+      zod.z.object({ deviceId: zod.z.number(), enabled: zod.z.boolean() }),
+      zod.z.void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  },
+  events: {
+    onDetected: { data: zod.z.object({
+      deviceId: zod.z.number(),
+      detection: NativeDetectionSchema
+    }) }
+  },
+  status: {
+    schema: NativeObjectDetectionStatusSchema,
+    kind: "push"
+  },
+  runtimeState: NativeObjectDetectionRuntimeStateSchema
+};
+const PrivacyMaskShapeSchema = zod.z.discriminatedUnion("kind", [
+  MaskRectShapeSchema,
+  MaskPolygonShapeSchema
+]);
+const PrivacyMaskRegionSchema = zod.z.object({
+  /** Slot id, 0-based. Stable across read/write. */
+  id: zod.z.number(),
+  /** Whether this zone is active (blanked out by the camera). */
+  enabled: zod.z.boolean(),
+  shape: PrivacyMaskShapeSchema
+});
+const PrivacyMaskStatusSchema = zod.z.object({
+  enabled: zod.z.boolean(),
+  /** Active zones (normalized 0..1). Length ≤ maxRegions. */
+  regions: zod.z.array(PrivacyMaskRegionSchema),
+  lastFetchedAt: zod.z.number()
+});
+const PrivacyMaskOptionsSchema = zod.z.object({
+  /** Maximum number of supported zones. */
+  maxRegions: zod.z.number(),
+  /** Shape kinds this camera accepts — Reolink: ['rect']; Hikvision: ['rect','polygon']. */
+  supportedShapes: zod.z.array(MaskShapeKindSchema),
+  /** Polygon vertex bounds when 'polygon' is supported (Hikvision: {min:4,max:4}). */
+  polygonVertices: MaskPolygonVerticesSchema.optional()
+});
+const PrivacyMaskPatchSchema = zod.z.object({
+  enabled: zod.z.boolean().optional(),
+  regions: zod.z.array(PrivacyMaskRegionSchema).optional()
+});
+const privacyMaskCapability = {
+  name: "privacy-mask",
+  scope: "device",
+  mode: "singleton",
+  deviceTypes: [DeviceType.Camera],
+  deviceConfig: {
+    ui: { kind: "widget", widgetId: "host/privacy-mask-grid", tab: "image", label: "Privacy Mask" }
+  },
+  methods: {
+    getOptions: method(zod.z.object({ deviceId: zod.z.number() }), PrivacyMaskOptionsSchema),
+    setMask: method(
+      zod.z.object({ deviceId: zod.z.number(), patch: PrivacyMaskPatchSchema }),
+      zod.z.void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  },
+  status: { schema: PrivacyMaskStatusSchema, kind: "poll" },
+  runtimeState: PrivacyMaskStatusSchema
+};
 const AutotrackTargetTypeSchema = zod.z.string().describe("Vendor target string (people/vehicle/pet); empty = camera default");
 const PtzAutotrackSettingsSchema = zod.z.object({
   targetType: AutotrackTargetTypeSchema,
@@ -3287,7 +3502,8 @@ const addonSettingsCapability = {
       zod.z.object({
         addonId: zod.z.string(),
         nodeId: zod.z.string().optional(),
-        overlay: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+        overlay: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+        cap: zod.z.string().optional()
       }),
       SettingsSchemaWithValuesSchema.nullable()
     ),
@@ -4046,7 +4262,14 @@ const OauthIntegrationDescriptorSchema = zod.z.object({
   /** Allowed redirect_uri prefixes. /api/oauth2/authorize rejects any
    *  redirect_uri that does not start with one of these. Required —
    *  an empty list means the integration can never complete linking. */
-  allowedRedirectPrefixes: zod.z.array(zod.z.string()).min(1)
+  allowedRedirectPrefixes: zod.z.array(zod.z.string()).min(1),
+  /** Optional public origin (no trailing slash) that this integration's
+   *  issued codes/tokens should carry as the `hubUrl` claim — typically the
+   *  operator-selected external-access endpoint resolved by the addon. When
+   *  present, /api/oauth2/authorize bakes THIS into the code instead of the
+   *  hub-global `publicHubUrl()`, so a forked exporter addon (which can't set
+   *  the hub's env) drives the claim that its cloud Lambda routes back on. */
+  hubUrl: zod.z.string().optional()
 });
 const oauthIntegrationCapability = {
   name: "oauth-integration",
@@ -4750,7 +4973,20 @@ const webrtcSessionCapability = {
       zod.z.object({
         deviceId: zod.z.number().int().nonnegative(),
         target: WebrtcStreamTargetSchema,
-        hints: webrtcClientHintsSchema.optional()
+        hints: webrtcClientHintsSchema.optional(),
+        /**
+         * SERVER-INJECTED — NOT a client hint. The hub layer that holds
+         * the tRPC request context (and therefore the client IP) sets
+         * this to `true` when the viewer's source IP is non-LAN
+         * (4G/CGNAT/internet). The broker then forces TURN-relay-only
+         * ICE for the session so a CGNAT client (which can only offer a
+         * relay candidate) gets a clean relay↔relay media path instead
+         * of werift nominating a dead host/hairpin-srflx pair. LAN
+         * clients leave this absent/false and keep the low-latency
+         * direct (host/srflx) path. Clients MUST NOT send this — the
+         * server overwrites it from the request context.
+         */
+        relayOnly: zod.z.boolean().optional()
       }),
       zod.z.object({ sessionId: zod.z.string(), sdpOffer: zod.z.string() }),
       { kind: "mutation" }
@@ -4773,7 +5009,22 @@ const webrtcSessionCapability = {
         deviceId: zod.z.number().int().nonnegative(),
         target: WebrtcStreamTargetSchema.optional(),
         sdpOffer: zod.z.string(),
-        sessionId: zod.z.string().optional()
+        sessionId: zod.z.string().optional(),
+        /**
+         * Force TURN-relay-only ICE for this session. Two kinds of caller
+         * set it:
+         *  - A cloud peer like Alexa's RTCSessionController (reachable
+         *    only via TURN, never our host/srflx behind NAT) passes
+         *    `true` from its own trusted addon context.
+         *  - The hub injects it for browser client-offer viewers from the
+         *    request's source IP (non-LAN ⇒ true), exactly as it does for
+         *    `createSession`.
+         * A LAN/Tailscale browser doing client-offer passthrough leaves it
+         * absent/false so a direct host pair carries full native quality.
+         * Untrusted browser clients MUST NOT send it — the hub overwrites
+         * it from the request context.
+         */
+        relayOnly: zod.z.boolean().optional()
       }),
       zod.z.object({ sessionId: zod.z.string(), sdpAnswer: zod.z.string() }),
       { kind: "mutation" }
@@ -4787,6 +5038,46 @@ const webrtcSessionCapability = {
       zod.z.void(),
       { kind: "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.
+     */
+    addIceCandidate: method(
+      zod.z.object({
+        deviceId: zod.z.number().int().nonnegative(),
+        sessionId: zod.z.string(),
+        candidate: zod.z.string(),
+        sdpMid: zod.z.string().nullable().optional(),
+        sdpMLineIndex: zod.z.number().int().nullable().optional()
+      }),
+      zod.z.void(),
+      { kind: "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.
+     */
+    getIceCandidates: method(
+      zod.z.object({
+        deviceId: zod.z.number().int().nonnegative(),
+        sessionId: zod.z.string()
+      }),
+      zod.z.object({
+        candidates: zod.z.array(zod.z.object({
+          candidate: zod.z.string(),
+          sdpMid: zod.z.string().nullable(),
+          sdpMLineIndex: zod.z.number().int().nullable()
+        })),
+        done: zod.z.boolean()
+      }),
+      { kind: "query" }
+    ),
     closeSession: method(
       zod.z.object({
         deviceId: zod.z.number().int().nonnegative(),
@@ -6539,6 +6830,16 @@ const detectionPipelineCapability = {
   exposesDeviceSettings: true,
   methods: {}
 };
+const cameraPipelineConfigCapability = {
+  name: "camera-pipeline-config",
+  scope: "device",
+  mode: "singleton",
+  kind: "wrapper",
+  defaultActive: true,
+  deviceTypes: [DeviceType.Camera],
+  exposesDeviceSettings: true,
+  methods: {}
+};
 const TrackStateSchema = zod.z.enum(["new", "entered", "left", "moving", "idle"]);
 const EventKindSchema = zod.z.enum(["motion", "object", "audio"]);
 const TrackPositionSchema = zod.z.object({
@@ -7455,44 +7756,31 @@ const intercomCapability = {
     kind: "command-driven"
   }
 };
-const NativeObjectClassEnum = zod.z.enum([
-  "person",
-  "vehicle",
-  "animal",
-  "face",
-  "package",
-  "other"
-]);
-const NativeDetectionSchema = zod.z.object({
-  class: NativeObjectClassEnum,
-  timestamp: zod.z.number(),
-  /** Firmware-provided confidence [0..1]. Reolink pushes don't carry it → undefined. */
-  confidence: zod.z.number().min(0).max(1).optional()
-});
-const NativeObjectDetectionStatusSchema = zod.z.object({
-  /**
-   * Last observed instance per class. Undefined entries mean the class
-   * is supported but nothing has been seen since the provider started.
-   */
-  lastByClass: zod.z.record(NativeObjectClassEnum, NativeDetectionSchema.nullable()),
-  /** Classes the firmware is capable of detecting — enumerated at device register. */
-  supportedClasses: zod.z.array(NativeObjectClassEnum).readonly()
+const CamStreamDescriptorSchema = zod.z.object({
+  camStreamId: zod.z.string().min(1),
+  kind: CamStreamKindSchema,
+  url: zod.z.string().optional(),
+  codec: zod.z.string().optional(),
+  resolution: CamStreamResolutionSchema.optional(),
+  fps: zod.z.number().positive().optional(),
+  label: zod.z.string().optional(),
+  /** Device-level features (e.g. `battery-operated`) — drives broker policy. */
+  deviceFeatures: zod.z.array(zod.z.string()).optional(),
+  /** Eligible for automatic profile assignment. Absent = `true`. */
+  autoEligible: zod.z.boolean().optional(),
+  /** Transport-specific opaque metadata (e.g. rfc4571 SDP). */
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
 });
-const nativeObjectDetectionCapability = {
-  name: "native-object-detection",
+const streamCatalogCapability = {
+  name: "stream-catalog",
   scope: "device",
   mode: "singleton",
   deviceTypes: [DeviceType.Camera],
-  methods: {},
-  events: {
-    onDetected: { data: zod.z.object({
-      deviceId: zod.z.number(),
-      detection: NativeDetectionSchema
-    }) }
-  },
-  status: {
-    schema: NativeObjectDetectionStatusSchema,
-    kind: "push"
+  methods: {
+    getCatalog: method(
+      zod.z.object({ deviceId: zod.z.number().int().nonnegative() }),
+      zod.z.array(CamStreamDescriptorSchema).readonly()
+    )
   }
 };
 const ModelFormatSchema = zod.z.enum(MODEL_FORMATS);
@@ -8729,7 +9017,8 @@ const PackageUpdateSchema = zod.z.object({
   currentVersion: zod.z.string(),
   latestVersion: zod.z.string(),
   category: zod.z.enum(["addon", "core"]),
-  requiresRestart: zod.z.boolean()
+  requiresRestart: zod.z.boolean(),
+  isSystem: zod.z.boolean()
 });
 const PackageVersionInfoSchema = zod.z.object({
   version: zod.z.string(),
@@ -8762,6 +9051,42 @@ const UpdateFrameworkPackageResultSchema = zod.z.object({
   /** Ms-epoch the server scheduled its self-restart. */
   restartingAt: zod.z.number()
 });
+const BulkUpdateItemStatusSchema = zod.z.enum([
+  "queued",
+  "updating",
+  "done",
+  "done-pending-restart",
+  "failed"
+]);
+const BulkUpdateItemSchema = zod.z.object({
+  name: zod.z.string(),
+  isSystem: zod.z.boolean(),
+  fromVersion: zod.z.string(),
+  toVersion: zod.z.string(),
+  status: BulkUpdateItemStatusSchema,
+  error: zod.z.string().optional(),
+  startedAtMs: zod.z.number().optional(),
+  completedAtMs: zod.z.number().optional()
+});
+const BulkUpdatePhaseSchema = zod.z.enum([
+  "regular",
+  "system",
+  "restarting",
+  "finalizing"
+]);
+const BulkUpdateStateSchema = zod.z.object({
+  id: zod.z.string(),
+  nodeId: zod.z.string(),
+  startedAtMs: zod.z.number(),
+  completedAtMs: zod.z.number().optional(),
+  total: zod.z.number(),
+  completed: zod.z.number(),
+  failed: zod.z.number(),
+  current: zod.z.string().nullable(),
+  phase: BulkUpdatePhaseSchema,
+  cancelled: zod.z.boolean(),
+  items: zod.z.array(BulkUpdateItemSchema).readonly()
+});
 const FrameworkPackageStatusSchema = zod.z.object({
   packageName: zod.z.string(),
   currentVersion: zod.z.string(),
@@ -8903,7 +9228,7 @@ const addonsCapability = {
     getLastRestart: method(
       zod.z.void(),
       zod.z.object({
-        kind: zod.z.enum(["framework-update", "manual", "system"]),
+        kind: zod.z.enum(["framework-update", "manual", "system", "framework-bulk-update"]),
         packageName: zod.z.string().optional(),
         fromVersion: zod.z.string().optional(),
         toVersion: zod.z.string().optional(),
@@ -8993,11 +9318,70 @@ const addonsCapability = {
     updateFrameworkPackage: method(
       zod.z.object({
         packageName: zod.z.string().min(1),
-        version: zod.z.string().optional()
+        version: zod.z.string().optional(),
+        deferRestart: zod.z.boolean().optional()
       }),
       UpdateFrameworkPackageResultSchema,
       { kind: "mutation", auth: "admin" }
     ),
+    /**
+     * Kicks off a server-side bulk update operation and returns the bulk
+     * id immediately. The operation runs asynchronously; observe progress
+     * via the `AddonsBulkUpdateProgress` event or `getBulkUpdateState`.
+     * Items with `isSystem: true` use `deferRestart` — the hub restarts
+     * ONCE at the end of the system phase, after all system packages are
+     * installed.
+     *
+     * `items[].version` is REQUIRED — callers must pass the resolved
+     * version from `listUpdates`. There is no `'latest'` default here
+     * (unlike `updatePackage`) to guarantee deterministic bulk rolls.
+     */
+    startBulkUpdate: method(
+      zod.z.object({
+        nodeId: zod.z.string(),
+        items: zod.z.array(zod.z.object({
+          name: zod.z.string(),
+          version: zod.z.string(),
+          isSystem: zod.z.boolean()
+        })).readonly()
+      }),
+      zod.z.object({ id: zod.z.string() }),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Returns the current state of a bulk update by id.
+     * Returns `null` if the id is unknown or has been auto-cleaned
+     * (5 minutes after `completedAt` the record is evicted from memory).
+     */
+    getBulkUpdateState: method(
+      zod.z.object({ id: zod.z.string() }),
+      BulkUpdateStateSchema.nullable(),
+      { auth: "admin" }
+    ),
+    /**
+     * Cancels an in-flight bulk update. The update loop exits after the
+     * currently-processing item completes — cancellation is not
+     * instantaneous. Has no effect once the `restarting` phase has been
+     * entered (the hub is already shutting down at that point).
+     * Returns `{ cancelled: false }` if the id is unknown, the operation
+     * has already completed, or the `restarting` phase is active.
+     */
+    cancelBulkUpdate: method(
+      zod.z.object({ id: zod.z.string() }),
+      zod.z.object({ cancelled: zod.z.boolean() }),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Lists all currently active (non-completed) bulk updates.
+     * If `nodeId` is provided, filters to only bulk updates targeting
+     * that node. Useful for restoring an in-progress banner on a fresh
+     * page load when the UI reconnects mid-operation.
+     */
+    listActiveBulkUpdates: method(
+      zod.z.object({ nodeId: zod.z.string().optional() }),
+      zod.z.array(BulkUpdateStateSchema).readonly(),
+      { auth: "admin" }
+    ),
     getVersions: method(
       zod.z.object({ name: zod.z.string() }),
       zod.z.array(PackageVersionInfoSchema).readonly()
@@ -9137,6 +9521,7 @@ exports.BrokerStatsSchema = BrokerStatsSchema;
 exports.BrokerStatusSchema = BrokerStatusSchema$1;
 exports.CAM_PROFILE_ORDER = CAM_PROFILE_ORDER;
 exports.CamProfileSchema = CamProfileSchema;
+exports.CamStreamDescriptorSchema = CamStreamDescriptorSchema;
 exports.CamStreamKindSchema = CamStreamKindSchema;
 exports.CamStreamResolutionSchema = CamStreamResolutionSchema;
 exports.CameraCredentialsSchema = CameraCredentialsSchema;
@@ -9221,6 +9606,15 @@ exports.LogEntrySchema = LogEntrySchema;
 exports.LogLevelSchema = LogLevelSchema$1;
 exports.LogStreamEntrySchema = LogStreamEntrySchema;
 exports.MODEL_FORMATS = MODEL_FORMATS;
+exports.MaskGridDimsSchema = MaskGridDimsSchema;
+exports.MaskGridShapeSchema = MaskGridShapeSchema;
+exports.MaskLineShapeSchema = MaskLineShapeSchema;
+exports.MaskPointSchema = MaskPointSchema;
+exports.MaskPolygonShapeSchema = MaskPolygonShapeSchema;
+exports.MaskPolygonVerticesSchema = MaskPolygonVerticesSchema;
+exports.MaskRectShapeSchema = MaskRectShapeSchema;
+exports.MaskShapeKindSchema = MaskShapeKindSchema;
+exports.MaskShapeSchema = MaskShapeSchema;
 exports.MediaFileSchema = MediaFileSchema;
 exports.MeshPeerSchema = MeshPeerSchema;
 exports.MeshStatusSchema = MeshStatusSchema;
@@ -9236,9 +9630,11 @@ exports.MotionTriggerRuntimeStateSchema = MotionTriggerRuntimeStateSchema;
 exports.MotionTriggerStatusSchema = MotionTriggerStatusSchema;
 exports.MotionZoneOptionsSchema = MotionZoneOptionsSchema;
 exports.MotionZonePatchSchema = MotionZonePatchSchema;
+exports.MotionZoneRegionSchema = MotionZoneRegionSchema;
 exports.MotionZoneStatusSchema = MotionZoneStatusSchema;
 exports.NativeDetectionSchema = NativeDetectionSchema;
 exports.NativeObjectClassEnum = NativeObjectClassEnum;
+exports.NativeObjectDetectionRuntimeStateSchema = NativeObjectDetectionRuntimeStateSchema;
 exports.NativeObjectDetectionStatusSchema = NativeObjectDetectionStatusSchema;
 exports.NetworkAccessStatusSchema = NetworkAccessStatusSchema;
 exports.NetworkAddressSchema = NetworkAddressSchema;
@@ -9268,6 +9664,11 @@ exports.PipelineRunResultBridge = PipelineRunResultBridge;
 exports.PipelineStepInputSchema = PipelineStepInputSchema;
 exports.PlaceholderReasonSchema = PlaceholderReasonSchema;
 exports.PolygonPointSchema = PolygonPointSchema;
+exports.PrivacyMaskOptionsSchema = PrivacyMaskOptionsSchema;
+exports.PrivacyMaskPatchSchema = PrivacyMaskPatchSchema;
+exports.PrivacyMaskRegionSchema = PrivacyMaskRegionSchema;
+exports.PrivacyMaskShapeSchema = PrivacyMaskShapeSchema;
+exports.PrivacyMaskStatusSchema = PrivacyMaskStatusSchema;
 exports.ProfileSlotSchema = ProfileSlotSchema;
 exports.ProfileSlotStatusSchema = ProfileSlotStatusSchema;
 exports.ProviderInfoSchema = ProviderInfoSchema;
@@ -9382,6 +9783,7 @@ exports.backupCapability = backupCapability;
 exports.batteryCapability = batteryCapability;
 exports.brightnessCapability = brightnessCapability;
 exports.cameraCredentialsCapability = cameraCredentialsCapability;
+exports.cameraPipelineConfigCapability = cameraPipelineConfigCapability;
 exports.cameraStreamsCapability = cameraStreamsCapability;
 exports.decoderCapability = decoderCapability;
 exports.detectionPipelineCapability = detectionPipelineCapability;
@@ -9428,6 +9830,7 @@ exports.pipelineExecutorCapability = pipelineExecutorCapability;
 exports.pipelineOrchestratorCapability = pipelineOrchestratorCapability;
 exports.pipelineRunnerCapability = pipelineRunnerCapability;
 exports.platformProbeCapability = platformProbeCapability;
+exports.privacyMaskCapability = privacyMaskCapability;
 exports.ptzAutotrackCapability = ptzAutotrackCapability;
 exports.ptzCapability = ptzCapability;
 exports.rebootCapability = rebootCapability;
@@ -9443,6 +9846,7 @@ exports.ssoBridgeCapability = ssoBridgeCapability;
 exports.storageCapability = storageCapability;
 exports.storageProviderCapability = storageProviderCapability;
 exports.streamBrokerCapability = streamBrokerCapability;
+exports.streamCatalogCapability = streamCatalogCapability;
 exports.streamParamsCapability = streamParamsCapability;
 exports.streamingEngineCapability = streamingEngineCapability;
 exports.switchCapability = switchCapability;
@@ -9454,7 +9858,12 @@ exports.userPasskeysCapability = userPasskeysCapability;
 exports.webrtcCapability = webrtcCapability;
 exports.webrtcClientHintsSchema = webrtcClientHintsSchema;
 exports.webrtcSessionCapability = webrtcSessionCapability;
+exports.wiringAddonHealthSchema = wiringAddonHealthSchema;
+exports.wiringHealthSnapshotSchema = wiringHealthSnapshotSchema;
+exports.wiringNodeHealthSchema = wiringNodeHealthSchema;
+exports.wiringProbeKindSchema = wiringProbeKindSchema;
+exports.wiringProbeResultSchema = wiringProbeResultSchema;
 exports.zoneAnalyticsCapability = zoneAnalyticsCapability;
 exports.zoneRulesCapability = zoneRulesCapability;
 exports.zonesCapability = zonesCapability;
-//# sourceMappingURL=index-CMM1Y9W6.js.map
+//# sourceMappingURL=index-DnpdVFKv.js.map