@camstack/types 0.1.40 → 0.1.41

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { h as hydrateSchema, e as errMsg, z as zonesCapability, a as zoneRulesCapability, b as zoneAnalyticsCapability, s as switchCapability, c as streamParamsCapability, p as ptzAutotrackCapability, d as privacyMaskCapability, n as nativeObjectDetectionCapability, m as motionZonesCapability, f as motionTriggerCapability, g as motionCapability, i as featureProbeCapability, j as doorbellCapability, k as deviceStatusCapability, l as deviceDiscoveryCapability, o as cameraStreamsCapability, q as brightnessCapability, r as batteryCapability, t as audioMetricsCapability, u as deviceProviderCapability, v as accessoriesCapability, w as addonPagesCapability, x as addonPagesSourceCapability, y as addonRoutesCapability, A as addonSettingsCapability, B as addonWidgetsCapability, C as addonWidgetsSourceCapability, D as addonsCapability, E as adminUiCapability, F as advancedNotifierCapability, G as alertsCapability, H as audioAnalysisCapability, I as audioAnalyzerCapability, J as audioCodecCapability, K as authProviderCapability, L as backupCapability, M as cameraCredentialsCapability, N as cameraPipelineConfigCapability, O as decoderCapability, P as detectionPipelineCapability, Q as deviceExportCapability, R as deviceManagerCapability, S as deviceOpsCapability, T as deviceStateCapability, U as embeddingEncoderCapability, V as eventsCapability, W as integrationsCapability, X as intercomCapability, Y as localNetworkCapability, Z as logDestinationCapability, _ as meshNetworkCapability, $ as metricsProviderCapability, a0 as motionDetectionCapability, a1 as mqttBrokerCapability, a2 as networkAccessCapability, a3 as networkQualityCapability, a4 as nodesCapability, a5 as notificationOutputCapability, a6 as oauthIntegrationCapability, a7 as osdCapability, a8 as pipelineAnalyticsCapability, a9 as pipelineExecutorCapability, aa as pipelineOrchestratorCapability, ab as pipelineRunnerCapability, ac as platformProbeCapability, ad as ptzCapability, ae as rebootCapability, af as recordingCapability, ag as recordingEngineCapability, ah as restreamerCapability, ai as settingsStoreCapability, aj as smtpProviderCapability, ak as snapshotCapability, al as snapshotProviderCapability, am as ssoBridgeCapability, an as storageCapability, ao as storageProviderCapability, ap as streamBrokerCapability, aq as streamCatalogCapability, ar as streamingEngineCapability, as as systemCapability, at as toastCapability, au as turnProviderCapability, av as userManagementCapability, aw as userPasskeysCapability, ax as webrtcCapability, ay as webrtcSessionCapability } from "./index-C2zzIDdX.mjs";
-import { az, aA, aB, aC, aD, aE, aF, aG, aH, aI, aJ, aK, aL, aM, aN, aO, aP, aQ, aR, aS, aT, aU, aV, aW, aX, aY, aZ, a_, a$, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf, bg, bh, bi, bj, bk, bl, bm, bn, bo, bp, bq, br, bs, bt, bu, bv, bw, bx, by, bz, bA, bB, bC, bD, bE, bF, bG, bH, bI, bJ, bK, bL, bM, bN, bO, bP, bQ, bR, bS, bT, bU, bV, bW, bX, bY, bZ, b_, b$, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf, cg, ch, ci, cj, ck, cl, cm, cn, co, cp, cq, cr, cs, ct, cu, cv, cw, cx, cy, cz, cA, cB, cC, cD, cE, cF, cG, cH, cI, cJ, cK, cL, cM, cN, cO, cP, cQ, cR, cS, cT, cU, cV, cW, cX, cY, cZ, c_, c$, d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, da, db, dc, dd, de, df, dg, dh, di, dj, dk, dl, dm, dn, dp, dq, dr, ds, dt, du, dv, dw, dx, dy, dz, dA, dB, dC, dD, dE, dF, dG, dH, dI, dJ, dK, dL, dM, dN, dO, dP, dQ, dR, dS, dT, dU, dV, dW, dX, dY, dZ, d_, d$, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ea, eb, ec, ed, ee, ef, eg, eh, ei, ej, ek, el, em, en, eo, ep, eq, er, es, et, eu, ev, ew, ex, ey, ez, eA, eB, eC, eD, eE, eF, eG, eH, eI, eJ, eK, eL, eM, eN, eO, eP, eQ, eR, eS, eT, eU, eV, eW, eX, eY, eZ, e_, e$, f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, fa, fb, fc, fd, fe, ff, fg, fh, fi, fj, fk, fl, fm, fn, fo, fp, fq, fr, fs, ft, fu, fv } from "./index-C2zzIDdX.mjs";
+import { h as hydrateSchema, e as errMsg, z as zonesCapability, a as zoneRulesCapability, b as zoneAnalyticsCapability, w as weatherCapability, c as waterHeaterCapability, v as vibrationCapability, d as valveCapability, f as vacuumControlCapability, u as updateCapability, t as temperatureSensorCapability, g as tamperCapability, s as switchCapability, i as streamParamsCapability, j as smokeCapability, k as scriptRunnerCapability, p as ptzAutotrackCapability, l as privacyMaskCapability, m as pressureSensorCapability, n as presenceCapability, o as powerMeterCapability, q as numericSensorCapability, r as notifierCapability, x as nativeObjectDetectionCapability, y as motionZonesCapability, A as motionTriggerCapability, B as motionCapability, C as mediaPlayerCapability, D as lockControlCapability, E as lawnMowerControlCapability, F as imageCapability, G as humiditySensorCapability, H as humidifierCapability, I as gasCapability, J as floodCapability, K as featureProbeCapability, L as fanControlCapability, M as eventEmitterCapability, N as enumSensorCapability, O as doorbellCapability, P as deviceStatusCapability, Q as deviceDiscoveryCapability, R as coverCapability, S as controlCapability, T as contactCapability, U as consumablesCapability, V as connectivityCapability, W as colorCapability, X as climateControlCapability, Y as carbonMonoxideCapability, Z as cameraStreamsCapability, _ as brightnessCapability, $ as binaryCapability, a0 as batteryCapability, a1 as automationControlCapability, a2 as audioMetricsCapability, a3 as ambientLightSensorCapability, a4 as alarmPanelCapability, a5 as airQualitySensorCapability, a6 as extractSourceInfoFromMetadata, a7 as synthesizeSourceInfo, a8 as mergeSourceInfo, a9 as SOURCE_INFO_METADATA_KEY, aa as deviceProviderCapability, ab as accessoriesCapability, ac as addonPagesCapability, ad as addonPagesSourceCapability, ae as addonRoutesCapability, af as addonSettingsCapability, ag as addonWidgetsCapability, ah as addonWidgetsSourceCapability, ai as addonsCapability, aj as adminUiCapability, ak as advancedNotifierCapability, al as alertsCapability, am as audioAnalysisCapability, an as audioAnalyzerCapability, ao as audioCodecCapability, ap as authProviderCapability, aq as backupCapability, ar as brokerCapability, as as buttonCapability, at as cameraCredentialsCapability, au as cameraPipelineConfigCapability, av as decoderCapability, aw as detectionPipelineCapability, ax as deviceAdoptionCapability, ay as deviceExportCapability, az as deviceManagerCapability, aA as deviceOpsCapability, aB as deviceStateCapability, aC as embeddingEncoderCapability, aD as eventsCapability, aE as integrationsCapability, aF as intercomCapability, aG as localNetworkCapability, aH as logDestinationCapability, aI as meshNetworkCapability, aJ as metricsProviderCapability, aK as motionDetectionCapability, aL as mqttBrokerCapability, aM as networkAccessCapability, aN as networkQualityCapability, aO as nodesCapability, aP as notificationOutputCapability, aQ as oauthIntegrationCapability, aR as osdCapability, aS as pipelineAnalyticsCapability, aT as pipelineExecutorCapability, aU as pipelineOrchestratorCapability, aV as pipelineRunnerCapability, aW as platformProbeCapability, aX as ptzCapability, aY as rebootCapability, aZ as recordingCapability, a_ as restreamerCapability, a$ as settingsStoreCapability, b0 as smtpProviderCapability, b1 as snapshotCapability, b2 as snapshotProviderCapability, b3 as ssoBridgeCapability, b4 as storageCapability, b5 as storageEvictableCapability, b6 as storageProviderCapability, b7 as streamBrokerCapability, b8 as streamCatalogCapability, b9 as streamingEngineCapability, ba as systemCapability, bb as toastCapability, bc as turnProviderCapability, bd as userManagementCapability, be as userPasskeysCapability, bf as webrtcCapability, bg as webrtcSessionCapability } from "./index-Bpj3ScIH.mjs";
+import { bh, bi, bj, bk, bl, bm, bn, bo, bp, bq, br, bs, bt, bu, bv, bw, bx, by, bz, bA, bB, bC, bD, bE, bF, bG, bH, bI, bJ, bK, bL, bM, bN, bO, bP, bQ, bR, bS, bT, bU, bV, bW, bX, bY, bZ, b_, b$, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf, cg, ch, ci, cj, ck, cl, cm, cn, co, cp, cq, cr, cs, ct, cu, cv, cw, cx, cy, cz, cA, cB, cC, cD, cE, cF, cG, cH, cI, cJ, cK, cL, cM, cN, cO, cP, cQ, cR, cS, cT, cU, cV, cW, cX, cY, cZ, c_, c$, d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, da, db, dc, dd, de, df, dg, dh, di, dj, dk, dl, dm, dn, dp, dq, dr, ds, dt, du, dv, dw, dx, dy, dz, dA, dB, dC, dD, dE, dF, dG, dH, dI, dJ, dK, dL, dM, dN, dO, dP, dQ, dR, dS, dT, dU, dV, dW, dX, dY, dZ, d_, d$, e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ea, eb, ec, ed, ee, ef, eg, eh, ei, ej, ek, el, em, en, eo, ep, eq, er, es, et, eu, ev, ew, ex, ey, ez, eA, eB, eC, eD, eE, eF, eG, eH, eI, eJ, eK, eL, eM, eN, eO, eP, eQ, eR, eS, eT, eU, eV, eW, eX, eY, eZ, e_, e$, f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, fa, fb, fc, fd, fe, ff, fg, fh, fi, fj, fk, fl, fm, fn, fo, fp, fq, fr, fs, ft, fu, fv, fw, fx, fy, fz, fA, fB, fC, fD, fE, fF, fG, fH, fI, fJ, fK, fL, fM, fN, fO, fP, fQ, fR, fS, fT, fU, fV, fW, fX, fY, fZ, f_, f$, g0, g1, g2, g3, g4, g5, g6, g7, g8, g9, ga, gb, gc, gd, ge, gf, gg, gh, gi, gj, gk, gl, gm, gn, go, gp, gq, gr, gs, gt, gu, gv, gw, gx, gy, gz, gA, gB, gC, gD, gE, gF, gG, gH, gI, gJ, gK, gL, gM, gN, gO, gP, gQ, gR, gS, gT, gU, gV, gW, gX, gY, gZ, g_, g$, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, ha, hb, hc, hd, he, hf, hg, hh, hi, hj, hk, hl, hm, hn, ho, hp, hq, hr, hs, ht, hu, hv, hw, hx, hy, hz, hA, hB, hC, hD, hE, hF, hG, hH, hI, hJ, hK, hL, hM, hN, hO, hP, hQ, hR, hS, hT } from "./index-Bpj3ScIH.mjs";
 import { z } from "zod";
 class DisposerChain {
   disposers = [];
@@ -119,10 +119,15 @@ var EventCategory = /* @__PURE__ */ ((EventCategory2) => {
   EventCategory2["DeviceSettingsUpdated"] = "device.settings-updated";
   EventCategory2["DeviceBindingsChanged"] = "device.bindings-changed";
   EventCategory2["DeviceMetaChanged"] = "device.meta-changed";
+  EventCategory2["DeviceSourceInfoChanged"] = "device.source-info-changed";
   EventCategory2["DeviceStreamsRegistered"] = "device.streams-registered";
+  EventCategory2["DeviceProvisioned"] = "device.provisioned";
+  EventCategory2["DeviceReady"] = "device.ready";
   EventCategory2["IntegrationEnabled"] = "integration.enabled";
   EventCategory2["IntegrationDisabled"] = "integration.disabled";
   EventCategory2["IntegrationDeleted"] = "integration.deleted";
+  EventCategory2["BrokerStatusChanged"] = "broker.status-changed";
+  EventCategory2["BrokerMessage"] = "broker.message";
   EventCategory2["ProviderStarted"] = "provider.started";
   EventCategory2["ProviderStopped"] = "provider.stopped";
   EventCategory2["ProcessCrashed"] = "process.crashed";
@@ -156,7 +161,9 @@ var EventCategory = /* @__PURE__ */ ((EventCategory2) => {
   EventCategory2["StreamParamsChanged"] = "stream-params.changed";
   EventCategory2["DeviceStateChanged"] = "device.state-changed";
   EventCategory2["BatteryOnStatusChanged"] = "battery.onStatusChanged";
+  EventCategory2["BatteryOnWakeStarted"] = "battery.onWakeStarted";
   EventCategory2["DoorbellOnPressed"] = "doorbell.onPressed";
+  EventCategory2["EventEmitted"] = "event-emitter.event";
   EventCategory2["PipelineEngineMetricsSnapshot"] = "pipeline.engine-metrics-snapshot";
   EventCategory2["ClusterTopologySnapshot"] = "cluster.topology-snapshot";
   EventCategory2["MetricsNodeResourcesSnapshot"] = "metrics.node-resources-snapshot";
@@ -242,6 +249,27 @@ function emitReadiness(bus, params) {
     }
   ));
 }
+function createDurableState(deps) {
+  const get = async () => {
+    const store = await deps.read();
+    const raw = store[deps.key];
+    if (raw === void 0) return deps.fallback;
+    const parsed = deps.schema.safeParse(raw);
+    if (!parsed.success) {
+      deps.onParseError?.(deps.key, parsed.error);
+      return deps.fallback;
+    }
+    return parsed.data;
+  };
+  const set = async (next) => {
+    const validated = deps.schema.parse(next);
+    await deps.write({ [deps.key]: validated });
+  };
+  const update = async (fn2) => {
+    await set(fn2(await get()));
+  };
+  return { get, set, update };
+}
 class BaseAddon {
   _ctx = null;
   _config;
@@ -485,12 +513,18 @@ class BaseAddon {
   // ── Lifecycle event emission ────────────────────────────────────────────
   emitLifecycle(category, data) {
     try {
-      this._ctx?.eventBus.emit({
-        id: `${this._ctx.id}-${Date.now()}`,
+      const ctx = this._ctx;
+      if (!ctx) return;
+      ctx.eventBus.emit({
+        id: `${ctx.id}-${Date.now()}`,
         timestamp: /* @__PURE__ */ new Date(),
-        source: { type: "addon", id: this._ctx.id, nodeId: this._ctx.kernel.localNodeId ?? "hub" },
+        source: { type: "addon", id: ctx.id, nodeId: ctx.kernel.localNodeId ?? "hub" },
         category,
-        data: data ?? {}
+        // Always carry `addonId` in the payload (the lifecycle event
+        // contract declares it) so consumers — e.g. the alerts builder —
+        // can name the addon without reaching into `source`. An explicit
+        // `data.addonId` still wins if a caller provides one.
+        data: { addonId: ctx.id, ...data ?? {} }
       });
     } catch {
     }
@@ -563,6 +597,44 @@ class BaseAddon {
     }
     this._config = resolved;
   }
+  /**
+   * Typed durable handle over ONE key of this addon's store. The whole
+   * Zod-validated value round-trips on every read/write — no hand-listed
+   * fields, so a field can never be silently dropped on persist. Reads use
+   * the same retry budget as config resolution; a corrupt/legacy blob logs
+   * a warning and falls back rather than crashing boot.
+   */
+  state(key, schema, fallback) {
+    return createDurableState({
+      key,
+      schema,
+      fallback,
+      read: () => this.readAddonStoreWithRetry(),
+      write: async (patch) => {
+        await this._ctx?.settings?.writeAddonStore(patch);
+      },
+      onParseError: (k, e) => this._ctx?.logger?.warn?.(
+        `durable-state: stored "${k}" failed validation — using fallback`,
+        { meta: { addonId: this._ctx?.id, key: k, error: String(e) } }
+      )
+    });
+  }
+  /** Per-device variant of {@link state}, backed by the per-device store. */
+  deviceState(deviceId, key, schema, fallback) {
+    return createDurableState({
+      key,
+      schema,
+      fallback,
+      read: async () => await this._ctx?.settings?.readDeviceStore(deviceId) ?? {},
+      write: async (patch) => {
+        await this._ctx?.settings?.writeDeviceStore(deviceId, patch);
+      },
+      onParseError: (k, e) => this._ctx?.logger?.warn?.(
+        `durable-state: stored device ${deviceId} "${k}" failed validation — using fallback`,
+        { meta: { addonId: this._ctx?.id, deviceId, key: k, error: String(e) } }
+      )
+    });
+  }
   /**
    * Wrap `ctx.settings.readAddonStore()` with a short retry budget so a
    * transient settings-store outage (mid-restart of sqlite-settings, tsx-watch
@@ -688,6 +760,68 @@ function buildCapturingReply(envelope) {
   };
   return wrapper;
 }
+const EU_DST = {
+  offsetHours: 1,
+  startMonth: 3,
+  startWeekIndex: 5,
+  startWeekday: "Sunday",
+  startHour: 2,
+  endMonth: 10,
+  endWeekIndex: 5,
+  endWeekday: "Sunday",
+  endHour: 3
+};
+const US_DST = {
+  offsetHours: 1,
+  startMonth: 3,
+  startWeekIndex: 2,
+  startWeekday: "Sunday",
+  startHour: 2,
+  endMonth: 11,
+  endWeekIndex: 1,
+  endWeekday: "Sunday",
+  endHour: 2
+};
+const AU_DST = {
+  offsetHours: 1,
+  startMonth: 10,
+  startWeekIndex: 1,
+  startWeekday: "Sunday",
+  startHour: 2,
+  endMonth: 4,
+  endWeekIndex: 1,
+  endWeekday: "Sunday",
+  endHour: 3
+};
+const TIMEZONES = [
+  // --- Universal ---
+  { id: "UTC", label: "UTC (UTC+0)", region: "Universal", stdOffsetMinutes: 0, dst: null },
+  // --- Europe (EU DST rule) ---
+  { id: "Europe/London", label: "Europe/London (UTC+0 / BST)", region: "Europe", stdOffsetMinutes: 0, dst: EU_DST },
+  { id: "Europe/Rome", label: "Europe/Rome (UTC+1 / CEST)", region: "Europe", stdOffsetMinutes: 60, dst: EU_DST },
+  { id: "Europe/Paris", label: "Europe/Paris (UTC+1 / CEST)", region: "Europe", stdOffsetMinutes: 60, dst: EU_DST },
+  { id: "Europe/Berlin", label: "Europe/Berlin (UTC+1 / CEST)", region: "Europe", stdOffsetMinutes: 60, dst: EU_DST },
+  { id: "Europe/Madrid", label: "Europe/Madrid (UTC+1 / CEST)", region: "Europe", stdOffsetMinutes: 60, dst: EU_DST },
+  { id: "Europe/Amsterdam", label: "Europe/Amsterdam (UTC+1 / CEST)", region: "Europe", stdOffsetMinutes: 60, dst: EU_DST },
+  { id: "Europe/Istanbul", label: "Europe/Istanbul (UTC+3)", region: "Europe", stdOffsetMinutes: 180, dst: null },
+  // --- Americas (US/Canada DST rule) ---
+  { id: "America/New_York", label: "America/New York (UTC−5 / EDT)", region: "Americas", stdOffsetMinutes: -300, dst: US_DST },
+  { id: "America/Chicago", label: "America/Chicago (UTC−6 / CDT)", region: "Americas", stdOffsetMinutes: -360, dst: US_DST },
+  { id: "America/Denver", label: "America/Denver (UTC−7 / MDT)", region: "Americas", stdOffsetMinutes: -420, dst: US_DST },
+  { id: "America/Los_Angeles", label: "America/Los Angeles (UTC−8 / PDT)", region: "Americas", stdOffsetMinutes: -480, dst: US_DST },
+  { id: "America/Sao_Paulo", label: "America/Sao Paulo (UTC−3)", region: "Americas", stdOffsetMinutes: -180, dst: null },
+  // --- Asia / Middle East (no DST) ---
+  { id: "Asia/Dubai", label: "Asia/Dubai (UTC+4)", region: "Asia", stdOffsetMinutes: 240, dst: null },
+  { id: "Asia/Kolkata", label: "Asia/Kolkata (UTC+5:30)", region: "Asia", stdOffsetMinutes: 330, dst: null },
+  { id: "Asia/Singapore", label: "Asia/Singapore (UTC+8)", region: "Asia", stdOffsetMinutes: 480, dst: null },
+  { id: "Asia/Shanghai", label: "Asia/Shanghai (UTC+8)", region: "Asia", stdOffsetMinutes: 480, dst: null },
+  { id: "Asia/Tokyo", label: "Asia/Tokyo (UTC+9)", region: "Asia", stdOffsetMinutes: 540, dst: null },
+  // --- Oceania (southern-hemisphere DST) ---
+  { id: "Australia/Sydney", label: "Australia/Sydney (UTC+10 / AEDT)", region: "Oceania", stdOffsetMinutes: 600, dst: AU_DST }
+];
+function findTimezone(id) {
+  return TIMEZONES.find((tz) => tz.id === id);
+}
 class ReadinessTimeoutError extends Error {
   capName;
   scope;
@@ -1083,34 +1217,7 @@ function emitDownForOwnedCaps(registry, owned) {
     registry.emitDown(capName, scope);
   }
 }
-const STORAGE_LOCATION_TYPES = [
-  "data",
-  "media",
-  "recordings",
-  "recordings-high",
-  "recordings-low",
-  "recordings-clips",
-  "event-images",
-  "models",
-  "addons-data",
-  "cache",
-  "logs",
-  "backups"
-];
-const DEFAULT_LOCATION_SUBDIRS = {
-  "data": "db",
-  "media": "media",
-  "recordings": "recordings",
-  "recordings-high": "recordings-high",
-  "recordings-low": "recordings-low",
-  "recordings-clips": "recordings-clips",
-  "event-images": "event-images",
-  "models": "models",
-  "addons-data": "addons-data",
-  "cache": "/tmp/camstack-cache",
-  "logs": "logs",
-  "backups": "backups"
-};
+const DATAPLANE_SECRET_HEADER = "x-camstack-dataplane-secret";
 const STREAM_QUALITY_LABELS = {
   high: "High",
   mid: "Mid",
@@ -1158,12 +1265,12 @@ function toStreamSourceEntry(stream) {
 function isString(v) {
   return typeof v === "string";
 }
-function isRecord(v) {
+function isRecord$1(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function parseStreamEntry(v) {
   if (isString(v) && v.trim()) return { url: v };
-  if (isRecord(v) && isString(v["url"]) && v["url"].trim()) {
+  if (isRecord$1(v) && isString(v["url"]) && v["url"].trim()) {
     return {
       url: v["url"],
       label: isString(v["label"]) ? v["label"] : void 0
@@ -1224,6 +1331,51 @@ const DEFAULT_FEATURES = {
 };
 const SUB_DETECTION_TYPES = ["face", "plate"];
 const RECOGNITION_TYPES = ["face", "plate", "clip", "custom"];
+function pickPreferredRtspEntry(entries, pref, deviceId, options = {}) {
+  if (entries.length === 0) return null;
+  const prefix = `${deviceId}/`;
+  const toPicked = (e) => ({
+    brokerId: e.brokerId,
+    profileId: e.brokerId.startsWith(prefix) ? e.brokerId.slice(prefix.length) : e.brokerId,
+    url: e.url,
+    mutedUrl: e.mutedUrl,
+    enabled: e.enabled,
+    ...e.codec !== void 0 ? { codec: e.codec } : {},
+    ...e.resolution !== void 0 ? { resolution: e.resolution } : {}
+  });
+  if (pref !== "auto") {
+    const match = entries.find(
+      (e) => e.enabled && e.url.length > 0 && (e.profile === pref || e.brokerId === `${prefix}${pref}`)
+    );
+    if (match) return toPicked(match);
+  }
+  const eligible = entries.filter((e) => e.enabled && e.url.length > 0);
+  if (eligible.length === 0) return null;
+  const target = options.targetResolution;
+  if (target) {
+    const withRes = eligible.filter((e) => e.resolution !== void 0);
+    if (withRes.length > 0) {
+      const picked = pickClosestResolution(withRes, target);
+      if (picked) return toPicked(picked);
+    }
+  }
+  return toPicked(eligible[0]);
+}
+function pickClosestResolution(entries, target) {
+  const targetPixels = target.width * target.height;
+  let bestAbove;
+  let bestBelow;
+  for (const e of entries) {
+    if (e.resolution === void 0) continue;
+    const pixels = e.resolution.width * e.resolution.height;
+    if (pixels >= targetPixels) {
+      if (!bestAbove || pixels < bestAbove.pixels) bestAbove = { entry: e, pixels };
+    } else {
+      if (!bestBelow || pixels > bestBelow.pixels) bestBelow = { entry: e, pixels };
+    }
+  }
+  return bestAbove?.entry ?? bestBelow?.entry;
+}
 const DEFAULT_RETENTION = {
   cleanupIntervalMs: 60 * 60 * 1e3,
   detectionEventsDays: 30,
@@ -1265,9 +1417,6 @@ const RUNTIME_DEFAULTS = {
     models: "camstack-data/models"
   },
   "providers": [],
-  // Recording
-  "recording.segmentDurationSeconds": 4,
-  "recording.defaultRetentionDays": 30,
   // Streaming ports are addon-specific (go2rtc owns its defaults)
   // FFmpeg
   "ffmpeg.binaryPath": "ffmpeg",
@@ -1935,22 +2084,61 @@ function createRuntimeStateBridge(params) {
   return { ensureFresh, getStatus };
 }
 const DEVICE_LOCAL_STATE_CAPS = {
+  airQualitySensor: airQualitySensorCapability,
+  alarmPanel: alarmPanelCapability,
+  ambientLightSensor: ambientLightSensorCapability,
   audioMetrics: audioMetricsCapability,
+  automationControl: automationControlCapability,
   battery: batteryCapability,
+  binary: binaryCapability,
   brightness: brightnessCapability,
   cameraStreams: cameraStreamsCapability,
+  carbonMonoxide: carbonMonoxideCapability,
+  climateControl: climateControlCapability,
+  color: colorCapability,
+  connectivity: connectivityCapability,
+  consumables: consumablesCapability,
+  contact: contactCapability,
+  control: controlCapability,
+  cover: coverCapability,
   deviceDiscovery: deviceDiscoveryCapability,
   deviceStatus: deviceStatusCapability,
   doorbell: doorbellCapability,
+  enumSensor: enumSensorCapability,
+  eventEmitter: eventEmitterCapability,
+  fanControl: fanControlCapability,
   featureProbe: featureProbeCapability,
+  flood: floodCapability,
+  gas: gasCapability,
+  humidifier: humidifierCapability,
+  humiditySensor: humiditySensorCapability,
+  image: imageCapability,
+  lawnMowerControl: lawnMowerControlCapability,
+  lockControl: lockControlCapability,
+  mediaPlayer: mediaPlayerCapability,
   motion: motionCapability,
   motionTrigger: motionTriggerCapability,
   motionZones: motionZonesCapability,
   nativeObjectDetection: nativeObjectDetectionCapability,
+  notifier: notifierCapability,
+  numericSensor: numericSensorCapability,
+  powerMeter: powerMeterCapability,
+  presence: presenceCapability,
+  pressureSensor: pressureSensorCapability,
   privacyMask: privacyMaskCapability,
   ptzAutotrack: ptzAutotrackCapability,
+  scriptRunner: scriptRunnerCapability,
+  smoke: smokeCapability,
   streamParams: streamParamsCapability,
   switch: switchCapability,
+  tamper: tamperCapability,
+  temperatureSensor: temperatureSensorCapability,
+  update: updateCapability,
+  vacuumControl: vacuumControlCapability,
+  valve: valveCapability,
+  vibration: vibrationCapability,
+  waterHeater: waterHeaterCapability,
+  weather: weatherCapability,
   zoneAnalytics: zoneAnalyticsCapability,
   zoneRules: zoneRulesCapability,
   zones: zonesCapability
@@ -2054,6 +2242,16 @@ class BaseDevice {
    * `kernel.devices.setDisabled(id, value)`.
    */
   disabled;
+  /**
+   * Cached materialised `SourceInfo` — either the value persisted under
+   * `metadata.sourceInfo` at construction time, or a synthetic
+   * `{ id: stableId, system: addonId }` for providers that haven't
+   * migrated yet. Lazily populated on first `sourceInfo` read so the
+   * cost of Zod-parsing the meta blob is paid once per device boot.
+   * Invalidated by `updateSourceInfo()` so providers see the new value
+   * back through the getter without a re-fetch from the meta surface.
+   */
+  _sourceInfoCache = null;
   constructor(ctx, schema, options) {
     this.ctx = ctx;
     this.id = ctx.id;
@@ -2094,7 +2292,7 @@ class BaseDevice {
     this.runtimeState = DeviceRuntimeState.fromInitial(initial, writer);
     ctx.bindRuntimeState?.(this.runtimeState);
     ctx.registerNativeCap?.(deviceStatusCapability, {});
-    const seed = { online: false, lastChangedAt: Date.now() };
+    const seed = { online: true, lastChangedAt: Date.now() };
     this.runtimeState.setCapState("device-status", seed);
     ctx.registerNativeCap?.(featureProbeCapability, {});
     const probeSeed = {
@@ -2107,6 +2305,21 @@ class BaseDevice {
     };
     this.runtimeState.setCapState("feature-probe", probeSeed);
   }
+  deviceActions = /* @__PURE__ */ new Map();
+  /** Declare a device custom action + its typed handler. Idempotent per name. */
+  registerDeviceAction(name, spec, handler) {
+    this.deviceActions.set(name, {
+      spec,
+      handler
+    });
+  }
+  /** Invoke a registered device action. Validates input against the spec. */
+  async runDeviceAction(action, input) {
+    const entry = this.deviceActions.get(action);
+    if (!entry) throw new Error(`unknown device action "${action}" on device ${this.id}`);
+    const parsed = entry.spec.input.parse(input);
+    return entry.handler(parsed);
+  }
   async removeDevice() {
   }
   /**
@@ -2123,6 +2336,71 @@ class BaseDevice {
     const next = { online, lastChangedAt: Date.now() };
     this.runtimeState.setCapState("device-status", next);
   }
+  /**
+   * Upstream-system identity + rendering envelope for this device. See
+   * `SourceInfo` for the field contract. Always returns a valid object:
+   * if the persisted `metadata.sourceInfo` blob is absent or fails Zod
+   * validation, falls back to a synthetic `{ id: stableId, system: addonId }`
+   * so providers that haven't migrated keep working without code changes.
+   *
+   * The value is cached after the first read. `updateSourceInfo()`
+   * invalidates the cache so subsequent reads see the new patch. The
+   * returned object is frozen to prevent accidental in-place mutation —
+   * use `updateSourceInfo({ patch })` to change fields.
+   */
+  get sourceInfo() {
+    if (this._sourceInfoCache) return this._sourceInfoCache;
+    const fromMeta = extractSourceInfoFromMetadata(this.ctx.deviceMeta.metadata);
+    const resolved = fromMeta ?? synthesizeSourceInfo({
+      stableId: this.stableId,
+      addonId: this.ctx.deviceMeta.addonId
+    });
+    this._sourceInfoCache = Object.freeze({ ...resolved });
+    return this._sourceInfoCache;
+  }
+  /**
+   * Convenience accessor for the upstream dispatch key. Equivalent to
+   * `this.sourceInfo.id` — providers use this to keep a
+   * `Map<sourceId, IDevice>` for routing inbound push events.
+   */
+  get sourceId() {
+    return this.sourceInfo.id;
+  }
+  /**
+   * Patch the device's `SourceInfo`. Shallow-merges `patch` over the
+   * current value, persists the merged result under
+   * `metadata.sourceInfo` via the `device-manager.setMetadata` cap, and
+   * emits `EventCategory.DeviceSourceInfoChanged` for live consumers.
+   *
+   * Safe to call from anywhere in the device's lifetime — the call is
+   * idempotent for `undefined` patch values (ignored) and best-effort
+   * for persistence (a transient device-manager error doesn't unwind
+   * the local cache update, so subsequent reads still see the patch).
+   *
+   * Drivers populate this on adoption + on every metadata change push
+   * from the upstream source. Subscribers (UI, export adapters) react
+   * via the `DeviceSourceInfoChanged` event without polling.
+   */
+  async updateSourceInfo(patch) {
+    const next = mergeSourceInfo(this.sourceInfo, patch);
+    this._sourceInfoCache = Object.freeze({ ...next });
+    const api = this.ctx.api;
+    const action = api?.deviceManager?.setMetadata;
+    if (action) {
+      try {
+        await action.mutate({
+          deviceId: this.id,
+          patch: { [SOURCE_INFO_METADATA_KEY]: next }
+        });
+      } catch {
+      }
+    }
+    this.ctx.eventBus.emit(createEvent(
+      "device.source-info-changed",
+      { type: "device", id: this.stableId },
+      { deviceId: this.id, sourceInfo: next }
+    ));
+  }
   /**
    * Re-publish the device's current `features` array to the persisted
    * meta blob. Drivers call this after a probe finishes when the live
@@ -2373,7 +2651,13 @@ function toDeviceSummary(device, addonId) {
     parentDeviceId: device.parentDeviceId,
     online: device.online,
     features: [...device.features],
-    config
+    config,
+    // BaseDevice always resolves sourceInfo (synthetic or persisted).
+    // `IDevice` doesn't declare the field — providers that override
+    // `IDevice` outside the BaseDevice hierarchy stay backwards-
+    // compatible. Read through a structural check so non-BaseDevice
+    // implementations don't blow up.
+    sourceInfo: device.sourceInfo
   };
 }
 class BaseDeviceProvider extends BaseAddon {
@@ -2682,6 +2966,80 @@ function getZodDefault(schema) {
 function humanizeKey(key) {
   return key.replace(/([A-Z])/g, " $1").replace(/[_-]/g, " ").replace(/^\w/, (c) => c.toUpperCase()).trim();
 }
+function isRecord(x) {
+  return x !== null && typeof x === "object" && !Array.isArray(x);
+}
+function getByPath(obj, path) {
+  const parts = path.split(".");
+  let cur = obj;
+  for (const part of parts) {
+    if (!isRecord(cur)) return void 0;
+    cur = cur[part];
+  }
+  return cur;
+}
+function setByPath(obj, path, value) {
+  const dotIndex = path.indexOf(".");
+  if (dotIndex === -1) {
+    return { ...obj, [path]: value };
+  }
+  const head = path.slice(0, dotIndex);
+  const tail = path.slice(dotIndex + 1);
+  const child = obj[head];
+  const childObj = isRecord(child) ? child : {};
+  return { ...obj, [head]: setByPath(childObj, tail, value) };
+}
+function applyTransform(value, transform) {
+  if (!transform || transform.kind === "identity") return value;
+  if (transform.kind === "enum-map") {
+    const key = String(value);
+    if (Object.prototype.hasOwnProperty.call(transform.mapping, key)) return transform.mapping[key];
+    return transform.fallback ?? null;
+  }
+  if (transform.kind === "linear") {
+    if (typeof value !== "number" || Number.isNaN(value)) return null;
+    let out = value * transform.scale + transform.offset;
+    if (transform.clamp) {
+      const min = transform.clamp[0];
+      const max = transform.clamp[1];
+      out = Math.min(max, Math.max(min, out));
+    }
+    return out;
+  }
+  return value;
+}
+function unwrap(schema) {
+  let s = schema;
+  while (s instanceof z.ZodNullable || s instanceof z.ZodOptional || s instanceof z.ZodDefault) {
+    s = s.unwrap();
+  }
+  return s;
+}
+function leafKind(schema) {
+  const s = unwrap(schema);
+  if (s instanceof z.ZodEnum) return { kind: "enum", enumValues: s.options };
+  if (s instanceof z.ZodNumber) return { kind: "number" };
+  if (s instanceof z.ZodString) return { kind: "string" };
+  if (s instanceof z.ZodBoolean) return { kind: "boolean" };
+  return null;
+}
+function enumerateSchemaFields(schema, prefix = "") {
+  const root = unwrap(schema);
+  if (!(root instanceof z.ZodObject)) return [];
+  const out = [];
+  const shape = root.shape;
+  for (const [key, field] of Object.entries(shape)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    const inner = unwrap(field);
+    if (inner instanceof z.ZodObject) {
+      out.push(...enumerateSchemaFields(inner, path));
+      continue;
+    }
+    const leaf = leafKind(field);
+    if (leaf) out.push({ path, kind: leaf.kind, ...leaf.enumValues ? { enumValues: leaf.enumValues } : {} });
+  }
+  return out;
+}
 const DEVICE_STATE_EVENT_CATEGORY = "device.state-changed";
 function createLazyTrpcSource(api) {
   const cache = /* @__PURE__ */ new Map();
@@ -2845,8 +3203,21 @@ function createDeviceProxy(api, binding, opts) {
     return callLeaf(capProp, method, kind, mergeInput(input, void 0), push);
   }
   const accessoriesInterface = {
+    setChildHidden: (input) => dispatch("accessories", "accessories", "setChildHidden", "mutation", input),
     getStatus: (input) => dispatch("accessories", "accessories", "getStatus", "query", input)
   };
+  const airQualitySensorInterface = {
+    getStatus: (input) => dispatch("air-quality-sensor", "airQualitySensor", "getStatus", "query", input)
+  };
+  const alarmPanelInterface = {
+    arm: (input) => dispatch("alarm-panel", "alarmPanel", "arm", "mutation", input),
+    disarm: (input) => dispatch("alarm-panel", "alarmPanel", "disarm", "mutation", input),
+    trigger: (input) => dispatch("alarm-panel", "alarmPanel", "trigger", "mutation", input),
+    getStatus: (input) => dispatch("alarm-panel", "alarmPanel", "getStatus", "query", input)
+  };
+  const ambientLightSensorInterface = {
+    getStatus: (input) => dispatch("ambient-light-sensor", "ambientLightSensor", "getStatus", "query", input)
+  };
   const audioAnalysisInterface = {
     resolveDeviceSettings: (input) => dispatch("audio-analysis", "audioAnalysis", "resolveDeviceSettings", "query", input),
     getDeviceSettingsContribution: (input) => dispatch("audio-analysis", "audioAnalysis", "getDeviceSettingsContribution", "query", input),
@@ -2857,13 +3228,26 @@ function createDeviceProxy(api, binding, opts) {
     getCurrentSnapshot: (input) => dispatch("audio-metrics", "audioMetrics", "getCurrentSnapshot", "query", input),
     getHistory: (input) => dispatch("audio-metrics", "audioMetrics", "getHistory", "query", input)
   };
+  const automationControlInterface = {
+    enable: (input) => dispatch("automation-control", "automationControl", "enable", "mutation", input),
+    disable: (input) => dispatch("automation-control", "automationControl", "disable", "mutation", input),
+    trigger: (input) => dispatch("automation-control", "automationControl", "trigger", "mutation", input),
+    getStatus: (input) => dispatch("automation-control", "automationControl", "getStatus", "query", input)
+  };
   const batteryInterface = {
+    wakeForStream: (input) => dispatch("battery", "battery", "wakeForStream", "mutation", input),
     getStatus: (input) => dispatch("battery", "battery", "getStatus", "query", input)
   };
+  const binaryInterface = {
+    getStatus: (input) => dispatch("binary", "binary", "getStatus", "query", input)
+  };
   const brightnessInterface = {
     setBrightness: (input) => dispatch("brightness", "brightness", "setBrightness", "mutation", input),
     getStatus: (input) => dispatch("brightness", "brightness", "getStatus", "query", input)
   };
+  const buttonInterface = {
+    press: (input) => dispatch("button", "button", "press", "mutation", input)
+  };
   const cameraCredentialsInterface = {
     getCredentials: (input) => dispatch("camera-credentials", "cameraCredentials", "getCredentials", "query", input),
     getStatus: (input) => dispatch("camera-credentials", "cameraCredentials", "getStatus", "query", input)
@@ -2871,7 +3255,47 @@ function createDeviceProxy(api, binding, opts) {
   const cameraStreamsInterface = {
     getCameraStreams: (input) => dispatch("camera-streams", "cameraStreams", "getCameraStreams", "query", input),
     getBrokerStreams: (input) => dispatch("camera-streams", "cameraStreams", "getBrokerStreams", "query", input),
-    getRtspEntries: (input) => dispatch("camera-streams", "cameraStreams", "getRtspEntries", "query", input)
+    getRtspEntries: (input) => dispatch("camera-streams", "cameraStreams", "getRtspEntries", "query", input),
+    getProfileRtspEntries: (input) => dispatch("camera-streams", "cameraStreams", "getProfileRtspEntries", "query", input),
+    pickStream: (input) => dispatch("camera-streams", "cameraStreams", "pickStream", "query", input)
+  };
+  const carbonMonoxideInterface = {
+    getStatus: (input) => dispatch("carbon-monoxide", "carbonMonoxide", "getStatus", "query", input)
+  };
+  const climateControlInterface = {
+    setMode: (input) => dispatch("climate-control", "climateControl", "setMode", "mutation", input),
+    setFanMode: (input) => dispatch("climate-control", "climateControl", "setFanMode", "mutation", input),
+    setPreset: (input) => dispatch("climate-control", "climateControl", "setPreset", "mutation", input),
+    setTarget: (input) => dispatch("climate-control", "climateControl", "setTarget", "mutation", input),
+    setTargetRange: (input) => dispatch("climate-control", "climateControl", "setTargetRange", "mutation", input),
+    setTargetHumidity: (input) => dispatch("climate-control", "climateControl", "setTargetHumidity", "mutation", input),
+    getStatus: (input) => dispatch("climate-control", "climateControl", "getStatus", "query", input)
+  };
+  const colorInterface = {
+    setColor: (input) => dispatch("color", "color", "setColor", "mutation", input),
+    getStatus: (input) => dispatch("color", "color", "getStatus", "query", input)
+  };
+  const connectivityInterface = {
+    getStatus: (input) => dispatch("connectivity", "connectivity", "getStatus", "query", input)
+  };
+  const consumablesInterface = {
+    reset: (input) => dispatch("consumables", "consumables", "reset", "mutation", input),
+    getStatus: (input) => dispatch("consumables", "consumables", "getStatus", "query", input)
+  };
+  const contactInterface = {
+    getStatus: (input) => dispatch("contact", "contact", "getStatus", "query", input)
+  };
+  const controlInterface = {
+    setValue: (input) => dispatch("control", "control", "setValue", "mutation", input),
+    getStatus: (input) => dispatch("control", "control", "getStatus", "query", input)
+  };
+  const coverInterface = {
+    open: (input) => dispatch("cover", "cover", "open", "mutation", input),
+    close: (input) => dispatch("cover", "cover", "close", "mutation", input),
+    stop: (input) => dispatch("cover", "cover", "stop", "mutation", input),
+    setPosition: (input) => dispatch("cover", "cover", "setPosition", "mutation", input),
+    setTiltPosition: (input) => dispatch("cover", "cover", "setTiltPosition", "mutation", input),
+    getStatus: (input) => dispatch("cover", "cover", "getStatus", "query", input)
   };
   const detectionPipelineInterface = {
     getDeviceSettingsContribution: (input) => dispatch("detection-pipeline", "detectionPipeline", "getDeviceSettingsContribution", "query", input),
@@ -2889,8 +3313,10 @@ function createDeviceProxy(api, binding, opts) {
     getStreamSources: (input) => dispatch("device-ops", "deviceOps", "getStreamSources", "query", input),
     getConfigEntries: (input) => dispatch("device-ops", "deviceOps", "getConfigEntries", "query", input),
     setConfig: (input) => dispatch("device-ops", "deviceOps", "setConfig", "mutation", input),
+    runAction: (input) => dispatch("device-ops", "deviceOps", "runAction", "mutation", input),
     removeDevice: (input) => dispatch("device-ops", "deviceOps", "removeDevice", "mutation", input),
-    getSettingsSchema: (input) => dispatch("device-ops", "deviceOps", "getSettingsSchema", "query", input)
+    getSettingsSchema: (input) => dispatch("device-ops", "deviceOps", "getSettingsSchema", "query", input),
+    getRawState: (input) => dispatch("device-ops", "deviceOps", "getRawState", "query", input)
   };
   const deviceStatusInterface = {
     getStatus: (input) => dispatch("device-status", "deviceStatus", "getStatus", "query", input)
@@ -2898,23 +3324,81 @@ function createDeviceProxy(api, binding, opts) {
   const doorbellInterface = {
     getStatus: (input) => dispatch("doorbell", "doorbell", "getStatus", "query", input)
   };
+  const enumSensorInterface = {
+    getStatus: (input) => dispatch("enum-sensor", "enumSensor", "getStatus", "query", input)
+  };
+  const eventEmitterInterface = {
+    getStatus: (input) => dispatch("event-emitter", "eventEmitter", "getStatus", "query", input)
+  };
   const eventsInterface = {
     getEvents: (input) => dispatch("events", "events", "getEvents", "query", input),
     getEventThumbnail: (input) => dispatch("events", "events", "getEventThumbnail", "query", input),
     getEventClipUrl: (input) => dispatch("events", "events", "getEventClipUrl", "query", input)
   };
+  const fanControlInterface = {
+    setPercentage: (input) => dispatch("fan-control", "fanControl", "setPercentage", "mutation", input),
+    setPreset: (input) => dispatch("fan-control", "fanControl", "setPreset", "mutation", input),
+    setDirection: (input) => dispatch("fan-control", "fanControl", "setDirection", "mutation", input),
+    setOscillating: (input) => dispatch("fan-control", "fanControl", "setOscillating", "mutation", input),
+    getStatus: (input) => dispatch("fan-control", "fanControl", "getStatus", "query", input)
+  };
   const featureProbeInterface = {
     getStatus: (input) => dispatch("feature-probe", "featureProbe", "getStatus", "query", input)
   };
+  const floodInterface = {
+    getStatus: (input) => dispatch("flood", "flood", "getStatus", "query", input)
+  };
+  const gasInterface = {
+    getStatus: (input) => dispatch("gas", "gas", "getStatus", "query", input)
+  };
+  const humidifierInterface = {
+    setOn: (input) => dispatch("humidifier", "humidifier", "setOn", "mutation", input),
+    setTargetHumidity: (input) => dispatch("humidifier", "humidifier", "setTargetHumidity", "mutation", input),
+    setMode: (input) => dispatch("humidifier", "humidifier", "setMode", "mutation", input),
+    getStatus: (input) => dispatch("humidifier", "humidifier", "getStatus", "query", input)
+  };
+  const humiditySensorInterface = {
+    getStatus: (input) => dispatch("humidity-sensor", "humiditySensor", "getStatus", "query", input)
+  };
+  const imageInterface = {
+    getStatus: (input) => dispatch("image", "image", "getStatus", "query", input)
+  };
   const intercomInterface = {
     startSession: (input) => dispatch("intercom", "intercom", "startSession", "mutation", input),
     handleAnswer: (input) => dispatch("intercom", "intercom", "handleAnswer", "mutation", input),
     stopSession: (input) => dispatch("intercom", "intercom", "stopSession", "mutation", input),
     startTalkSession: (input) => dispatch("intercom", "intercom", "startTalkSession", "mutation", input),
-    pushTalkPcm: (input) => dispatch("intercom", "intercom", "pushTalkPcm", "mutation", input),
+    pushTalkAudio: (input) => dispatch("intercom", "intercom", "pushTalkAudio", "mutation", input),
     endTalkSession: (input) => dispatch("intercom", "intercom", "endTalkSession", "mutation", input),
     getStatus: (input) => dispatch("intercom", "intercom", "getStatus", "query", input)
   };
+  const lawnMowerControlInterface = {
+    startMowing: (input) => dispatch("lawn-mower-control", "lawnMowerControl", "startMowing", "mutation", input),
+    pause: (input) => dispatch("lawn-mower-control", "lawnMowerControl", "pause", "mutation", input),
+    dock: (input) => dispatch("lawn-mower-control", "lawnMowerControl", "dock", "mutation", input),
+    getStatus: (input) => dispatch("lawn-mower-control", "lawnMowerControl", "getStatus", "query", input)
+  };
+  const lockControlInterface = {
+    lock: (input) => dispatch("lock-control", "lockControl", "lock", "mutation", input),
+    unlock: (input) => dispatch("lock-control", "lockControl", "unlock", "mutation", input),
+    open: (input) => dispatch("lock-control", "lockControl", "open", "mutation", input),
+    getStatus: (input) => dispatch("lock-control", "lockControl", "getStatus", "query", input)
+  };
+  const mediaPlayerInterface = {
+    play: (input) => dispatch("media-player", "mediaPlayer", "play", "mutation", input),
+    pause: (input) => dispatch("media-player", "mediaPlayer", "pause", "mutation", input),
+    stop: (input) => dispatch("media-player", "mediaPlayer", "stop", "mutation", input),
+    next: (input) => dispatch("media-player", "mediaPlayer", "next", "mutation", input),
+    previous: (input) => dispatch("media-player", "mediaPlayer", "previous", "mutation", input),
+    seek: (input) => dispatch("media-player", "mediaPlayer", "seek", "mutation", input),
+    setVolume: (input) => dispatch("media-player", "mediaPlayer", "setVolume", "mutation", input),
+    setMute: (input) => dispatch("media-player", "mediaPlayer", "setMute", "mutation", input),
+    setShuffle: (input) => dispatch("media-player", "mediaPlayer", "setShuffle", "mutation", input),
+    setRepeat: (input) => dispatch("media-player", "mediaPlayer", "setRepeat", "mutation", input),
+    selectSource: (input) => dispatch("media-player", "mediaPlayer", "selectSource", "mutation", input),
+    playMedia: (input) => dispatch("media-player", "mediaPlayer", "playMedia", "mutation", input),
+    getStatus: (input) => dispatch("media-player", "mediaPlayer", "getStatus", "query", input)
+  };
   const motionInterface = {
     isDetected: (input) => dispatch("motion", "motion", "isDetected", "query", input),
     getStatus: (input) => dispatch("motion", "motion", "getStatus", "query", input)
@@ -2940,6 +3424,14 @@ function createDeviceProxy(api, binding, opts) {
     setEnabled: (input) => dispatch("native-object-detection", "nativeObjectDetection", "setEnabled", "mutation", input),
     getStatus: (input) => dispatch("native-object-detection", "nativeObjectDetection", "getStatus", "query", input)
   };
+  const notifierInterface = {
+    send: (input) => dispatch("notifier", "notifier", "send", "mutation", input),
+    cancel: (input) => dispatch("notifier", "notifier", "cancel", "mutation", input),
+    getStatus: (input) => dispatch("notifier", "notifier", "getStatus", "query", input)
+  };
+  const numericSensorInterface = {
+    getStatus: (input) => dispatch("numeric-sensor", "numericSensor", "getStatus", "query", input)
+  };
   const osdInterface = {
     setOverlay: (input) => dispatch("osd", "osd", "setOverlay", "mutation", input),
     getStatus: (input) => dispatch("osd", "osd", "getStatus", "query", input)
@@ -2952,12 +3444,23 @@ function createDeviceProxy(api, binding, opts) {
     getMotionEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getMotionEvents", "query", input),
     getObjectEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getObjectEvents", "query", input),
     getAudioEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getAudioEvents", "query", input),
+    getEventDensity: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getEventDensity", "query", input),
+    pruneEventsBefore: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "pruneEventsBefore", "mutation", input),
     getEventMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getEventMedia", "query", input),
     getTrackMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getTrackMedia", "query", input),
     getDeviceSettingsContribution: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getDeviceSettingsContribution", "query", input),
     getDeviceLiveContribution: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getDeviceLiveContribution", "query", input),
     applyDeviceSettingsPatch: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "applyDeviceSettingsPatch", "mutation", input)
   };
+  const powerMeterInterface = {
+    getStatus: (input) => dispatch("power-meter", "powerMeter", "getStatus", "query", input)
+  };
+  const presenceInterface = {
+    getStatus: (input) => dispatch("presence", "presence", "getStatus", "query", input)
+  };
+  const pressureSensorInterface = {
+    getStatus: (input) => dispatch("pressure-sensor", "pressureSensor", "getStatus", "query", input)
+  };
   const privacyMaskInterface = {
     getOptions: (input) => dispatch("privacy-mask", "privacyMask", "getOptions", "query", input),
     setMask: (input) => dispatch("privacy-mask", "privacyMask", "setMask", "mutation", input),
@@ -2986,10 +3489,13 @@ function createDeviceProxy(api, binding, opts) {
   const rebootInterface = {
     reboot: (input) => dispatch("reboot", "reboot", "reboot", "mutation", input)
   };
-  const recordingInterface = {
-    getSegments: (input) => dispatch("recording", "recording", "getSegments", "query", input),
-    getPlaybackUrl: (input) => dispatch("recording", "recording", "getPlaybackUrl", "query", input),
-    getThumbnailAt: (input) => dispatch("recording", "recording", "getThumbnailAt", "query", input)
+  const scriptRunnerInterface = {
+    run: (input) => dispatch("script-runner", "scriptRunner", "run", "mutation", input),
+    stop: (input) => dispatch("script-runner", "scriptRunner", "stop", "mutation", input),
+    getStatus: (input) => dispatch("script-runner", "scriptRunner", "getStatus", "query", input)
+  };
+  const smokeInterface = {
+    getStatus: (input) => dispatch("smoke", "smoke", "getStatus", "query", input)
   };
   const snapshotInterface = {
     getSnapshot: (input) => dispatch("snapshot", "snapshot", "getSnapshot", "query", input),
@@ -3012,6 +3518,44 @@ function createDeviceProxy(api, binding, opts) {
     setState: (input) => dispatch("switch", "switch", "setState", "mutation", input),
     getStatus: (input) => dispatch("switch", "switch", "getStatus", "query", input)
   };
+  const tamperInterface = {
+    getStatus: (input) => dispatch("tamper", "tamper", "getStatus", "query", input)
+  };
+  const temperatureSensorInterface = {
+    getStatus: (input) => dispatch("temperature-sensor", "temperatureSensor", "getStatus", "query", input)
+  };
+  const updateInterface = {
+    installUpdate: (input) => dispatch("update", "update", "installUpdate", "mutation", input),
+    getStatus: (input) => dispatch("update", "update", "getStatus", "query", input)
+  };
+  const vacuumControlInterface = {
+    start: (input) => dispatch("vacuum-control", "vacuumControl", "start", "mutation", input),
+    pause: (input) => dispatch("vacuum-control", "vacuumControl", "pause", "mutation", input),
+    stop: (input) => dispatch("vacuum-control", "vacuumControl", "stop", "mutation", input),
+    returnToBase: (input) => dispatch("vacuum-control", "vacuumControl", "returnToBase", "mutation", input),
+    locate: (input) => dispatch("vacuum-control", "vacuumControl", "locate", "mutation", input),
+    setFanSpeed: (input) => dispatch("vacuum-control", "vacuumControl", "setFanSpeed", "mutation", input),
+    getStatus: (input) => dispatch("vacuum-control", "vacuumControl", "getStatus", "query", input)
+  };
+  const valveInterface = {
+    open: (input) => dispatch("valve", "valve", "open", "mutation", input),
+    close: (input) => dispatch("valve", "valve", "close", "mutation", input),
+    stop: (input) => dispatch("valve", "valve", "stop", "mutation", input),
+    setPosition: (input) => dispatch("valve", "valve", "setPosition", "mutation", input),
+    getStatus: (input) => dispatch("valve", "valve", "getStatus", "query", input)
+  };
+  const vibrationInterface = {
+    getStatus: (input) => dispatch("vibration", "vibration", "getStatus", "query", input)
+  };
+  const waterHeaterInterface = {
+    setTargetTemp: (input) => dispatch("water-heater", "waterHeater", "setTargetTemp", "mutation", input),
+    setOperationMode: (input) => dispatch("water-heater", "waterHeater", "setOperationMode", "mutation", input),
+    setAway: (input) => dispatch("water-heater", "waterHeater", "setAway", "mutation", input),
+    getStatus: (input) => dispatch("water-heater", "waterHeater", "getStatus", "query", input)
+  };
+  const weatherInterface = {
+    getStatus: (input) => dispatch("weather", "weather", "getStatus", "query", input)
+  };
   const webrtcSessionInterface = {
     listStreams: (input) => dispatch("webrtc-session", "webrtcSession", "listStreams", "query", input),
     createSession: (input) => dispatch("webrtc-session", "webrtcSession", "createSession", "mutation", input),
@@ -3020,7 +3564,8 @@ function createDeviceProxy(api, binding, opts) {
     addIceCandidate: (input) => dispatch("webrtc-session", "webrtcSession", "addIceCandidate", "mutation", input),
     getIceCandidates: (input) => dispatch("webrtc-session", "webrtcSession", "getIceCandidates", "query", input),
     closeSession: (input) => dispatch("webrtc-session", "webrtcSession", "closeSession", "mutation", input),
-    hasAdaptiveBitrate: (input) => dispatch("webrtc-session", "webrtcSession", "hasAdaptiveBitrate", "query", input)
+    hasAdaptiveBitrate: (input) => dispatch("webrtc-session", "webrtcSession", "hasAdaptiveBitrate", "query", input),
+    getSessionState: (input) => dispatch("webrtc-session", "webrtcSession", "getSessionState", "query", input)
   };
   const zoneAnalyticsInterface = {
     getCurrentSnapshot: (input) => dispatch("zone-analytics", "zoneAnalytics", "getCurrentSnapshot", "query", input),
@@ -3047,6 +3592,9 @@ function createDeviceProxy(api, binding, opts) {
     getDeviceLiveContribution: (input) => dispatchSystem("cameraPipelineConfig", "getDeviceLiveContribution", "query", input),
     applyDeviceSettingsPatch: (input) => dispatchSystem("cameraPipelineConfig", "applyDeviceSettingsPatch", "mutation", input)
   };
+  const deviceAdoptionInterface = {
+    getStatus: (input) => dispatchSystem("deviceAdoption", "getStatus", "query", input)
+  };
   const deviceExportInterface = {
     getDeviceSettingsContribution: (input) => dispatchSystem("deviceExport", "getDeviceSettingsContribution", "query", input),
     getDeviceLiveContribution: (input) => dispatchSystem("deviceExport", "getDeviceLiveContribution", "query", input),
@@ -3058,6 +3606,15 @@ function createDeviceProxy(api, binding, opts) {
     loadMeta: (input) => dispatchSystem("deviceManager", "loadMeta", "query", input),
     setName: (input) => dispatchSystem("deviceManager", "setName", "mutation", input),
     setLocation: (input) => dispatchSystem("deviceManager", "setLocation", "mutation", input),
+    setType: (input) => dispatchSystem("deviceManager", "setType", "mutation", input),
+    setIntegrationId: (input) => dispatchSystem("deviceManager", "setIntegrationId", "mutation", input),
+    setLinkDeviceId: (input) => dispatchSystem("deviceManager", "setLinkDeviceId", "mutation", input),
+    setPrimaryChildEntityId: (input) => dispatchSystem("deviceManager", "setPrimaryChildEntityId", "mutation", input),
+    setChildLayout: (input) => dispatchSystem("deviceManager", "setChildLayout", "mutation", input),
+    setDeviceLinks: (input) => dispatchSystem("deviceManager", "setDeviceLinks", "mutation", input),
+    getWireableFields: (input) => dispatchSystem("deviceManager", "getWireableFields", "query", input),
+    setRole: (input) => dispatchSystem("deviceManager", "setRole", "mutation", input),
+    applyInitialMeta: (input) => dispatchSystem("deviceManager", "applyInitialMeta", "mutation", input),
     setMetadata: (input) => dispatchSystem("deviceManager", "setMetadata", "mutation", input),
     setDisabled: (input) => dispatchSystem("deviceManager", "setDisabled", "mutation", input),
     getDevice: (input) => dispatchSystem("deviceManager", "getDevice", "query", input),
@@ -3077,6 +3634,7 @@ function createDeviceProxy(api, binding, opts) {
     getDeviceSettingsAggregate: (input) => dispatchSystem("deviceManager", "getDeviceSettingsAggregate", "query", input),
     getDeviceLiveInfoAggregate: (input) => dispatchSystem("deviceManager", "getDeviceLiveInfoAggregate", "query", input),
     getDeviceAggregate: (input) => dispatchSystem("deviceManager", "getDeviceAggregate", "query", input),
+    runDeviceAction: (input) => dispatchSystem("deviceManager", "runDeviceAction", "mutation", input),
     updateDeviceField: (input) => dispatchSystem("deviceManager", "updateDeviceField", "mutation", input),
     updateDeviceFieldsBatch: (input) => dispatchSystem("deviceManager", "updateDeviceFieldsBatch", "mutation", input),
     testField: (input) => dispatchSystem("deviceManager", "testField", "mutation", input),
@@ -3121,8 +3679,17 @@ function createDeviceProxy(api, binding, opts) {
     detachCamera: (input) => dispatchSystem("pipelineRunner", "detachCamera", "mutation", input),
     getCameraMetrics: (input) => dispatchSystem("pipelineRunner", "getCameraMetrics", "query", input)
   };
-  const recordingEngineInterface = {
-    getPolicyStatus: (input) => dispatchSystem("recordingEngine", "getPolicyStatus", "query", input)
+  const recordingInterface = {
+    getAvailability: (input) => dispatchSystem("recording", "getAvailability", "query", input),
+    getPlaybackManifest: (input) => dispatchSystem("recording", "getPlaybackManifest", "query", input),
+    getDeviceConfig: (input) => dispatchSystem("recording", "getDeviceConfig", "query", input),
+    setDeviceConfig: (input) => dispatchSystem("recording", "setDeviceConfig", "mutation", input),
+    rescanStorage: (input) => dispatchSystem("recording", "rescanStorage", "mutation", input),
+    pruneFootage: (input) => dispatchSystem("recording", "pruneFootage", "mutation", input),
+    getStatus: (input) => dispatchSystem("recording", "getStatus", "query", input),
+    getDeviceSettingsContribution: (input) => dispatchSystem("recording", "getDeviceSettingsContribution", "query", input),
+    getDeviceLiveContribution: (input) => dispatchSystem("recording", "getDeviceLiveContribution", "query", input),
+    applyDeviceSettingsPatch: (input) => dispatchSystem("recording", "applyDeviceSettingsPatch", "mutation", input)
   };
   const snapshotProviderInterface = {
     supportsDevice: (input) => dispatchSystem("snapshotProvider", "supportsDevice", "query", input),
@@ -3142,63 +3709,142 @@ function createDeviceProxy(api, binding, opts) {
     deviceId: binding.deviceId,
     binding,
     state: {
+      airQualitySensor: createSliceHandle(stateSource, binding.deviceId, "air-quality-sensor"),
+      alarmPanel: createSliceHandle(stateSource, binding.deviceId, "alarm-panel"),
+      ambientLightSensor: createSliceHandle(stateSource, binding.deviceId, "ambient-light-sensor"),
       audioMetrics: createSliceHandle(stateSource, binding.deviceId, "audio-metrics"),
+      automationControl: createSliceHandle(stateSource, binding.deviceId, "automation-control"),
       battery: createSliceHandle(stateSource, binding.deviceId, "battery"),
+      binary: createSliceHandle(stateSource, binding.deviceId, "binary"),
       brightness: createSliceHandle(stateSource, binding.deviceId, "brightness"),
       cameraStreams: createSliceHandle(stateSource, binding.deviceId, "camera-streams"),
+      carbonMonoxide: createSliceHandle(stateSource, binding.deviceId, "carbon-monoxide"),
+      climateControl: createSliceHandle(stateSource, binding.deviceId, "climate-control"),
+      color: createSliceHandle(stateSource, binding.deviceId, "color"),
+      connectivity: createSliceHandle(stateSource, binding.deviceId, "connectivity"),
+      consumables: createSliceHandle(stateSource, binding.deviceId, "consumables"),
+      contact: createSliceHandle(stateSource, binding.deviceId, "contact"),
+      control: createSliceHandle(stateSource, binding.deviceId, "control"),
+      cover: createSliceHandle(stateSource, binding.deviceId, "cover"),
       deviceDiscovery: createSliceHandle(stateSource, binding.deviceId, "device-discovery"),
       deviceStatus: createSliceHandle(stateSource, binding.deviceId, "device-status"),
       doorbell: createSliceHandle(stateSource, binding.deviceId, "doorbell"),
+      enumSensor: createSliceHandle(stateSource, binding.deviceId, "enum-sensor"),
+      eventEmitter: createSliceHandle(stateSource, binding.deviceId, "event-emitter"),
+      fanControl: createSliceHandle(stateSource, binding.deviceId, "fan-control"),
       featureProbe: createSliceHandle(stateSource, binding.deviceId, "feature-probe"),
+      flood: createSliceHandle(stateSource, binding.deviceId, "flood"),
+      gas: createSliceHandle(stateSource, binding.deviceId, "gas"),
+      humidifier: createSliceHandle(stateSource, binding.deviceId, "humidifier"),
+      humiditySensor: createSliceHandle(stateSource, binding.deviceId, "humidity-sensor"),
+      image: createSliceHandle(stateSource, binding.deviceId, "image"),
+      lawnMowerControl: createSliceHandle(stateSource, binding.deviceId, "lawn-mower-control"),
+      lockControl: createSliceHandle(stateSource, binding.deviceId, "lock-control"),
+      mediaPlayer: createSliceHandle(stateSource, binding.deviceId, "media-player"),
       motion: createSliceHandle(stateSource, binding.deviceId, "motion"),
       motionTrigger: createSliceHandle(stateSource, binding.deviceId, "motion-trigger"),
       motionZones: createSliceHandle(stateSource, binding.deviceId, "motion-zones"),
       nativeObjectDetection: createSliceHandle(stateSource, binding.deviceId, "native-object-detection"),
+      notifier: createSliceHandle(stateSource, binding.deviceId, "notifier"),
+      numericSensor: createSliceHandle(stateSource, binding.deviceId, "numeric-sensor"),
+      powerMeter: createSliceHandle(stateSource, binding.deviceId, "power-meter"),
+      presence: createSliceHandle(stateSource, binding.deviceId, "presence"),
+      pressureSensor: createSliceHandle(stateSource, binding.deviceId, "pressure-sensor"),
       privacyMask: createSliceHandle(stateSource, binding.deviceId, "privacy-mask"),
       ptzAutotrack: createSliceHandle(stateSource, binding.deviceId, "ptz-autotrack"),
+      scriptRunner: createSliceHandle(stateSource, binding.deviceId, "script-runner"),
+      smoke: createSliceHandle(stateSource, binding.deviceId, "smoke"),
       streamParams: createSliceHandle(stateSource, binding.deviceId, "stream-params"),
       switch: createSliceHandle(stateSource, binding.deviceId, "switch"),
+      tamper: createSliceHandle(stateSource, binding.deviceId, "tamper"),
+      temperatureSensor: createSliceHandle(stateSource, binding.deviceId, "temperature-sensor"),
+      update: createSliceHandle(stateSource, binding.deviceId, "update"),
+      vacuumControl: createSliceHandle(stateSource, binding.deviceId, "vacuum-control"),
+      valve: createSliceHandle(stateSource, binding.deviceId, "valve"),
+      vibration: createSliceHandle(stateSource, binding.deviceId, "vibration"),
+      waterHeater: createSliceHandle(stateSource, binding.deviceId, "water-heater"),
+      weather: createSliceHandle(stateSource, binding.deviceId, "weather"),
       zoneAnalytics: createSliceHandle(stateSource, binding.deviceId, "zone-analytics"),
       zoneRules: createSliceHandle(stateSource, binding.deviceId, "zone-rules"),
       zones: createSliceHandle(stateSource, binding.deviceId, "zones")
     },
     accessories: accessoriesInterface,
+    airQualitySensor: airQualitySensorInterface,
+    alarmPanel: alarmPanelInterface,
+    ambientLightSensor: ambientLightSensorInterface,
     audioAnalysis: audioAnalysisInterface,
     audioMetrics: audioMetricsInterface,
+    automationControl: automationControlInterface,
     battery: batteryInterface,
+    binary: binaryInterface,
     brightness: brightnessInterface,
+    button: buttonInterface,
     cameraCredentials: cameraCredentialsInterface,
     cameraStreams: cameraStreamsInterface,
+    carbonMonoxide: carbonMonoxideInterface,
+    climateControl: climateControlInterface,
+    color: colorInterface,
+    connectivity: connectivityInterface,
+    consumables: consumablesInterface,
+    contact: contactInterface,
+    control: controlInterface,
+    cover: coverInterface,
     detectionPipeline: detectionPipelineInterface,
     deviceDiscovery: deviceDiscoveryInterface,
     deviceOps: deviceOpsInterface,
     deviceStatus: deviceStatusInterface,
     doorbell: doorbellInterface,
+    enumSensor: enumSensorInterface,
+    eventEmitter: eventEmitterInterface,
     events: eventsInterface,
+    fanControl: fanControlInterface,
     featureProbe: featureProbeInterface,
+    flood: floodInterface,
+    gas: gasInterface,
+    humidifier: humidifierInterface,
+    humiditySensor: humiditySensorInterface,
+    image: imageInterface,
     intercom: intercomInterface,
+    lawnMowerControl: lawnMowerControlInterface,
+    lockControl: lockControlInterface,
+    mediaPlayer: mediaPlayerInterface,
     motion: motionInterface,
     motionDetection: motionDetectionInterface,
     motionTrigger: motionTriggerInterface,
     motionZones: motionZonesInterface,
     nativeObjectDetection: nativeObjectDetectionInterface,
+    notifier: notifierInterface,
+    numericSensor: numericSensorInterface,
     osd: osdInterface,
     pipelineAnalytics: pipelineAnalyticsInterface,
+    powerMeter: powerMeterInterface,
+    presence: presenceInterface,
+    pressureSensor: pressureSensorInterface,
     privacyMask: privacyMaskInterface,
     ptz: ptzInterface,
     ptzAutotrack: ptzAutotrackInterface,
     reboot: rebootInterface,
-    recording: recordingInterface,
+    scriptRunner: scriptRunnerInterface,
+    smoke: smokeInterface,
     snapshot: snapshotInterface,
     streamCatalog: streamCatalogInterface,
     streamParams: streamParamsInterface,
     switch: switchInterface,
+    tamper: tamperInterface,
+    temperatureSensor: temperatureSensorInterface,
+    update: updateInterface,
+    vacuumControl: vacuumControlInterface,
+    valve: valveInterface,
+    vibration: vibrationInterface,
+    waterHeater: waterHeaterInterface,
+    weather: weatherInterface,
     webrtcSession: webrtcSessionInterface,
     zoneAnalytics: zoneAnalyticsInterface,
     zoneRules: zoneRulesInterface,
     zones: zonesInterface,
     addonSettings: addonSettingsInterface,
     cameraPipelineConfig: cameraPipelineConfigInterface,
+    deviceAdoption: deviceAdoptionInterface,
     deviceExport: deviceExportInterface,
     deviceManager: deviceManagerInterface,
     deviceState: deviceStateInterface,
@@ -3206,7 +3852,7 @@ function createDeviceProxy(api, binding, opts) {
     pipelineExecutor: pipelineExecutorInterface,
     pipelineOrchestrator: pipelineOrchestratorInterface,
     pipelineRunner: pipelineRunnerInterface,
-    recordingEngine: recordingEngineInterface,
+    recording: recordingInterface,
     snapshotProvider: snapshotProviderInterface,
     streamBroker: streamBrokerInterface
   };
@@ -3357,6 +4003,24 @@ function createSystemProxy(api) {
     upsertDestinationPolicy: (input) => dispatch("backup", "upsertDestinationPolicy", "mutation", input),
     previewSchedule: (input) => dispatch("backup", "previewSchedule", "query", input)
   };
+  const brokerInterface = {
+    list: (input) => dispatch("broker", "list", "query", input),
+    get: (input) => dispatch("broker", "get", "query", input),
+    listProviders: (input) => dispatch("broker", "listProviders", "query", input),
+    add: (input) => dispatch("broker", "add", "mutation", input),
+    remove: (input) => dispatch("broker", "remove", "mutation", input),
+    testConnection: (input) => dispatch("broker", "testConnection", "mutation", input),
+    getSettings: (input) => dispatch("broker", "getSettings", "query", input),
+    setSettings: (input) => dispatch("broker", "setSettings", "mutation", input),
+    getBrokerConfig: (input) => dispatch("broker", "getBrokerConfig", "query", input),
+    getSettingsSchema: (input) => dispatch("broker", "getSettingsSchema", "query", input),
+    testSettings: (input) => dispatch("broker", "testSettings", "mutation", input),
+    publish: (input) => dispatch("broker", "publish", "mutation", input),
+    subscribe: (input) => dispatch("broker", "subscribe", "mutation", input),
+    unsubscribe: (input) => dispatch("broker", "unsubscribe", "mutation", input),
+    getState: (input) => dispatch("broker", "getState", "query", input),
+    getStatus: (input) => dispatch("broker", "getStatus", "query", input)
+  };
   const decoderInterface = {
     supportsCodec: (input) => dispatch("decoder", "supportsCodec", "query", input),
     getInfo: (input) => dispatch("decoder", "getInfo", "query", input),
@@ -3373,6 +4037,15 @@ function createSystemProxy(api) {
     listActiveSessions: (input) => dispatch("decoder", "listActiveSessions", "query", input),
     reprobeHwaccel: (input) => dispatch("decoder", "reprobeHwaccel", "mutation", input)
   };
+  const deviceAdoptionInterface = {
+    listCandidateFilters: (input) => dispatch("deviceAdoption", "listCandidateFilters", "query", input),
+    listCandidates: (input) => dispatch("deviceAdoption", "listCandidates", "query", input),
+    getCandidate: (input) => dispatch("deviceAdoption", "getCandidate", "query", input),
+    refresh: (input) => dispatch("deviceAdoption", "refresh", "mutation", input),
+    adopt: (input) => dispatch("deviceAdoption", "adopt", "mutation", input),
+    release: (input) => dispatch("deviceAdoption", "release", "mutation", input),
+    resync: (input) => dispatch("deviceAdoption", "resync", "mutation", input)
+  };
   const deviceExportInterface = {
     getStatus: (input) => dispatch("deviceExport", "getStatus", "query", input),
     listSupportedDeviceKinds: (input) => dispatch("deviceExport", "listSupportedDeviceKinds", "query", input),
@@ -3391,13 +4064,18 @@ function createSystemProxy(api) {
     listPersistedByAddon: (input) => dispatch("deviceManager", "listPersistedByAddon", "query", input),
     listAll: (input) => dispatch("deviceManager", "listAll", "query", input),
     getChildren: (input) => dispatch("deviceManager", "getChildren", "query", input),
+    removeByIntegration: (input) => dispatch("deviceManager", "removeByIntegration", "mutation", input),
     listWrappersForCap: (input) => dispatch("deviceManager", "listWrappersForCap", "query", input),
     listBindableCapsForDeviceType: (input) => dispatch("deviceManager", "listBindableCapsForDeviceType", "query", input),
     discoverDevices: (input) => dispatch("deviceManager", "discoverDevices", "mutation", input),
     adoptDevice: (input) => dispatch("deviceManager", "adoptDevice", "mutation", input),
     getCreationSchema: (input) => dispatch("deviceManager", "getCreationSchema", "query", input),
     createDevice: (input) => dispatch("deviceManager", "createDevice", "mutation", input),
-    testCreationField: (input) => dispatch("deviceManager", "testCreationField", "mutation", input)
+    testCreationField: (input) => dispatch("deviceManager", "testCreationField", "mutation", input),
+    adoptionListCandidates: (input) => dispatch("deviceManager", "adoptionListCandidates", "query", input),
+    adoptionRefresh: (input) => dispatch("deviceManager", "adoptionRefresh", "mutation", input),
+    adoptionAdopt: (input) => dispatch("deviceManager", "adoptionAdopt", "mutation", input),
+    adoptionRelease: (input) => dispatch("deviceManager", "adoptionRelease", "mutation", input)
   };
   const deviceProviderInterface = {
     start: (input) => dispatch("deviceProvider", "start", "mutation", input),
@@ -3557,32 +4235,8 @@ function createSystemProxy(api) {
     getAllCameraMetrics: (input) => dispatch("pipelineRunner", "getAllCameraMetrics", "query", input),
     getLocalCameras: (input) => dispatch("pipelineRunner", "getLocalCameras", "query", input)
   };
-  const platformProbeInterface = {
-    getCapabilities: (input) => dispatch("platformProbe", "getCapabilities", "query", input),
-    getHardware: (input) => dispatch("platformProbe", "getHardware", "query", input),
-    resolveInferenceConfig: (input) => dispatch("platformProbe", "resolveInferenceConfig", "query", input),
-    resolveHwAccel: (input) => dispatch("platformProbe", "resolveHwAccel", "query", input),
-    getHardwareEncoders: (input) => dispatch("platformProbe", "getHardwareEncoders", "query", input),
-    refreshHardwareEncoders: (input) => dispatch("platformProbe", "refreshHardwareEncoders", "mutation", input)
-  };
-  const recordingEngineInterface = {
-    getStatus: (input) => dispatch("recordingEngine", "getStatus", "query", input),
-    enable: (input) => dispatch("recordingEngine", "enable", "mutation", input),
-    disable: (input) => dispatch("recordingEngine", "disable", "mutation", input),
-    getConfig: (input) => dispatch("recordingEngine", "getConfig", "query", input),
-    updateConfig: (input) => dispatch("recordingEngine", "updateConfig", "mutation", input),
-    getPlaylist: (input) => dispatch("recordingEngine", "getPlaylist", "query", input),
-    getThumbnail: (input) => dispatch("recordingEngine", "getThumbnail", "query", input),
-    getSegments: (input) => dispatch("recordingEngine", "getSegments", "query", input),
-    getAvailability: (input) => dispatch("recordingEngine", "getAvailability", "query", input),
-    estimateStorage: (input) => dispatch("recordingEngine", "estimateStorage", "query", input),
-    estimateGlobalStorage: (input) => dispatch("recordingEngine", "estimateGlobalStorage", "query", input),
-    getStorageUsage: (input) => dispatch("recordingEngine", "getStorageUsage", "query", input),
-    setPolicy: (input) => dispatch("recordingEngine", "setPolicy", "mutation", input),
-    getPolicy: (input) => dispatch("recordingEngine", "getPolicy", "query", input),
-    getRetentionConfig: (input) => dispatch("recordingEngine", "getRetentionConfig", "query", input),
-    updateRetentionConfig: (input) => dispatch("recordingEngine", "updateRetentionConfig", "mutation", input),
-    getMotionStats: (input) => dispatch("recordingEngine", "getMotionStats", "query", input)
+  const recordingInterface = {
+    getStorageUsage: (input) => dispatch("recording", "getStorageUsage", "query", input)
   };
   const settingsStoreInterface = {
     get: (input) => dispatch("settingsStore", "get", "query", input),
@@ -3592,6 +4246,7 @@ function createSystemProxy(api) {
     update: (input) => dispatch("settingsStore", "update", "mutation", input),
     delete: (input) => dispatch("settingsStore", "delete", "mutation", input),
     count: (input) => dispatch("settingsStore", "count", "query", input),
+    histogram: (input) => dispatch("settingsStore", "histogram", "query", input),
     isEmpty: (input) => dispatch("settingsStore", "isEmpty", "query", input),
     declareCollection: (input) => dispatch("settingsStore", "declareCollection", "mutation", input)
   };
@@ -3612,6 +4267,7 @@ function createSystemProxy(api) {
     endDownload: (input) => dispatch("storage", "endDownload", "mutation", input),
     listLocations: (input) => dispatch("storage", "listLocations", "query", input),
     getDefaultLocation: (input) => dispatch("storage", "getDefaultLocation", "query", input),
+    listLocationDeclarations: (input) => dispatch("storage", "listLocationDeclarations", "query", input),
     upsertLocation: (input) => dispatch("storage", "upsertLocation", "mutation", input),
     deleteLocation: (input) => dispatch("storage", "deleteLocation", "mutation", input),
     testLocation: (input) => dispatch("storage", "testLocation", "query", input),
@@ -3694,7 +4350,9 @@ function createSystemProxy(api) {
     audioAnalyzer: audioAnalyzerInterface,
     audioCodec: audioCodecInterface,
     backup: backupInterface,
+    broker: brokerInterface,
     decoder: decoderInterface,
+    deviceAdoption: deviceAdoptionInterface,
     deviceExport: deviceExportInterface,
     deviceManager: deviceManagerInterface,
     deviceProvider: deviceProviderInterface,
@@ -3711,8 +4369,7 @@ function createSystemProxy(api) {
     pipelineExecutor: pipelineExecutorInterface,
     pipelineOrchestrator: pipelineOrchestratorInterface,
     pipelineRunner: pipelineRunnerInterface,
-    platformProbe: platformProbeInterface,
-    recordingEngine: recordingEngineInterface,
+    recording: recordingInterface,
     settingsStore: settingsStoreInterface,
     storage: storageInterface,
     streamBroker: streamBrokerInterface,
@@ -4474,6 +5131,15 @@ function customAction(input, output, options) {
     scope: options?.scope ?? { kind: "system" }
   };
 }
+function deviceCustomAction(input, output, options) {
+  return {
+    input,
+    output,
+    kind: options?.kind ?? "query",
+    auth: options?.auth ?? "protected",
+    scope: { kind: "device", ...options?.deviceTypes ? { deviceTypes: options.deviceTypes } : {} }
+  };
+}
 const STREAM_PROFILE_META = [
   { profile: "main", prefix: "streamMain", label: "Main stream" },
   { profile: "sub", prefix: "streamSub", label: "Sub stream" },
@@ -4684,20 +5350,36 @@ const CAPABILITY_NAMES = {
   addons: "addons",
   adminUi: "admin-ui",
   advancedNotifier: "advanced-notifier",
+  airQualitySensor: "air-quality-sensor",
+  alarmPanel: "alarm-panel",
   alerts: "alerts",
+  ambientLightSensor: "ambient-light-sensor",
   audioAnalysis: "audio-analysis",
   audioAnalyzer: "audio-analyzer",
   audioCodec: "audio-codec",
   audioMetrics: "audio-metrics",
   authProvider: "auth-provider",
+  automationControl: "automation-control",
   backup: "backup",
   battery: "battery",
+  binary: "binary",
   brightness: "brightness",
+  broker: "broker",
+  button: "button",
   cameraCredentials: "camera-credentials",
   cameraPipelineConfig: "camera-pipeline-config",
   cameraStreams: "camera-streams",
+  carbonMonoxide: "carbon-monoxide",
+  climateControl: "climate-control",
+  color: "color",
+  connectivity: "connectivity",
+  consumables: "consumables",
+  contact: "contact",
+  control: "control",
+  cover: "cover",
   decoder: "decoder",
   detectionPipeline: "detection-pipeline",
+  deviceAdoption: "device-adoption",
   deviceDiscovery: "device-discovery",
   deviceExport: "device-export",
   deviceManager: "device-manager",
@@ -4707,12 +5389,23 @@ const CAPABILITY_NAMES = {
   deviceStatus: "device-status",
   doorbell: "doorbell",
   embeddingEncoder: "embedding-encoder",
+  enumSensor: "enum-sensor",
+  eventEmitter: "event-emitter",
   events: "events",
+  fanControl: "fan-control",
   featureProbe: "feature-probe",
+  flood: "flood",
+  gas: "gas",
+  humidifier: "humidifier",
+  humiditySensor: "humidity-sensor",
+  image: "image",
   integrations: "integrations",
   intercom: "intercom",
+  lawnMowerControl: "lawn-mower-control",
   localNetwork: "local-network",
+  lockControl: "lock-control",
   logDestination: "log-destination",
+  mediaPlayer: "media-player",
   meshNetwork: "mesh-network",
   metricsProvider: "metrics-provider",
   motion: "motion",
@@ -4725,6 +5418,8 @@ const CAPABILITY_NAMES = {
   networkQuality: "network-quality",
   nodes: "nodes",
   notificationOutput: "notification-output",
+  notifier: "notifier",
+  numericSensor: "numeric-sensor",
   oauthIntegration: "oauth-integration",
   osd: "osd",
   pipelineAnalytics: "pipeline-analytics",
@@ -4732,19 +5427,24 @@ const CAPABILITY_NAMES = {
   pipelineOrchestrator: "pipeline-orchestrator",
   pipelineRunner: "pipeline-runner",
   platformProbe: "platform-probe",
+  powerMeter: "power-meter",
+  presence: "presence",
+  pressureSensor: "pressure-sensor",
   privacyMask: "privacy-mask",
   ptz: "ptz",
   ptzAutotrack: "ptz-autotrack",
   reboot: "reboot",
   recording: "recording",
-  recordingEngine: "recording-engine",
   restreamer: "restreamer",
+  scriptRunner: "script-runner",
   settingsStore: "settings-store",
+  smoke: "smoke",
   smtpProvider: "smtp-provider",
   snapshot: "snapshot",
   snapshotProvider: "snapshot-provider",
   ssoBridge: "sso-bridge",
   storage: "storage",
+  storageEvictable: "storage-evictable",
   storageProvider: "storage-provider",
   streamBroker: "stream-broker",
   streamCatalog: "stream-catalog",
@@ -4752,10 +5452,18 @@ const CAPABILITY_NAMES = {
   streamingEngine: "streaming-engine",
   switch: "switch",
   system: "system",
+  tamper: "tamper",
+  temperatureSensor: "temperature-sensor",
   toast: "toast",
   turnProvider: "turn-provider",
+  update: "update",
   userManagement: "user-management",
   userPasskeys: "user-passkeys",
+  vacuumControl: "vacuum-control",
+  valve: "valve",
+  vibration: "vibration",
+  waterHeater: "water-heater",
+  weather: "weather",
   webrtc: "webrtc",
   webrtcSession: "webrtc-session",
   zoneAnalytics: "zone-analytics",
@@ -4773,20 +5481,36 @@ const CAPABILITY_ROUTER_KEYS = [
   { key: "addons", name: "addons" },
   { key: "adminUi", name: "admin-ui" },
   { key: "advancedNotifier", name: "advanced-notifier" },
+  { key: "airQualitySensor", name: "air-quality-sensor" },
+  { key: "alarmPanel", name: "alarm-panel" },
   { key: "alerts", name: "alerts" },
+  { key: "ambientLightSensor", name: "ambient-light-sensor" },
   { key: "audioAnalysis", name: "audio-analysis" },
   { key: "audioAnalyzer", name: "audio-analyzer" },
   { key: "audioCodec", name: "audio-codec" },
   { key: "audioMetrics", name: "audio-metrics" },
   { key: "authProvider", name: "auth-provider" },
+  { key: "automationControl", name: "automation-control" },
   { key: "backup", name: "backup" },
   { key: "battery", name: "battery" },
+  { key: "binary", name: "binary" },
   { key: "brightness", name: "brightness" },
+  { key: "broker", name: "broker" },
+  { key: "button", name: "button" },
   { key: "cameraCredentials", name: "camera-credentials" },
   { key: "cameraPipelineConfig", name: "camera-pipeline-config" },
   { key: "cameraStreams", name: "camera-streams" },
+  { key: "carbonMonoxide", name: "carbon-monoxide" },
+  { key: "climateControl", name: "climate-control" },
+  { key: "color", name: "color" },
+  { key: "connectivity", name: "connectivity" },
+  { key: "consumables", name: "consumables" },
+  { key: "contact", name: "contact" },
+  { key: "control", name: "control" },
+  { key: "cover", name: "cover" },
   { key: "decoder", name: "decoder" },
   { key: "detectionPipeline", name: "detection-pipeline" },
+  { key: "deviceAdoption", name: "device-adoption" },
   { key: "deviceDiscovery", name: "device-discovery" },
   { key: "deviceExport", name: "device-export" },
   { key: "deviceManager", name: "device-manager" },
@@ -4796,12 +5520,23 @@ const CAPABILITY_ROUTER_KEYS = [
   { key: "deviceStatus", name: "device-status" },
   { key: "doorbell", name: "doorbell" },
   { key: "embeddingEncoder", name: "embedding-encoder" },
+  { key: "enumSensor", name: "enum-sensor" },
+  { key: "eventEmitter", name: "event-emitter" },
   { key: "events", name: "events" },
+  { key: "fanControl", name: "fan-control" },
   { key: "featureProbe", name: "feature-probe" },
+  { key: "flood", name: "flood" },
+  { key: "gas", name: "gas" },
+  { key: "humidifier", name: "humidifier" },
+  { key: "humiditySensor", name: "humidity-sensor" },
+  { key: "image", name: "image" },
   { key: "integrations", name: "integrations" },
   { key: "intercom", name: "intercom" },
+  { key: "lawnMowerControl", name: "lawn-mower-control" },
   { key: "localNetwork", name: "local-network" },
+  { key: "lockControl", name: "lock-control" },
   { key: "logDestination", name: "log-destination" },
+  { key: "mediaPlayer", name: "media-player" },
   { key: "meshNetwork", name: "mesh-network" },
   { key: "metricsProvider", name: "metrics-provider" },
   { key: "motion", name: "motion" },
@@ -4814,6 +5549,8 @@ const CAPABILITY_ROUTER_KEYS = [
   { key: "networkQuality", name: "network-quality" },
   { key: "nodes", name: "nodes" },
   { key: "notificationOutput", name: "notification-output" },
+  { key: "notifier", name: "notifier" },
+  { key: "numericSensor", name: "numeric-sensor" },
   { key: "oauthIntegration", name: "oauth-integration" },
   { key: "osd", name: "osd" },
   { key: "pipelineAnalytics", name: "pipeline-analytics" },
@@ -4821,19 +5558,24 @@ const CAPABILITY_ROUTER_KEYS = [
   { key: "pipelineOrchestrator", name: "pipeline-orchestrator" },
   { key: "pipelineRunner", name: "pipeline-runner" },
   { key: "platformProbe", name: "platform-probe" },
+  { key: "powerMeter", name: "power-meter" },
+  { key: "presence", name: "presence" },
+  { key: "pressureSensor", name: "pressure-sensor" },
   { key: "privacyMask", name: "privacy-mask" },
   { key: "ptz", name: "ptz" },
   { key: "ptzAutotrack", name: "ptz-autotrack" },
   { key: "reboot", name: "reboot" },
   { key: "recording", name: "recording" },
-  { key: "recordingEngine", name: "recording-engine" },
   { key: "restreamer", name: "restreamer" },
+  { key: "scriptRunner", name: "script-runner" },
   { key: "settingsStore", name: "settings-store" },
+  { key: "smoke", name: "smoke" },
   { key: "smtpProvider", name: "smtp-provider" },
   { key: "snapshot", name: "snapshot" },
   { key: "snapshotProvider", name: "snapshot-provider" },
   { key: "ssoBridge", name: "sso-bridge" },
   { key: "storage", name: "storage" },
+  { key: "storageEvictable", name: "storage-evictable" },
   { key: "storageProvider", name: "storage-provider" },
   { key: "streamBroker", name: "stream-broker" },
   { key: "streamCatalog", name: "stream-catalog" },
@@ -4841,10 +5583,18 @@ const CAPABILITY_ROUTER_KEYS = [
   { key: "streamingEngine", name: "streaming-engine" },
   { key: "switch", name: "switch" },
   { key: "system", name: "system" },
+  { key: "tamper", name: "tamper" },
+  { key: "temperatureSensor", name: "temperature-sensor" },
   { key: "toast", name: "toast" },
   { key: "turnProvider", name: "turn-provider" },
+  { key: "update", name: "update" },
   { key: "userManagement", name: "user-management" },
   { key: "userPasskeys", name: "user-passkeys" },
+  { key: "vacuumControl", name: "vacuum-control" },
+  { key: "valve", name: "valve" },
+  { key: "vibration", name: "vibration" },
+  { key: "waterHeater", name: "water-heater" },
+  { key: "weather", name: "weather" },
   { key: "webrtc", name: "webrtc" },
   { key: "webrtcSession", name: "webrtc-session" },
   { key: "zoneAnalytics", name: "zone-analytics" },
@@ -4862,20 +5612,36 @@ const ALL_CAPABILITY_DEFINITIONS = [
   addonsCapability,
   adminUiCapability,
   advancedNotifierCapability,
+  airQualitySensorCapability,
+  alarmPanelCapability,
   alertsCapability,
+  ambientLightSensorCapability,
   audioAnalysisCapability,
   audioAnalyzerCapability,
   audioCodecCapability,
   audioMetricsCapability,
   authProviderCapability,
+  automationControlCapability,
   backupCapability,
   batteryCapability,
+  binaryCapability,
   brightnessCapability,
+  brokerCapability,
+  buttonCapability,
   cameraCredentialsCapability,
   cameraPipelineConfigCapability,
   cameraStreamsCapability,
+  carbonMonoxideCapability,
+  climateControlCapability,
+  colorCapability,
+  connectivityCapability,
+  consumablesCapability,
+  contactCapability,
+  controlCapability,
+  coverCapability,
   decoderCapability,
   detectionPipelineCapability,
+  deviceAdoptionCapability,
   deviceDiscoveryCapability,
   deviceExportCapability,
   deviceManagerCapability,
@@ -4885,12 +5651,23 @@ const ALL_CAPABILITY_DEFINITIONS = [
   deviceStatusCapability,
   doorbellCapability,
   embeddingEncoderCapability,
+  enumSensorCapability,
+  eventEmitterCapability,
   eventsCapability,
+  fanControlCapability,
   featureProbeCapability,
+  floodCapability,
+  gasCapability,
+  humidifierCapability,
+  humiditySensorCapability,
+  imageCapability,
   integrationsCapability,
   intercomCapability,
+  lawnMowerControlCapability,
   localNetworkCapability,
+  lockControlCapability,
   logDestinationCapability,
+  mediaPlayerCapability,
   meshNetworkCapability,
   metricsProviderCapability,
   motionCapability,
@@ -4903,6 +5680,8 @@ const ALL_CAPABILITY_DEFINITIONS = [
   networkQualityCapability,
   nodesCapability,
   notificationOutputCapability,
+  notifierCapability,
+  numericSensorCapability,
   oauthIntegrationCapability,
   osdCapability,
   pipelineAnalyticsCapability,
@@ -4910,19 +5689,24 @@ const ALL_CAPABILITY_DEFINITIONS = [
   pipelineOrchestratorCapability,
   pipelineRunnerCapability,
   platformProbeCapability,
+  powerMeterCapability,
+  presenceCapability,
+  pressureSensorCapability,
   privacyMaskCapability,
   ptzCapability,
   ptzAutotrackCapability,
   rebootCapability,
   recordingCapability,
-  recordingEngineCapability,
   restreamerCapability,
+  scriptRunnerCapability,
   settingsStoreCapability,
+  smokeCapability,
   smtpProviderCapability,
   snapshotCapability,
   snapshotProviderCapability,
   ssoBridgeCapability,
   storageCapability,
+  storageEvictableCapability,
   storageProviderCapability,
   streamBrokerCapability,
   streamCatalogCapability,
@@ -4930,10 +5714,18 @@ const ALL_CAPABILITY_DEFINITIONS = [
   streamingEngineCapability,
   switchCapability,
   systemCapability,
+  tamperCapability,
+  temperatureSensorCapability,
   toastCapability,
   turnProviderCapability,
+  updateCapability,
   userManagementCapability,
   userPasskeysCapability,
+  vacuumControlCapability,
+  valveCapability,
+  vibrationCapability,
+  waterHeaterCapability,
+  weatherCapability,
   webrtcCapability,
   webrtcSessionCapability,
   zoneAnalyticsCapability,
@@ -4942,29 +5734,72 @@ const ALL_CAPABILITY_DEFINITIONS = [
 ];
 const CAP_NAMES_WITH_STATUS = [
   "accessories",
+  "air-quality-sensor",
+  "alarm-panel",
+  "ambient-light-sensor",
+  "automation-control",
   "battery",
+  "binary",
   "brightness",
+  "broker",
   "camera-credentials",
+  "carbon-monoxide",
+  "climate-control",
+  "color",
+  "connectivity",
+  "consumables",
+  "contact",
+  "control",
+  "cover",
+  "device-adoption",
   "device-discovery",
   "device-export",
   "device-status",
   "doorbell",
+  "enum-sensor",
+  "event-emitter",
+  "fan-control",
   "feature-probe",
+  "flood",
+  "gas",
+  "humidifier",
+  "humidity-sensor",
+  "image",
   "intercom",
+  "lawn-mower-control",
+  "lock-control",
+  "media-player",
   "motion",
   "motion-trigger",
   "motion-zones",
   "mqtt-broker",
   "native-object-detection",
+  "notifier",
+  "numeric-sensor",
   "osd",
+  "power-meter",
+  "presence",
+  "pressure-sensor",
   "privacy-mask",
   "ptz",
   "ptz-autotrack",
+  "recording",
+  "script-runner",
+  "smoke",
   "snapshot",
   "stream-params",
-  "switch"
+  "switch",
+  "tamper",
+  "temperature-sensor",
+  "update",
+  "vacuum-control",
+  "valve",
+  "vibration",
+  "water-heater",
+  "weather"
 ];
 const METHOD_ACCESS_MAP = Object.freeze({
+  "accessories.setChildHidden": { capName: "accessories", capScope: "device", addonId: null, access: "create" },
   "addonPages.listPages": { capName: "addon-pages", capScope: "system", addonId: null, access: "view" },
   "addonPagesSource.listPages": { capName: "addon-pages-source", capScope: "system", addonId: null, access: "view" },
   "addonRoutes.getRoutes": { capName: "addon-routes", capScope: "system", addonId: null, access: "view" },
@@ -5016,6 +5851,9 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "advancedNotifier.getRules": { capName: "advanced-notifier", capScope: "system", addonId: null, access: "view" },
   "advancedNotifier.testRule": { capName: "advanced-notifier", capScope: "system", addonId: null, access: "create" },
   "advancedNotifier.upsertRule": { capName: "advanced-notifier", capScope: "system", addonId: null, access: "create" },
+  "alarmPanel.arm": { capName: "alarm-panel", capScope: "device", addonId: null, access: "create" },
+  "alarmPanel.disarm": { capName: "alarm-panel", capScope: "device", addonId: null, access: "create" },
+  "alarmPanel.trigger": { capName: "alarm-panel", capScope: "device", addonId: null, access: "create" },
   "alerts.dismiss": { capName: "alerts", capScope: "system", addonId: null, access: "create" },
   "alerts.emit": { capName: "alerts", capScope: "system", addonId: null, access: "create" },
   "alerts.getUnreadCount": { capName: "alerts", capScope: "system", addonId: null, access: "view" },
@@ -5046,6 +5884,9 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "authProvider.handleCallback": { capName: "auth-provider", capScope: "system", addonId: null, access: "create" },
   "authProvider.validateCredentials": { capName: "auth-provider", capScope: "system", addonId: null, access: "create" },
   "authProvider.validateToken": { capName: "auth-provider", capScope: "system", addonId: null, access: "view" },
+  "automationControl.disable": { capName: "automation-control", capScope: "device", addonId: null, access: "create" },
+  "automationControl.enable": { capName: "automation-control", capScope: "device", addonId: null, access: "create" },
+  "automationControl.trigger": { capName: "automation-control", capScope: "device", addonId: null, access: "create" },
   "backup.delete": { capName: "backup", capScope: "system", addonId: null, access: "delete" },
   "backup.getEntries": { capName: "backup", capScope: "system", addonId: null, access: "view" },
   "backup.list": { capName: "backup", capScope: "system", addonId: null, access: "view" },
@@ -5056,11 +5897,45 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "backup.restore": { capName: "backup", capScope: "system", addonId: null, access: "create" },
   "backup.trigger": { capName: "backup", capScope: "system", addonId: null, access: "create" },
   "backup.upsertDestinationPolicy": { capName: "backup", capScope: "system", addonId: null, access: "create" },
+  "battery.wakeForStream": { capName: "battery", capScope: "device", addonId: null, access: "create" },
   "brightness.setBrightness": { capName: "brightness", capScope: "device", addonId: null, access: "create" },
+  "broker.add": { capName: "broker", capScope: "system", addonId: null, access: "create" },
+  "broker.get": { capName: "broker", capScope: "system", addonId: null, access: "view" },
+  "broker.getBrokerConfig": { capName: "broker", capScope: "system", addonId: null, access: "view" },
+  "broker.getSettings": { capName: "broker", capScope: "system", addonId: null, access: "view" },
+  "broker.getSettingsSchema": { capName: "broker", capScope: "system", addonId: null, access: "view" },
+  "broker.getState": { capName: "broker", capScope: "system", addonId: null, access: "view" },
+  "broker.getStatus": { capName: "broker", capScope: "system", addonId: null, access: "view" },
+  "broker.list": { capName: "broker", capScope: "system", addonId: null, access: "view" },
+  "broker.listProviders": { capName: "broker", capScope: "system", addonId: null, access: "view" },
+  "broker.publish": { capName: "broker", capScope: "system", addonId: null, access: "create" },
+  "broker.remove": { capName: "broker", capScope: "system", addonId: null, access: "delete" },
+  "broker.setSettings": { capName: "broker", capScope: "system", addonId: null, access: "create" },
+  "broker.subscribe": { capName: "broker", capScope: "system", addonId: null, access: "create" },
+  "broker.testConnection": { capName: "broker", capScope: "system", addonId: null, access: "create" },
+  "broker.testSettings": { capName: "broker", capScope: "system", addonId: null, access: "create" },
+  "broker.unsubscribe": { capName: "broker", capScope: "system", addonId: null, access: "create" },
+  "button.press": { capName: "button", capScope: "device", addonId: null, access: "create" },
   "cameraCredentials.getCredentials": { capName: "camera-credentials", capScope: "device", addonId: null, access: "view" },
   "cameraStreams.getBrokerStreams": { capName: "camera-streams", capScope: "device", addonId: null, access: "view" },
   "cameraStreams.getCameraStreams": { capName: "camera-streams", capScope: "device", addonId: null, access: "view" },
+  "cameraStreams.getProfileRtspEntries": { capName: "camera-streams", capScope: "device", addonId: null, access: "view" },
   "cameraStreams.getRtspEntries": { capName: "camera-streams", capScope: "device", addonId: null, access: "view" },
+  "cameraStreams.pickStream": { capName: "camera-streams", capScope: "device", addonId: null, access: "view" },
+  "climateControl.setFanMode": { capName: "climate-control", capScope: "device", addonId: null, access: "create" },
+  "climateControl.setMode": { capName: "climate-control", capScope: "device", addonId: null, access: "create" },
+  "climateControl.setPreset": { capName: "climate-control", capScope: "device", addonId: null, access: "create" },
+  "climateControl.setTarget": { capName: "climate-control", capScope: "device", addonId: null, access: "create" },
+  "climateControl.setTargetHumidity": { capName: "climate-control", capScope: "device", addonId: null, access: "create" },
+  "climateControl.setTargetRange": { capName: "climate-control", capScope: "device", addonId: null, access: "create" },
+  "color.setColor": { capName: "color", capScope: "device", addonId: null, access: "create" },
+  "consumables.reset": { capName: "consumables", capScope: "device", addonId: null, access: "delete" },
+  "control.setValue": { capName: "control", capScope: "device", addonId: null, access: "create" },
+  "cover.close": { capName: "cover", capScope: "device", addonId: null, access: "create" },
+  "cover.open": { capName: "cover", capScope: "device", addonId: null, access: "create" },
+  "cover.setPosition": { capName: "cover", capScope: "device", addonId: null, access: "create" },
+  "cover.setTiltPosition": { capName: "cover", capScope: "device", addonId: null, access: "create" },
+  "cover.stop": { capName: "cover", capScope: "device", addonId: null, access: "create" },
   "decoder.createSession": { capName: "decoder", capScope: "system", addonId: null, access: "view" },
   "decoder.destroySession": { capName: "decoder", capScope: "system", addonId: null, access: "delete" },
   "decoder.getFrame": { capName: "decoder", capScope: "system", addonId: null, access: "view" },
@@ -5075,6 +5950,13 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "decoder.reprobeHwaccel": { capName: "decoder", capScope: "system", addonId: null, access: "create" },
   "decoder.supportsCodec": { capName: "decoder", capScope: "system", addonId: null, access: "view" },
   "decoder.updateConfig": { capName: "decoder", capScope: "system", addonId: null, access: "view" },
+  "deviceAdoption.adopt": { capName: "device-adoption", capScope: "system", addonId: null, access: "create" },
+  "deviceAdoption.getCandidate": { capName: "device-adoption", capScope: "system", addonId: null, access: "view" },
+  "deviceAdoption.listCandidateFilters": { capName: "device-adoption", capScope: "system", addonId: null, access: "view" },
+  "deviceAdoption.listCandidates": { capName: "device-adoption", capScope: "system", addonId: null, access: "view" },
+  "deviceAdoption.refresh": { capName: "device-adoption", capScope: "system", addonId: null, access: "create" },
+  "deviceAdoption.release": { capName: "device-adoption", capScope: "system", addonId: null, access: "create" },
+  "deviceAdoption.resync": { capName: "device-adoption", capScope: "system", addonId: null, access: "create" },
   "deviceDiscovery.adoptDevice": { capName: "device-discovery", capScope: "device", addonId: null, access: "create" },
   "deviceDiscovery.listDiscovered": { capName: "device-discovery", capScope: "device", addonId: null, access: "view" },
   "deviceDiscovery.refreshDiscovery": { capName: "device-discovery", capScope: "device", addonId: null, access: "create" },
@@ -5086,7 +5968,12 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "deviceExport.unexposeDevice": { capName: "device-export", capScope: "system", addonId: null, access: "create" },
   "deviceManager.addLocation": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.adoptDevice": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
+  "deviceManager.adoptionAdopt": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
+  "deviceManager.adoptionListCandidates": { capName: "device-manager", capScope: "system", addonId: null, access: "view" },
+  "deviceManager.adoptionRefresh": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
+  "deviceManager.adoptionRelease": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.allocateDeviceId": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
+  "deviceManager.applyInitialMeta": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.createDevice": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.disable": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.discoverDevices": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
@@ -5104,6 +5991,7 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "deviceManager.getSettingsSchema": { capName: "device-manager", capScope: "system", addonId: null, access: "view" },
   "deviceManager.getStreamProfileMap": { capName: "device-manager", capScope: "system", addonId: null, access: "view" },
   "deviceManager.getStreamSources": { capName: "device-manager", capScope: "system", addonId: null, access: "view" },
+  "deviceManager.getWireableFields": { capName: "device-manager", capScope: "system", addonId: null, access: "view" },
   "deviceManager.listAll": { capName: "device-manager", capScope: "system", addonId: null, access: "view" },
   "deviceManager.listBindableCapsForDeviceType": { capName: "device-manager", capScope: "system", addonId: null, access: "view" },
   "deviceManager.listLocations": { capName: "device-manager", capScope: "system", addonId: null, access: "view" },
@@ -5116,13 +6004,22 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "deviceManager.probeStreams": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.registerDevice": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.remove": { capName: "device-manager", capScope: "system", addonId: null, access: "delete" },
+  "deviceManager.removeByIntegration": { capName: "device-manager", capScope: "system", addonId: null, access: "delete" },
   "deviceManager.removeDevice": { capName: "device-manager", capScope: "system", addonId: null, access: "delete" },
   "deviceManager.removeLocation": { capName: "device-manager", capScope: "system", addonId: null, access: "delete" },
+  "deviceManager.runDeviceAction": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
+  "deviceManager.setChildLayout": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
+  "deviceManager.setDeviceLinks": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.setDisabled": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
+  "deviceManager.setIntegrationId": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
+  "deviceManager.setLinkDeviceId": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.setLocation": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.setMetadata": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.setName": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
+  "deviceManager.setPrimaryChildEntityId": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
+  "deviceManager.setRole": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.setStreamProfileMap": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
+  "deviceManager.setType": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.setWrapperActive": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.testCreationField": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.testField": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
@@ -5130,9 +6027,11 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "deviceManager.updateDeviceField": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceManager.updateDeviceFieldsBatch": { capName: "device-manager", capScope: "system", addonId: null, access: "create" },
   "deviceOps.getConfigEntries": { capName: "device-ops", capScope: "device", addonId: null, access: "view" },
+  "deviceOps.getRawState": { capName: "device-ops", capScope: "device", addonId: null, access: "view" },
   "deviceOps.getSettingsSchema": { capName: "device-ops", capScope: "device", addonId: null, access: "view" },
   "deviceOps.getStreamSources": { capName: "device-ops", capScope: "device", addonId: null, access: "view" },
   "deviceOps.removeDevice": { capName: "device-ops", capScope: "device", addonId: null, access: "delete" },
+  "deviceOps.runAction": { capName: "device-ops", capScope: "device", addonId: null, access: "create" },
   "deviceOps.setConfig": { capName: "device-ops", capScope: "device", addonId: null, access: "create" },
   "deviceProvider.adoptDiscoveredDevice": { capName: "device-provider", capScope: "system", addonId: null, access: "create" },
   "deviceProvider.createDevice": { capName: "device-provider", capScope: "system", addonId: null, access: "create" },
@@ -5155,6 +6054,13 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "events.getEventClipUrl": { capName: "events", capScope: "device", addonId: null, access: "view" },
   "events.getEvents": { capName: "events", capScope: "device", addonId: null, access: "view" },
   "events.getEventThumbnail": { capName: "events", capScope: "device", addonId: null, access: "view" },
+  "fanControl.setDirection": { capName: "fan-control", capScope: "device", addonId: null, access: "create" },
+  "fanControl.setOscillating": { capName: "fan-control", capScope: "device", addonId: null, access: "create" },
+  "fanControl.setPercentage": { capName: "fan-control", capScope: "device", addonId: null, access: "create" },
+  "fanControl.setPreset": { capName: "fan-control", capScope: "device", addonId: null, access: "create" },
+  "humidifier.setMode": { capName: "humidifier", capScope: "device", addonId: null, access: "create" },
+  "humidifier.setOn": { capName: "humidifier", capScope: "device", addonId: null, access: "create" },
+  "humidifier.setTargetHumidity": { capName: "humidifier", capScope: "device", addonId: null, access: "create" },
   "integrations.create": { capName: "integrations", capScope: "system", addonId: null, access: "create" },
   "integrations.delete": { capName: "integrations", capScope: "system", addonId: null, access: "delete" },
   "integrations.get": { capName: "integrations", capScope: "system", addonId: null, access: "view" },
@@ -5167,18 +6073,36 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "integrations.update": { capName: "integrations", capScope: "system", addonId: null, access: "create" },
   "intercom.endTalkSession": { capName: "intercom", capScope: "device", addonId: null, access: "create" },
   "intercom.handleAnswer": { capName: "intercom", capScope: "device", addonId: null, access: "create" },
-  "intercom.pushTalkPcm": { capName: "intercom", capScope: "device", addonId: null, access: "create" },
+  "intercom.pushTalkAudio": { capName: "intercom", capScope: "device", addonId: null, access: "create" },
   "intercom.startSession": { capName: "intercom", capScope: "device", addonId: null, access: "create" },
   "intercom.startTalkSession": { capName: "intercom", capScope: "device", addonId: null, access: "create" },
   "intercom.stopSession": { capName: "intercom", capScope: "device", addonId: null, access: "create" },
+  "lawnMowerControl.dock": { capName: "lawn-mower-control", capScope: "device", addonId: null, access: "create" },
+  "lawnMowerControl.pause": { capName: "lawn-mower-control", capScope: "device", addonId: null, access: "create" },
+  "lawnMowerControl.startMowing": { capName: "lawn-mower-control", capScope: "device", addonId: null, access: "create" },
   "localNetwork.getAllowedAddresses": { capName: "local-network", capScope: "system", addonId: null, access: "view" },
   "localNetwork.getConnectionEndpoints": { capName: "local-network", capScope: "system", addonId: null, access: "view" },
   "localNetwork.getPreferred": { capName: "local-network", capScope: "system", addonId: null, access: "view" },
   "localNetwork.list": { capName: "local-network", capScope: "system", addonId: null, access: "view" },
   "localNetwork.resetAllowlistToBestMatch": { capName: "local-network", capScope: "system", addonId: null, access: "delete" },
   "localNetwork.setAllowedAddresses": { capName: "local-network", capScope: "system", addonId: null, access: "create" },
+  "lockControl.lock": { capName: "lock-control", capScope: "device", addonId: null, access: "create" },
+  "lockControl.open": { capName: "lock-control", capScope: "device", addonId: null, access: "create" },
+  "lockControl.unlock": { capName: "lock-control", capScope: "device", addonId: null, access: "create" },
   "logDestination.query": { capName: "log-destination", capScope: "system", addonId: null, access: "view" },
   "logDestination.write": { capName: "log-destination", capScope: "system", addonId: null, access: "create" },
+  "mediaPlayer.next": { capName: "media-player", capScope: "device", addonId: null, access: "create" },
+  "mediaPlayer.pause": { capName: "media-player", capScope: "device", addonId: null, access: "create" },
+  "mediaPlayer.play": { capName: "media-player", capScope: "device", addonId: null, access: "create" },
+  "mediaPlayer.playMedia": { capName: "media-player", capScope: "device", addonId: null, access: "create" },
+  "mediaPlayer.previous": { capName: "media-player", capScope: "device", addonId: null, access: "create" },
+  "mediaPlayer.seek": { capName: "media-player", capScope: "device", addonId: null, access: "create" },
+  "mediaPlayer.selectSource": { capName: "media-player", capScope: "device", addonId: null, access: "create" },
+  "mediaPlayer.setMute": { capName: "media-player", capScope: "device", addonId: null, access: "create" },
+  "mediaPlayer.setRepeat": { capName: "media-player", capScope: "device", addonId: null, access: "create" },
+  "mediaPlayer.setShuffle": { capName: "media-player", capScope: "device", addonId: null, access: "create" },
+  "mediaPlayer.setVolume": { capName: "media-player", capScope: "device", addonId: null, access: "create" },
+  "mediaPlayer.stop": { capName: "media-player", capScope: "device", addonId: null, access: "create" },
   "meshNetwork.getStatus": { capName: "mesh-network", capScope: "system", addonId: null, access: "view" },
   "meshNetwork.join": { capName: "mesh-network", capScope: "system", addonId: null, access: "create" },
   "meshNetwork.leave": { capName: "mesh-network", capScope: "system", addonId: null, access: "create" },
@@ -5236,17 +6160,21 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "nodes.undeployAddon": { capName: "nodes", capScope: "system", addonId: null, access: "create" },
   "notificationOutput.send": { capName: "notification-output", capScope: "system", addonId: null, access: "create" },
   "notificationOutput.sendTest": { capName: "notification-output", capScope: "system", addonId: null, access: "create" },
+  "notifier.cancel": { capName: "notifier", capScope: "device", addonId: null, access: "create" },
+  "notifier.send": { capName: "notifier", capScope: "device", addonId: null, access: "create" },
   "oauthIntegration.getDescriptor": { capName: "oauth-integration", capScope: "system", addonId: null, access: "view" },
   "osd.setOverlay": { capName: "osd", capScope: "device", addonId: null, access: "create" },
   "pipelineAnalytics.clearTracks": { capName: "pipeline-analytics", capScope: "device", addonId: null, access: "delete" },
   "pipelineAnalytics.getActiveTracks": { capName: "pipeline-analytics", capScope: "device", addonId: null, access: "view" },
   "pipelineAnalytics.getAudioEvents": { capName: "pipeline-analytics", capScope: "device", addonId: null, access: "view" },
+  "pipelineAnalytics.getEventDensity": { capName: "pipeline-analytics", capScope: "device", addonId: null, access: "view" },
   "pipelineAnalytics.getEventMedia": { capName: "pipeline-analytics", capScope: "device", addonId: null, access: "view" },
   "pipelineAnalytics.getMotionEvents": { capName: "pipeline-analytics", capScope: "device", addonId: null, access: "view" },
   "pipelineAnalytics.getObjectEvents": { capName: "pipeline-analytics", capScope: "device", addonId: null, access: "view" },
   "pipelineAnalytics.getTrack": { capName: "pipeline-analytics", capScope: "device", addonId: null, access: "view" },
   "pipelineAnalytics.getTrackMedia": { capName: "pipeline-analytics", capScope: "device", addonId: null, access: "view" },
   "pipelineAnalytics.listTracks": { capName: "pipeline-analytics", capScope: "device", addonId: null, access: "view" },
+  "pipelineAnalytics.pruneEventsBefore": { capName: "pipeline-analytics", capScope: "device", addonId: null, access: "create" },
   "pipelineExecutor.cacheFrameInPool": { capName: "pipeline-executor", capScope: "system", addonId: null, access: "create" },
   "pipelineExecutor.deleteModel": { capName: "pipeline-executor", capScope: "system", addonId: null, access: "delete" },
   "pipelineExecutor.deleteTemplate": { capName: "pipeline-executor", capScope: "system", addonId: null, access: "delete" },
@@ -5325,7 +6253,9 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "pipelineRunner.reportMotion": { capName: "pipeline-runner", capScope: "system", addonId: null, access: "create" },
   "platformProbe.getCapabilities": { capName: "platform-probe", capScope: "system", addonId: null, access: "view" },
   "platformProbe.getHardware": { capName: "platform-probe", capScope: "system", addonId: null, access: "view" },
+  "platformProbe.getHardwareDecodeAccels": { capName: "platform-probe", capScope: "system", addonId: null, access: "view" },
   "platformProbe.getHardwareEncoders": { capName: "platform-probe", capScope: "system", addonId: null, access: "view" },
+  "platformProbe.refreshHardwareDecodeAccels": { capName: "platform-probe", capScope: "system", addonId: null, access: "create" },
   "platformProbe.refreshHardwareEncoders": { capName: "platform-probe", capScope: "system", addonId: null, access: "create" },
   "platformProbe.resolveHwAccel": { capName: "platform-probe", capScope: "system", addonId: null, access: "view" },
   "platformProbe.resolveInferenceConfig": { capName: "platform-probe", capScope: "system", addonId: null, access: "view" },
@@ -5347,34 +6277,23 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "ptzAutotrack.setEnabled": { capName: "ptz-autotrack", capScope: "device", addonId: null, access: "create" },
   "ptzAutotrack.setSettings": { capName: "ptz-autotrack", capScope: "device", addonId: null, access: "create" },
   "reboot.reboot": { capName: "reboot", capScope: "device", addonId: null, access: "create" },
-  "recording.getPlaybackUrl": { capName: "recording", capScope: "device", addonId: null, access: "view" },
-  "recording.getSegments": { capName: "recording", capScope: "device", addonId: null, access: "view" },
-  "recording.getThumbnailAt": { capName: "recording", capScope: "device", addonId: null, access: "view" },
-  "recordingEngine.disable": { capName: "recording-engine", capScope: "system", addonId: null, access: "create" },
-  "recordingEngine.enable": { capName: "recording-engine", capScope: "system", addonId: null, access: "create" },
-  "recordingEngine.estimateGlobalStorage": { capName: "recording-engine", capScope: "system", addonId: null, access: "view" },
-  "recordingEngine.estimateStorage": { capName: "recording-engine", capScope: "system", addonId: null, access: "view" },
-  "recordingEngine.getAvailability": { capName: "recording-engine", capScope: "system", addonId: null, access: "view" },
-  "recordingEngine.getConfig": { capName: "recording-engine", capScope: "system", addonId: null, access: "view" },
-  "recordingEngine.getMotionStats": { capName: "recording-engine", capScope: "system", addonId: null, access: "view" },
-  "recordingEngine.getPlaylist": { capName: "recording-engine", capScope: "system", addonId: null, access: "view" },
-  "recordingEngine.getPolicy": { capName: "recording-engine", capScope: "system", addonId: null, access: "view" },
-  "recordingEngine.getPolicyStatus": { capName: "recording-engine", capScope: "system", addonId: null, access: "view" },
-  "recordingEngine.getRetentionConfig": { capName: "recording-engine", capScope: "system", addonId: null, access: "view" },
-  "recordingEngine.getSegments": { capName: "recording-engine", capScope: "system", addonId: null, access: "view" },
-  "recordingEngine.getStatus": { capName: "recording-engine", capScope: "system", addonId: null, access: "view" },
-  "recordingEngine.getStorageUsage": { capName: "recording-engine", capScope: "system", addonId: null, access: "view" },
-  "recordingEngine.getThumbnail": { capName: "recording-engine", capScope: "system", addonId: null, access: "view" },
-  "recordingEngine.setPolicy": { capName: "recording-engine", capScope: "system", addonId: null, access: "create" },
-  "recordingEngine.updateConfig": { capName: "recording-engine", capScope: "system", addonId: null, access: "create" },
-  "recordingEngine.updateRetentionConfig": { capName: "recording-engine", capScope: "system", addonId: null, access: "create" },
+  "recording.getAvailability": { capName: "recording", capScope: "system", addonId: null, access: "view" },
+  "recording.getDeviceConfig": { capName: "recording", capScope: "system", addonId: null, access: "view" },
+  "recording.getPlaybackManifest": { capName: "recording", capScope: "system", addonId: null, access: "view" },
+  "recording.getStorageUsage": { capName: "recording", capScope: "system", addonId: null, access: "view" },
+  "recording.pruneFootage": { capName: "recording", capScope: "system", addonId: null, access: "create" },
+  "recording.rescanStorage": { capName: "recording", capScope: "system", addonId: null, access: "create" },
+  "recording.setDeviceConfig": { capName: "recording", capScope: "system", addonId: null, access: "create" },
   "restreamer.getExposedResources": { capName: "restreamer", capScope: "system", addonId: null, access: "view" },
   "restreamer.registerDevice": { capName: "restreamer", capScope: "system", addonId: null, access: "create" },
   "restreamer.unregisterDevice": { capName: "restreamer", capScope: "system", addonId: null, access: "delete" },
+  "scriptRunner.run": { capName: "script-runner", capScope: "device", addonId: null, access: "create" },
+  "scriptRunner.stop": { capName: "script-runner", capScope: "device", addonId: null, access: "create" },
   "settingsStore.count": { capName: "settings-store", capScope: "system", addonId: null, access: "view" },
   "settingsStore.declareCollection": { capName: "settings-store", capScope: "system", addonId: null, access: "create" },
   "settingsStore.delete": { capName: "settings-store", capScope: "system", addonId: null, access: "delete" },
   "settingsStore.get": { capName: "settings-store", capScope: "system", addonId: null, access: "view" },
+  "settingsStore.histogram": { capName: "settings-store", capScope: "system", addonId: null, access: "view" },
   "settingsStore.insert": { capName: "settings-store", capScope: "system", addonId: null, access: "create" },
   "settingsStore.isEmpty": { capName: "settings-store", capScope: "system", addonId: null, access: "view" },
   "settingsStore.query": { capName: "settings-store", capScope: "system", addonId: null, access: "view" },
@@ -5400,6 +6319,7 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "storage.getAvailableSpace": { capName: "storage", capScope: "system", addonId: null, access: "view" },
   "storage.getDefaultLocation": { capName: "storage", capScope: "system", addonId: null, access: "view" },
   "storage.list": { capName: "storage", capScope: "system", addonId: null, access: "view" },
+  "storage.listLocationDeclarations": { capName: "storage", capScope: "system", addonId: null, access: "view" },
   "storage.listLocations": { capName: "storage", capScope: "system", addonId: null, access: "view" },
   "storage.listProviders": { capName: "storage", capScope: "system", addonId: null, access: "view" },
   "storage.read": { capName: "storage", capScope: "system", addonId: null, access: "view" },
@@ -5410,6 +6330,8 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "storage.upsertLocation": { capName: "storage", capScope: "system", addonId: null, access: "create" },
   "storage.write": { capName: "storage", capScope: "system", addonId: null, access: "create" },
   "storage.writeChunk": { capName: "storage", capScope: "system", addonId: null, access: "create" },
+  "storageEvictable.evict": { capName: "storage-evictable", capScope: "system", addonId: null, access: "create" },
+  "storageEvictable.getEvictableUsage": { capName: "storage-evictable", capScope: "system", addonId: null, access: "view" },
   "storageProvider.abortUpload": { capName: "storage-provider", capScope: "system", addonId: null, access: "create" },
   "storageProvider.beginDownload": { capName: "storage-provider", capScope: "system", addonId: null, access: "create" },
   "storageProvider.beginUpload": { capName: "storage-provider", capScope: "system", addonId: null, access: "create" },
@@ -5471,6 +6393,7 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "system.setRetentionConfig": { capName: "system", capScope: "system", addonId: null, access: "create" },
   "toast.onToast": { capName: "toast", capScope: "system", addonId: null, access: "view" },
   "turnProvider.getTurnServers": { capName: "turn-provider", capScope: "system", addonId: null, access: "view" },
+  "update.installUpdate": { capName: "update", capScope: "device", addonId: null, access: "create" },
   "userManagement.confirmTotp": { capName: "user-management", capScope: "system", addonId: null, access: "create" },
   "userManagement.createApiKey": { capName: "user-management", capScope: "system", addonId: null, access: "create" },
   "userManagement.createScopedToken": { capName: "user-management", capScope: "system", addonId: null, access: "create" },
@@ -5503,6 +6426,19 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "userPasskeys.finishRegistration": { capName: "user-passkeys", capScope: "system", addonId: null, access: "create" },
   "userPasskeys.listPasskeys": { capName: "user-passkeys", capScope: "system", addonId: null, access: "view" },
   "userPasskeys.removePasskey": { capName: "user-passkeys", capScope: "system", addonId: null, access: "delete" },
+  "vacuumControl.locate": { capName: "vacuum-control", capScope: "device", addonId: null, access: "create" },
+  "vacuumControl.pause": { capName: "vacuum-control", capScope: "device", addonId: null, access: "create" },
+  "vacuumControl.returnToBase": { capName: "vacuum-control", capScope: "device", addonId: null, access: "create" },
+  "vacuumControl.setFanSpeed": { capName: "vacuum-control", capScope: "device", addonId: null, access: "create" },
+  "vacuumControl.start": { capName: "vacuum-control", capScope: "device", addonId: null, access: "create" },
+  "vacuumControl.stop": { capName: "vacuum-control", capScope: "device", addonId: null, access: "create" },
+  "valve.close": { capName: "valve", capScope: "device", addonId: null, access: "create" },
+  "valve.open": { capName: "valve", capScope: "device", addonId: null, access: "create" },
+  "valve.setPosition": { capName: "valve", capScope: "device", addonId: null, access: "create" },
+  "valve.stop": { capName: "valve", capScope: "device", addonId: null, access: "create" },
+  "waterHeater.setAway": { capName: "water-heater", capScope: "device", addonId: null, access: "create" },
+  "waterHeater.setOperationMode": { capName: "water-heater", capScope: "device", addonId: null, access: "create" },
+  "waterHeater.setTargetTemp": { capName: "water-heater", capScope: "device", addonId: null, access: "create" },
   "webrtc.closeSession": { capName: "webrtc", capScope: "system", addonId: null, access: "create" },
   "webrtc.createSession": { capName: "webrtc", capScope: "system", addonId: null, access: "create" },
   "webrtc.handleAnswer": { capName: "webrtc", capScope: "system", addonId: null, access: "create" },
@@ -5515,6 +6451,7 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "webrtcSession.closeSession": { capName: "webrtc-session", capScope: "device", addonId: null, access: "create" },
   "webrtcSession.createSession": { capName: "webrtc-session", capScope: "device", addonId: null, access: "create" },
   "webrtcSession.getIceCandidates": { capName: "webrtc-session", capScope: "device", addonId: null, access: "view" },
+  "webrtcSession.getSessionState": { capName: "webrtc-session", capScope: "device", addonId: null, access: "view" },
   "webrtcSession.handleAnswer": { capName: "webrtc-session", capScope: "device", addonId: null, access: "create" },
   "webrtcSession.handleOffer": { capName: "webrtc-session", capScope: "device", addonId: null, access: "create" },
   "webrtcSession.hasAdaptiveBitrate": { capName: "webrtc-session", capScope: "device", addonId: null, access: "view" },
@@ -5531,6 +6468,7 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "zones.updateZone": { capName: "zones", capScope: "device", addonId: null, access: "create" }
 });
 const KNOWN_CAP_NAMES = [
+  "accessories",
   "addon-pages",
   "addon-pages-source",
   "addon-routes",
@@ -5540,17 +6478,28 @@ const KNOWN_CAP_NAMES = [
   "addons",
   "admin-ui",
   "advanced-notifier",
+  "alarm-panel",
   "alerts",
   "audio-analysis",
   "audio-analyzer",
   "audio-codec",
   "audio-metrics",
   "auth-provider",
+  "automation-control",
   "backup",
+  "battery",
   "brightness",
+  "broker",
+  "button",
   "camera-credentials",
   "camera-streams",
+  "climate-control",
+  "color",
+  "consumables",
+  "control",
+  "cover",
   "decoder",
+  "device-adoption",
   "device-discovery",
   "device-export",
   "device-manager",
@@ -5559,10 +6508,15 @@ const KNOWN_CAP_NAMES = [
   "device-state",
   "embedding-encoder",
   "events",
+  "fan-control",
+  "humidifier",
   "integrations",
   "intercom",
+  "lawn-mower-control",
   "local-network",
+  "lock-control",
   "log-destination",
+  "media-player",
   "mesh-network",
   "metrics-provider",
   "motion",
@@ -5575,6 +6529,7 @@ const KNOWN_CAP_NAMES = [
   "network-quality",
   "nodes",
   "notification-output",
+  "notifier",
   "oauth-integration",
   "osd",
   "pipeline-analytics",
@@ -5587,14 +6542,15 @@ const KNOWN_CAP_NAMES = [
   "ptz-autotrack",
   "reboot",
   "recording",
-  "recording-engine",
   "restreamer",
+  "script-runner",
   "settings-store",
   "smtp-provider",
   "snapshot",
   "snapshot-provider",
   "sso-bridge",
   "storage",
+  "storage-evictable",
   "storage-provider",
   "stream-broker",
   "stream-catalog",
@@ -5604,8 +6560,12 @@ const KNOWN_CAP_NAMES = [
   "system",
   "toast",
   "turn-provider",
+  "update",
   "user-management",
   "user-passkeys",
+  "vacuum-control",
+  "valve",
+  "water-heater",
   "webrtc",
   "webrtc-session",
   "zone-analytics",
@@ -5613,31 +6573,51 @@ const KNOWN_CAP_NAMES = [
   "zones"
 ];
 const DEVICE_CAP_NAMES = [
+  "accessories",
+  "alarm-panel",
   "audio-analysis",
   "audio-metrics",
+  "automation-control",
+  "battery",
   "brightness",
+  "button",
   "camera-credentials",
   "camera-streams",
+  "climate-control",
+  "color",
+  "consumables",
+  "control",
+  "cover",
   "device-discovery",
   "device-ops",
   "events",
+  "fan-control",
+  "humidifier",
   "intercom",
+  "lawn-mower-control",
+  "lock-control",
+  "media-player",
   "motion",
   "motion-detection",
   "motion-trigger",
   "motion-zones",
   "native-object-detection",
+  "notifier",
   "osd",
   "pipeline-analytics",
   "privacy-mask",
   "ptz",
   "ptz-autotrack",
   "reboot",
-  "recording",
+  "script-runner",
   "snapshot",
   "stream-catalog",
   "stream-params",
   "switch",
+  "update",
+  "vacuum-control",
+  "valve",
+  "water-heater",
   "webrtc-session",
   "zone-analytics",
   "zone-rules",
@@ -5658,7 +6638,9 @@ const SYSTEM_CAP_NAMES = [
   "audio-codec",
   "auth-provider",
   "backup",
+  "broker",
   "decoder",
+  "device-adoption",
   "device-export",
   "device-manager",
   "device-provider",
@@ -5679,13 +6661,14 @@ const SYSTEM_CAP_NAMES = [
   "pipeline-orchestrator",
   "pipeline-runner",
   "platform-probe",
-  "recording-engine",
+  "recording",
   "restreamer",
   "settings-store",
   "smtp-provider",
   "snapshot-provider",
   "sso-bridge",
   "storage",
+  "storage-evictable",
   "storage-provider",
   "stream-broker",
   "streaming-engine",
@@ -5733,6 +6716,7 @@ const SCOPE_PRESETS = [
   }
 ];
 const CAP_PROVIDER_KIND_MAP = Object.freeze({
+  "broker": "broker",
   "device-export": "device-export",
   "mesh-network": "mesh",
   "mqtt-broker": "broker",
@@ -5740,6 +6724,7 @@ const CAP_PROVIDER_KIND_MAP = Object.freeze({
   "smtp-provider": "email"
 });
 const PROVIDER_KIND_CAP_NAMES = [
+  "broker",
   "device-export",
   "mesh-network",
   "mqtt-broker",
@@ -5753,6 +6738,46 @@ function getCapsByProviderKind(kind) {
   }
   return out;
 }
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  const prevRow = Array.from({ length: n + 1 }, (_, k) => k);
+  const currRow = Array.from({ length: n + 1 }, () => 0);
+  for (let i = 1; i <= m; i++) {
+    currRow[0] = i;
+    let diagVal = prevRow[0] ?? 0;
+    for (let j = 1; j <= n; j++) {
+      const above = prevRow[j] ?? 0;
+      const left = currRow[j - 1] ?? 0;
+      const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+      currRow[j] = Math.min(above + 1, left + 1, diagVal + cost);
+      diagVal = above;
+    }
+    for (let j = 0; j <= n; j++) prevRow[j] = currRow[j] ?? 0;
+  }
+  return prevRow[n] ?? 0;
+}
+function locationSimilarity(a, b) {
+  const x = a.trim().toLowerCase();
+  const y = b.trim().toLowerCase();
+  if (x === y) return 1;
+  if (x.length === 0 || y.length === 0) return 0;
+  return 1 - levenshtein(x, y) / Math.max(x.length, y.length);
+}
+function bestLocationMatch(externalName, existing, threshold = 0.8) {
+  let best = null;
+  let bestScore = 0;
+  for (const name of existing) {
+    const score = locationSimilarity(externalName, name);
+    if (score >= threshold && score > bestScore) {
+      best = name;
+      bestScore = score;
+    }
+  }
+  return best;
+}
 const CREDENTIAL_PARAM_PATTERNS = [
   /^user$/i,
   /^usr$/i,
@@ -5906,6 +6931,24 @@ function cellsToRects(cells, gridWidth, gridHeight, maxRegions) {
     h: (block.rowEnd - block.rowStart + 1) / gridHeight
   }));
 }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+function sleepCancellable(ms, signal) {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, Math.max(0, ms));
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
 function bindAddonActions(api, addonId, catalog) {
   const out = {};
   for (const action of Object.keys(catalog)) {
@@ -5917,352 +6960,453 @@ function bindAddonActions(api, addonId, catalog) {
   return out;
 }
 export {
-  az as ACCESSORY_LABEL,
+  bh as ACCESSORY_LABEL,
   ALL_CAPABILITY_DEFINITIONS,
-  aA as APPLE_SA_TO_MACRO,
-  aB as AUDIO_BACKEND_CHOICES,
-  aC as AUDIO_MACRO_LABELS,
-  aD as AccessoriesStatusSchema,
-  aE as AccessoryKind,
-  aF as AddBrokerInputSchema,
-  aG as AddonAutoUpdateSchema,
-  aH as AddonListItemSchema,
-  aI as AddonPageDeclarationSchema,
-  aJ as AddonPageInfoSchema,
-  aK as AgentLoadSummarySchema,
-  aL as AlertSchema,
-  aM as AlertSeveritySchema,
-  aN as AlertSourceSchema,
-  aO as AlertStatusSchema,
-  aP as ApiKeyRecordSchema,
-  aQ as ApiKeySummarySchema,
-  aR as ArchiveEntrySchema,
-  aS as ArchiveManifestSchema,
-  aT as AudioAnalysisResultSchema,
-  aU as AudioAnalysisSettingsSchema,
-  aV as AudioChunkInputSchema,
-  aW as AudioClassSummarySchema,
-  aX as AudioClassificationLabelSchema,
-  aY as AudioClassificationResultSchema,
-  aZ as AudioCodecInfoSchema,
-  a_ as AudioDecodeSessionConfigSchema,
-  a$ as AudioEncodeSessionConfigSchema,
-  b0 as AudioEncodedChunkSchema,
-  b1 as AudioEventSchema,
-  b2 as AudioLevelSchema,
-  b3 as AudioMetricsHistoryPointSchema,
-  b4 as AudioMetricsHistorySchema,
-  b5 as AudioMetricsSnapshotSchema,
-  b6 as AudioPcmChunkSchema,
-  b7 as AuthResultSchema,
-  b8 as AutoUpdateSettingsSchema,
-  b9 as AvailableIntegrationTypeSchema,
+  bi as APPLE_SA_TO_MACRO,
+  bj as AUDIO_BACKEND_CHOICES,
+  bk as AUDIO_MACRO_LABELS,
+  bl as AccessoriesStatusSchema,
+  bm as AccessoryKind,
+  bn as AddBrokerInputSchema,
+  bo as AddonAutoUpdateSchema,
+  bp as AddonListItemSchema,
+  bq as AddonPageDeclarationSchema,
+  br as AddonPageInfoSchema,
+  bs as AdoptionAdoptInputSchema,
+  bt as AdoptionAdoptResultSchema,
+  bu as AdoptionFilterSchema,
+  bv as AdoptionGetCandidateInputSchema,
+  bw as AdoptionListCandidatesInputSchema,
+  bx as AdoptionListCandidatesOutputSchema,
+  by as AdoptionReleaseInputSchema,
+  bz as AdoptionStatusSchema,
+  bA as AgentLoadSummarySchema,
+  bB as AirQualitySensorStatusSchema,
+  bC as AlarmArmModeSchema,
+  bD as AlarmPanelStatusSchema,
+  bE as AlarmStateSchema,
+  bF as AlertSchema,
+  bG as AlertSeveritySchema,
+  bH as AlertSourceSchema,
+  bI as AlertStatusSchema,
+  bJ as AmbientLightSensorStatusSchema,
+  bK as ApiKeyRecordSchema,
+  bL as ApiKeySummarySchema,
+  bM as ArchiveEntrySchema,
+  bN as ArchiveManifestSchema,
+  bO as AudioAnalysisResultSchema,
+  bP as AudioAnalysisSettingsSchema,
+  bQ as AudioChunkInputSchema,
+  bR as AudioClassSummarySchema,
+  bS as AudioClassificationLabelSchema,
+  bT as AudioClassificationResultSchema,
+  bU as AudioCodecInfoSchema,
+  bV as AudioDecodeSessionConfigSchema,
+  bW as AudioEncodeSchema,
+  bX as AudioEncodeSessionConfigSchema,
+  bY as AudioEncodedChunkSchema,
+  bZ as AudioEventSchema,
+  b_ as AudioLevelSchema,
+  b$ as AudioMetricsHistoryPointSchema,
+  c0 as AudioMetricsHistorySchema,
+  c1 as AudioMetricsSnapshotSchema,
+  c2 as AudioPcmChunkSchema,
+  c3 as AuthResultSchema,
+  c4 as AutoUpdateSettingsSchema,
+  c5 as AutomationControlStatusSchema,
+  c6 as AvailableIntegrationTypeSchema,
   BACKEND_TO_FORMAT,
-  ba as BATTERY_DEVICE_PROFILE,
-  bb as BackupDestinationInfoSchema,
-  bc as BackupEntrySchema,
+  c7 as BATTERY_DEVICE_PROFILE,
+  c8 as BackupDestinationInfoSchema,
+  c9 as BackupEntrySchema,
   BaseAddon,
   BaseDevice,
   BaseDeviceProvider,
-  bd as BatteryStatusSchema,
-  be as BoundingBoxSchema,
-  bf as BrightnessStatusSchema,
-  bg as BrokerAudioClientSchema,
-  bh as BrokerClientsSchema,
-  bi as BrokerConnectionDetailsSchema,
-  bj as BrokerDecodedClientSchema,
-  bk as BrokerInfoSchema,
-  bl as BrokerRtspClientSchema,
-  bm as BrokerStatsSchema,
-  bn as BrokerStatusSchema,
-  bo as CAM_PROFILE_ORDER,
+  ca as BatteryStatusSchema,
+  cb as BinaryStatusSchema,
+  cc as BoundingBoxSchema,
+  cd as BrightnessStatusSchema,
+  ce as BrokerAddInputSchema,
+  cf as BrokerAudioClientSchema,
+  cg as BrokerClientsSchema,
+  ch as BrokerConnectionDetailsSchema,
+  ci as BrokerConsumerAttributionSchema,
+  cj as BrokerConsumerKindSchema,
+  ck as BrokerDecodedClientSchema,
+  cl as BrokerEncodedClientSchema,
+  cm as BrokerGetStateInputSchema,
+  cn as BrokerInfoSchema,
+  co as BrokerProviderInfoSchema,
+  cp as BrokerPublishInputSchema,
+  cq as BrokerRegistryStatusSchema,
+  cr as BrokerRtspClientSchema,
+  cs as BrokerStatsSchema,
+  ct as BrokerStatusEnum,
+  cu as BrokerStatusSchema,
+  cv as BrokerSubscribeInputSchema,
+  cw as BrokerSubscribeResultSchema,
+  cx as BrokerTestConnectionResultSchema,
+  cy as BrokerUnsubscribeInputSchema,
+  cz as CAM_PROFILE_ORDER,
   CAPABILITY_NAMES,
   CAPABILITY_ROUTER_KEYS,
   CAP_NAMES_WITH_STATUS,
   CAP_PROVIDER_KIND_MAP,
   COCO_80_LABELS,
   COCO_TO_MACRO,
-  bp as CamProfileSchema,
-  bq as CamStreamDescriptorSchema,
-  br as CamStreamKindSchema,
-  bs as CamStreamResolutionSchema,
-  bt as CameraCredentialsSchema,
-  bu as CameraCredentialsStatusSchema,
-  bv as CameraMetricsSchema,
-  bw as CameraMetricsWithDeviceIdSchema,
-  bx as CameraStreamSchema,
-  by as CapScopeSchema,
-  bz as CapabilityBindingsSchema,
-  bA as ChargingStatus,
-  bB as ClientNetworkStatsSchema,
-  bC as ClusterAddonNodeDeploymentSchema,
-  bD as ClusterAddonStatusEntrySchema,
-  bE as CollectionColumnSchema,
-  bF as CollectionIndexSchema,
-  bG as ConfigEntrySchema,
-  bH as ConfigSectionWithValuesSchema,
-  bI as ConfigTabDeclarationSchema,
-  bJ as CreateApiKeyInputSchema,
-  bK as CreateApiKeyResultSchema,
-  bL as CreateIntegrationInputSchema,
-  bM as CreateScopedTokenInputSchema,
-  bN as CreateScopedTokenResultSchema,
-  bO as CreateUserInputSchema,
-  bP as CustomActionInputSchema,
+  cA as CamProfileSchema,
+  cB as CamStreamDescriptorSchema,
+  cC as CamStreamKindSchema,
+  cD as CamStreamResolutionSchema,
+  cE as CameraCredentialsSchema,
+  cF as CameraCredentialsStatusSchema,
+  cG as CameraMetricsSchema,
+  cH as CameraMetricsWithDeviceIdSchema,
+  cI as CameraStreamSchema,
+  cJ as CandidateQueryFilterSchema,
+  cK as CapScopeSchema,
+  cL as CapabilityBindingsSchema,
+  cM as CarbonMonoxideStatusSchema,
+  cN as ChargingStatus,
+  cO as ClientNetworkStatsSchema,
+  cP as ClimateControlStatusSchema,
+  cQ as ClusterAddonNodeDeploymentSchema,
+  cR as ClusterAddonStatusEntrySchema,
+  cS as CollectionColumnSchema,
+  cT as CollectionIndexSchema,
+  cU as ColorStatusSchema,
+  cV as ConfigEntrySchema,
+  cW as ConfigSectionWithValuesSchema,
+  cX as ConfigTabDeclarationSchema,
+  cY as ConnectivityStatusSchema,
+  cZ as ConsumableItemSchema,
+  c_ as ConsumablesStatusSchema,
+  c$ as ContactStatusSchema,
+  d0 as ControlKindSchema,
+  d1 as ControlStatusSchema,
+  d2 as CoverStateSchema,
+  d3 as CoverStatusSchema,
+  d4 as CreateApiKeyInputSchema,
+  d5 as CreateApiKeyResultSchema,
+  d6 as CreateIntegrationInputSchema,
+  d7 as CreateScopedTokenInputSchema,
+  d8 as CreateScopedTokenResultSchema,
+  d9 as CreateUserInputSchema,
+  da as CustomActionInputSchema,
+  DATAPLANE_SECRET_HEADER,
   DEFAULT_ADDON_PLACEMENT,
-  bQ as DEFAULT_AUDIO_ANALYZER_CONFIG,
-  bR as DEFAULT_DECODER_HWACCEL_CONFIG,
+  db as DEFAULT_AUDIO_ANALYZER_CONFIG,
+  dc as DEFAULT_DECODER_HWACCEL_CONFIG,
   DEFAULT_FEATURES,
-  DEFAULT_LOCATION_SUBDIRS,
   DEFAULT_RETENTION,
   DEVICE_CAP_NAMES,
-  bS as DEVICE_PROFILES,
-  bT as DEVICE_SETTINGS_CONTRIBUTION_METHODS,
-  bU as DEVICE_STATUS_METHOD,
+  dd as DEVICE_PROFILES,
+  de as DEVICE_SETTINGS_CONTRIBUTION_METHODS,
+  df as DEVICE_STATUS_METHOD,
   DEVICE_TYPE_INFO,
-  bV as DecodedAudioChunkSchema,
-  bW as DecodedFrameSchema,
-  bX as DecoderAssignmentSchema,
-  bY as DecoderSessionConfigSchema,
-  bZ as DecoderStatsSchema,
-  b_ as DeleteIntegrationResultSchema,
-  b$ as DetectorOutputSchema,
+  dg as DecodedAudioChunkSchema,
+  dh as DecodedFrameSchema,
+  di as DecoderAssignmentSchema,
+  dj as DecoderSessionConfigSchema,
+  dk as DecoderStatsSchema,
+  dl as DeleteIntegrationResultSchema,
+  dm as DetectorOutputSchema,
   DeviceConfig,
-  c0 as DeviceDiscoveryStatusSchema,
-  c1 as DeviceExportExposeInputSchema,
-  c2 as DeviceExportStatusSchema,
-  c3 as DeviceExportUnexposeInputSchema,
-  c4 as DeviceFeature,
-  c5 as DeviceInfoSchema,
-  c6 as DeviceNetworkStatsSchema,
-  c7 as DeviceRole,
+  dn as DeviceDiscoveryStatusSchema,
+  dp as DeviceExportExposeInputSchema,
+  dq as DeviceExportStatusSchema,
+  dr as DeviceExportUnexposeInputSchema,
+  ds as DeviceFeature,
+  dt as DeviceInfoSchema,
+  du as DeviceNetworkStatsSchema,
+  dv as DeviceRole,
   DeviceRuntimeState,
-  c8 as DeviceStatusSchema,
-  c9 as DeviceType,
-  ca as DiscoveredChildDeviceSchema,
-  cb as DiscoveredChildStatusSchema,
-  cc as DiscoveredDeviceSchema,
+  dw as DeviceStatusSchema,
+  dx as DeviceType,
+  dy as DiscoveredChildDeviceSchema,
+  dz as DiscoveredChildStatusSchema,
+  dA as DiscoveredDeviceSchema,
   DisposerChain,
-  cd as DoorbellPressEventSchema,
-  ce as DoorbellStatusSchema,
+  dB as DoorbellPressEventSchema,
+  dC as DoorbellStatusSchema,
   ElementConfigStore,
-  cf as EmbeddingInfoSchema,
-  cg as EmbeddingResultSchema,
-  ch as EncodedPacketSchema,
-  ci as EnrichedWidgetMetadataSchema,
+  dD as EmbeddingInfoSchema,
+  dE as EmbeddingResultSchema,
+  dF as EncodeProfileSchema,
+  dG as EncodedPacketSchema,
+  dH as EnrichedWidgetMetadataSchema,
+  dI as EnumSensorDateTimeFormatSchema,
+  dJ as EnumSensorStatusSchema,
   EventCategory,
-  cj as EventItemSchema,
-  ck as EventKindSchema,
+  dK as EventEmitterStatusSchema,
+  dL as EventFireSchema,
+  dM as EventItemSchema,
+  dN as EventKindSchema,
   EventSourceType,
-  cl as ExportSetupFieldSchema,
-  cm as ExportSetupSchema,
-  cn as ExposedDeviceSchema,
-  co as ExposedResourceSchema,
-  cp as FeatureManifestSchema,
-  cq as FeatureProbeStatusSchema,
-  cr as FrameHandleFormatSchema,
-  cs as FrameHandleSchema,
-  ct as FrameInputSchema,
-  cu as GetStreamWithCodecInputSchema,
-  cv as GlobalMetricsSchema,
+  dO as ExportSetupFieldSchema,
+  dP as ExportSetupSchema,
+  dQ as ExposedDeviceSchema,
+  dR as ExposedResourceSchema,
+  dS as FanControlStatusSchema,
+  dT as FanDirectionSchema,
+  dU as FeatureManifestSchema,
+  dV as FeatureProbeStatusSchema,
+  dW as FloodStatusSchema,
+  dX as FrameHandleFormatSchema,
+  dY as FrameHandleSchema,
+  dZ as FrameInputSchema,
+  d_ as GasStatusSchema,
+  d$ as GetStreamWithCodecInputSchema,
+  e0 as GlobalMetricsSchema,
   HF_BASE_URL,
   HF_REPO,
-  cw as HWACCEL_OPTIONS,
-  cx as HealthStatusSchema,
-  cy as HistoryPointSchema,
-  cz as HistoryResolutionEnum,
-  cA as InstalledPackageSchema,
-  cB as IntegrationLiteSchema,
-  cC as IntegrationWithStateSchema,
-  cD as IntercomAbilitySchema,
-  cE as IntercomStatusSchema,
+  e1 as HWACCEL_OPTIONS,
+  e2 as HealthStatusSchema,
+  e3 as HistoryPointSchema,
+  e4 as HistoryResolutionEnum,
+  e5 as HumidifierStatusSchema,
+  e6 as HumiditySensorStatusSchema,
+  e7 as HvacModeSchema,
+  e8 as ImageStatusSchema,
+  e9 as InstalledPackageSchema,
+  ea as IntegrationLiteSchema,
+  eb as IntegrationWithStateSchema,
+  ec as IntercomAbilitySchema,
+  ed as IntercomStatusSchema,
   KNOWN_CAP_NAMES,
-  cF as LocationStatSchema,
-  cG as LogEntrySchema,
-  cH as LogLevelSchema,
-  cI as LogStreamEntrySchema,
+  ee as LawnMowerActivitySchema,
+  ef as LawnMowerControlStatusSchema,
+  eg as LocationStatSchema,
+  eh as LockControlStatusSchema,
+  ei as LockStateSchema,
+  ej as LogEntrySchema,
+  ek as LogLevelSchema,
+  el as LogStreamEntrySchema,
   MACRO_LABELS,
   METHOD_ACCESS_MAP,
-  cJ as MODEL_FORMATS,
-  cK as MaskGridDimsSchema,
-  cL as MaskGridShapeSchema,
-  cM as MaskLineShapeSchema,
-  cN as MaskPointSchema,
-  cO as MaskPolygonShapeSchema,
-  cP as MaskPolygonVerticesSchema,
-  cQ as MaskRectShapeSchema,
-  cR as MaskShapeKindSchema,
-  cS as MaskShapeSchema,
-  cT as MediaFileSchema,
-  cU as MeshPeerSchema,
-  cV as MeshStatusSchema,
-  cW as MethodAccessSchema,
-  cX as MotionAnalysisResultSchema,
-  cY as MotionEventSchema,
-  cZ as MotionOnMotionChangedDataSchema,
-  c_ as MotionRegionSchema,
-  c$ as MotionSourceEnum,
-  d0 as MotionSourcesSchema,
-  d1 as MotionStatusSchema,
-  d2 as MotionTriggerRuntimeStateSchema,
-  d3 as MotionTriggerStatusSchema,
-  d4 as MotionZoneOptionsSchema,
-  d5 as MotionZonePatchSchema,
-  d6 as MotionZoneRegionSchema,
-  d7 as MotionZoneStatusSchema,
-  d8 as MqttBrokerStatusSchema,
-  d9 as NativeDetectionSchema,
-  da as NativeObjectClassEnum,
-  db as NativeObjectDetectionRuntimeStateSchema,
-  dc as NativeObjectDetectionStatusSchema,
-  dd as NetworkAccessStatusSchema,
-  de as NetworkAddressSchema,
-  df as NetworkEndpointSchema,
-  dg as NotificationHistoryEntrySchema,
-  dh as NotificationRuleSchema,
-  di as NotificationSchema,
-  dj as OauthIntegrationDescriptorSchema,
-  dk as ObjectEventSchema,
-  dl as OrchestratorMetricsSchema,
-  dm as OsdOverlayKindEnum,
-  dn as OsdOverlayPatchSchema,
-  dp as OsdOverlaySchema,
-  dq as OsdPositionEnum,
-  dr as OsdStatusSchema,
-  ds as PIPELINE_FLOW_CAPABILITY_NAMES,
-  dt as PIPELINE_OWNER_CAPABILITY_NAMES,
+  em as MODEL_FORMATS,
+  en as MaskGridDimsSchema,
+  eo as MaskGridShapeSchema,
+  ep as MaskLineShapeSchema,
+  eq as MaskPointSchema,
+  er as MaskPolygonShapeSchema,
+  es as MaskPolygonVerticesSchema,
+  et as MaskRectShapeSchema,
+  eu as MaskShapeKindSchema,
+  ev as MaskShapeSchema,
+  ew as MediaFileSchema,
+  ex as MediaPlayerRepeatSchema,
+  ey as MediaPlayerStateSchema,
+  ez as MediaPlayerStatusSchema,
+  eA as MeshPeerSchema,
+  eB as MeshStatusSchema,
+  eC as MethodAccessSchema,
+  eD as MotionAnalysisResultSchema,
+  eE as MotionEventSchema,
+  eF as MotionOnMotionChangedDataSchema,
+  eG as MotionRegionSchema,
+  eH as MotionSourceEnum,
+  eI as MotionSourcesSchema,
+  eJ as MotionStatusSchema,
+  eK as MotionTriggerRuntimeStateSchema,
+  eL as MotionTriggerStatusSchema,
+  eM as MotionZoneOptionsSchema,
+  eN as MotionZonePatchSchema,
+  eO as MotionZoneRegionSchema,
+  eP as MotionZoneStatusSchema,
+  eQ as MqttBrokerStatusSchema,
+  eR as NativeDetectionSchema,
+  eS as NativeObjectClassEnum,
+  eT as NativeObjectDetectionRuntimeStateSchema,
+  eU as NativeObjectDetectionStatusSchema,
+  eV as NetworkAccessStatusSchema,
+  eW as NetworkAddressSchema,
+  eX as NetworkEndpointSchema,
+  eY as NotificationHistoryEntrySchema,
+  eZ as NotificationRuleSchema,
+  e_ as NotificationSchema,
+  e$ as NotifierStatusSchema,
+  f0 as NumericSensorStatusSchema,
+  f1 as OauthIntegrationDescriptorSchema,
+  f2 as ObjectEventSchema,
+  f3 as OrchestratorMetricsSchema,
+  f4 as OsdOverlayKindEnum,
+  f5 as OsdOverlayPatchSchema,
+  f6 as OsdOverlaySchema,
+  f7 as OsdPositionEnum,
+  f8 as OsdStatusSchema,
+  f9 as PIPELINE_FLOW_CAPABILITY_NAMES,
+  fa as PIPELINE_OWNER_CAPABILITY_NAMES,
   PROVIDER_KIND_CAP_NAMES,
   PYTHON_SCRIPT,
-  du as PackageUpdateSchema,
-  dv as PackageVersionInfoSchema,
-  dw as PasskeySummarySchema,
-  dx as PcmSampleFormatSchema,
-  dy as PerScopeBreakdownSchema,
-  dz as PipelineAssignmentSchema,
-  dA as PipelineDefaultStepSchema,
-  dB as PipelineEngineChoiceSchema,
-  dC as PipelineRunResultBridge,
-  dD as PipelineStepInputSchema,
-  dE as PlaceholderReasonSchema,
-  dF as PolygonPointSchema,
-  dG as PrivacyMaskOptionsSchema,
-  dH as PrivacyMaskPatchSchema,
-  dI as PrivacyMaskRegionSchema,
-  dJ as PrivacyMaskShapeSchema,
-  dK as PrivacyMaskStatusSchema,
-  dL as ProfileSlotSchema,
-  dM as ProfileSlotStatusSchema,
-  dN as ProviderStatusSchema,
-  dO as PtzAutotrackRuntimeStateSchema,
-  dP as PtzAutotrackSettingsSchema,
-  dQ as PtzAutotrackStatusSchema,
-  dR as PtzAutotrackTargetOptionSchema,
-  dS as PtzMoveCommandSchema,
-  dT as PtzPositionSchema,
-  dU as PtzPresetSchema,
-  dV as PtzStatusSchema,
-  dW as QueryFilterSchema,
+  fb as PackageUpdateSchema,
+  fc as PackageVersionInfoSchema,
+  fd as PasskeySummarySchema,
+  fe as PcmSampleFormatSchema,
+  ff as PerScopeBreakdownSchema,
+  fg as PickStreamPreferencesSchema,
+  fh as PickStreamRequirementsSchema,
+  fi as PickedCamStreamSchema,
+  fj as PipelineAssignmentSchema,
+  fk as PipelineDefaultStepSchema,
+  fl as PipelineEngineChoiceSchema,
+  fm as PipelineRunResultBridge,
+  fn as PipelineStepInputSchema,
+  fo as PlaceholderReasonSchema,
+  fp as PolygonPointSchema,
+  fq as PowerMeterStatusSchema,
+  fr as PresenceStatusSchema,
+  fs as PressureSensorStatusSchema,
+  ft as PrivacyMaskOptionsSchema,
+  fu as PrivacyMaskPatchSchema,
+  fv as PrivacyMaskRegionSchema,
+  fw as PrivacyMaskShapeSchema,
+  fx as PrivacyMaskStatusSchema,
+  fy as ProfileRtspEntrySchema,
+  fz as ProfileSlotSchema,
+  fA as ProfileSlotStatusSchema,
+  fB as ProviderStatusSchema,
+  fC as PtzAutotrackRuntimeStateSchema,
+  fD as PtzAutotrackSettingsSchema,
+  fE as PtzAutotrackStatusSchema,
+  fF as PtzAutotrackTargetOptionSchema,
+  fG as PtzMoveCommandSchema,
+  fH as PtzPositionSchema,
+  fI as PtzPresetSchema,
+  fJ as PtzStatusSchema,
+  fK as QueryFilterSchema,
   RECOGNITION_TYPES,
   RUNTIME_DEFAULTS,
   RUNTIME_TO_FORMAT,
+  fL as RawStateResultSchema,
   ReadinessRegistry,
   ReadinessTimeoutError,
-  dX as RegisteredStreamSchema,
-  dY as ReportMotionInputSchema,
+  fM as RecordingAvailabilitySchema,
+  fN as RecordingConfigSchema,
+  fO as RecordingDeviceUsageSchema,
+  fP as RecordingLocationUsageSchema,
+  fQ as RecordingManifestSchema,
+  fR as RecordingModeSchema,
+  fS as RecordingRangeSchema,
+  fT as RecordingRetentionSchema,
+  fU as RecordingRuleSchema,
+  fV as RecordingScheduleSchema,
+  fW as RecordingStatusSchema,
+  fX as RecordingStorageUsageSchema,
+  fY as RecordingWeekdaySchema,
+  fZ as RegisteredStreamSchema,
+  f_ as ReportMotionInputSchema,
   RingBuffer,
-  dZ as RtpSourceSchema,
-  d_ as RtspRestreamEntrySchema,
-  d$ as RunnerCameraConfigSchema,
-  e0 as RunnerCameraDeviceUIFields,
-  e1 as RunnerLocalLoadSchema,
-  e2 as RunnerLocalMetricsSchema,
+  f$ as RtpSourceSchema,
+  g0 as RtspRestreamEntrySchema,
+  g1 as RunnerCameraConfigSchema,
+  g2 as RunnerCameraDeviceUIFields,
+  g3 as RunnerLocalLoadSchema,
+  g4 as RunnerLocalMetricsSchema,
   SCOPE_PRESETS,
-  e3 as STORAGE_LOCATION_CARDINALITY,
-  STORAGE_LOCATION_TYPES,
+  SOURCE_INFO_METADATA_KEY,
   STREAM_PROFILE_META,
   STREAM_QUALITY_LABELS,
   SUB_DETECTION_TYPES,
   SYSTEM_CAP_NAMES,
-  e4 as ScopedTokenSchema,
-  e5 as ScopedTokenSummarySchema,
-  e6 as SearchResultSchema,
-  e7 as SegmentSchema,
-  e8 as SendEmailInputSchema,
-  e9 as SendEmailResultSchema,
-  ea as SettingsPatchSchema,
-  eb as SettingsRecordSchema,
-  ec as SettingsSchemaWithValuesSchema,
-  ed as SettingsUpdateResultSchema,
-  ee as ShmRingStatsSchema,
-  ef as SmtpStatusSchema,
-  eg as SnapshotImageSchema,
-  eh as SpatialDetectionSchema,
-  ei as SsoBridgeClaimsSchema,
-  ej as StartEmbeddedInputSchema,
-  ek as StorageAbortUploadInputSchema,
-  el as StorageBeginDownloadInputSchema,
-  em as StorageBeginDownloadResultSchema,
-  en as StorageBeginUploadInputSchema,
-  eo as StorageBeginUploadResultSchema,
-  ep as StorageEndDownloadInputSchema,
-  eq as StorageFinalizeUploadInputSchema,
-  er as StorageLocationRefSchema,
-  es as StorageLocationSchema,
-  et as StorageLocationTypeSchema,
-  eu as StorageProviderInfoSchema,
-  ev as StorageReadChunkInputSchema,
-  ew as StorageTestLocationResultSchema,
-  ex as StorageWriteChunkInputSchema,
-  ey as StreamFormatSchema,
-  ez as StreamInfoSchema,
-  eA as StreamNetworkStatsSchema,
-  eB as StreamParamsOptionsSchema,
-  eC as StreamParamsStatusSchema,
-  eD as StreamProfileConfigSchema,
-  eE as StreamProfileOptionsSchema,
-  eF as StreamProfilePatchSchema,
-  eG as StreamProfileSchema,
-  eH as StreamSourceEntrySchema,
-  eI as StreamSourceSchema,
-  eJ as SubscribeAudioChunksInputSchema,
-  eK as SubscribeAudioChunksResultSchema,
-  eL as SubscribeFramesInputSchema,
-  eM as SubscribeFramesResultSchema,
-  eN as SwitchStatusSchema,
-  eO as SystemMetricsSchema,
+  g5 as ScopedTokenSchema,
+  g6 as ScopedTokenSummarySchema,
+  g7 as ScriptRunnerStatusSchema,
+  g8 as SearchResultSchema,
+  g9 as SendEmailInputSchema,
+  ga as SendEmailResultSchema,
+  gb as SettingsPatchSchema,
+  gc as SettingsRecordSchema,
+  gd as SettingsSchemaWithValuesSchema,
+  ge as SettingsUpdateResultSchema,
+  gf as ShmRingStatsSchema,
+  gg as SmokeStatusSchema,
+  gh as SmtpStatusSchema,
+  gi as SnapshotImageSchema,
+  gj as SourceInfoSchema,
+  gk as SpatialDetectionSchema,
+  gl as SsoBridgeClaimsSchema,
+  gm as StartEmbeddedInputSchema,
+  gn as StorageAbortUploadInputSchema,
+  go as StorageBeginDownloadInputSchema,
+  gp as StorageBeginDownloadResultSchema,
+  gq as StorageBeginUploadInputSchema,
+  gr as StorageBeginUploadResultSchema,
+  gs as StorageEndDownloadInputSchema,
+  gt as StorageFinalizeUploadInputSchema,
+  gu as StorageLocationDeclarationSchema,
+  gv as StorageLocationRefSchema,
+  gw as StorageLocationSchema,
+  gx as StorageLocationTypeSchema,
+  gy as StorageProviderInfoSchema,
+  gz as StorageReadChunkInputSchema,
+  gA as StorageTestLocationResultSchema,
+  gB as StorageWriteChunkInputSchema,
+  gC as StreamCodecSchema,
+  gD as StreamFormatSchema,
+  gE as StreamInfoSchema,
+  gF as StreamNetworkStatsSchema,
+  gG as StreamParamsOptionsSchema,
+  gH as StreamParamsStatusSchema,
+  gI as StreamProfileConfigSchema,
+  gJ as StreamProfileOptionsSchema,
+  gK as StreamProfilePatchSchema,
+  gL as StreamProfileSchema,
+  gM as StreamSourceEntrySchema,
+  gN as StreamSourceSchema,
+  gO as SubscribeAudioChunksInputSchema,
+  gP as SubscribeAudioChunksResultSchema,
+  gQ as SubscribeFramesInputSchema,
+  gR as SubscribeFramesResultSchema,
+  gS as SwitchStatusSchema,
+  gT as SystemMetricsSchema,
   SystemMirror,
-  eP as TestConnectionResultSchema,
-  eQ as ToastSchema,
-  eR as TokenScopeSchema,
-  eS as TopologyNodeSchema,
-  eT as TopologyProcessSchema,
-  eU as TopologyServiceSchema,
-  eV as TrackSchema,
-  eW as TrackStateSchema,
-  eX as TrackedDetectionSchema,
-  eY as TurnServerSchema,
-  eZ as UpdateIntegrationInputSchema,
-  e_ as UpdateUserInputSchema,
-  e$ as UserRecordSchema,
-  f0 as UserSummarySchema,
-  f1 as WELL_KNOWN_TABS,
-  f2 as WELL_KNOWN_TAB_MAP,
-  f3 as WebrtcStreamChoiceSchema,
-  f4 as WebrtcStreamTargetSchema,
-  f5 as WidgetHostEnum,
-  f6 as WidgetMetadataSchema,
-  f7 as WidgetRemoteSchema,
-  f8 as WidgetSizeEnum,
-  f9 as YAMNET_TO_MACRO,
-  fa as ZoneKindEnum,
-  fb as ZoneRuleModeEnum,
-  fc as ZoneRuleSchema,
-  fd as ZoneRuleStageEnum,
-  fe as ZoneRulesArraySchema,
-  ff as ZoneSchema,
-  fg as ZoneScopeBreakdownSchema,
+  TIMEZONES,
+  gU as TamperStatusSchema,
+  gV as TankStatusSchema,
+  gW as TemperatureSensorStatusSchema,
+  gX as TestConnectionResultSchema,
+  gY as ToastSchema,
+  gZ as TokenScopeSchema,
+  g_ as TopologyNodeSchema,
+  g$ as TopologyProcessSchema,
+  h0 as TopologyServiceSchema,
+  h1 as TrackSchema,
+  h2 as TrackStateSchema,
+  h3 as TrackedDetectionSchema,
+  h4 as TurnServerSchema,
+  h5 as UnifiedBrokerInfoSchema,
+  h6 as UpdateIntegrationInputSchema,
+  h7 as UpdateStatusSchema,
+  h8 as UpdateUserInputSchema,
+  h9 as UserRecordSchema,
+  ha as UserSummarySchema,
+  hb as VacuumControlStatusSchema,
+  hc as VacuumStateSchema,
+  hd as ValveStateSchema,
+  he as ValveStatusSchema,
+  hf as VibrationStatusSchema,
+  hg as VideoEncodeSchema,
+  hh as WELL_KNOWN_TABS,
+  hi as WELL_KNOWN_TAB_MAP,
+  hj as WaterHeaterStatusSchema,
+  hk as WeatherStatusSchema,
+  hl as WebrtcStreamChoiceSchema,
+  hm as WebrtcStreamTargetSchema,
+  hn as WidgetHostEnum,
+  ho as WidgetMetadataSchema,
+  hp as WidgetRemoteSchema,
+  hq as WidgetSizeEnum,
+  hr as YAMNET_TO_MACRO,
+  hs as ZoneKindEnum,
+  ht as ZoneRuleModeEnum,
+  hu as ZoneRuleSchema,
+  hv as ZoneRuleStageEnum,
+  hw as ZoneRulesArraySchema,
+  hx as ZoneSchema,
+  hy as ZoneScopeBreakdownSchema,
   accessoriesCapability,
-  fh as accessoryStableId,
+  hz as accessoryStableId,
   addonPagesCapability,
   addonPagesSourceCapability,
   addonRoutesCapability,
@@ -6272,7 +7416,11 @@ export {
   addonsCapability,
   adminUiCapability,
   advancedNotifierCapability,
+  airQualitySensorCapability,
+  alarmPanelCapability,
   alertsCapability,
+  ambientLightSensorCapability,
+  applyTransform,
   asBoolean,
   asJsonArray,
   asJsonObject,
@@ -6284,20 +7432,34 @@ export {
   audioMetricsCapability,
   authProviderCapability,
   autoAssignProfiles,
+  automationControlCapability,
   backupCapability,
   batteryCapability,
+  bestLocationMatch,
+  binaryCapability,
   bindAddonActions,
   brightnessCapability,
+  brokerCapability,
   buildAddonRouteProvider,
   buildStreamParamsConfigSchema,
+  buttonCapability,
   cameraCredentialsCapability,
   cameraPipelineConfigCapability,
   cameraStreamsCapability,
+  carbonMonoxideCapability,
   cellsToRects,
   classifyStream,
   classifyStreams,
+  climateControlCapability,
+  colorCapability,
+  connectivityCapability,
+  consumablesCapability,
+  contactCapability,
+  controlCapability,
   cosineSimilarity,
+  coverCapability,
   createDeviceProxy,
+  createDurableState,
   createEvent,
   createLazyTrpcSource,
   createMirrorSource,
@@ -6308,10 +7470,12 @@ export {
   decoderCapability,
   defineCustomActions,
   detectionPipelineCapability,
+  deviceAdoptionCapability,
+  deviceCustomAction,
   deviceDiscoveryCapability,
   deviceExportCapability,
   deviceManagerCapability,
-  fi as deviceMatchesProfile,
+  hA as deviceMatchesProfile,
   deviceOpsCapability,
   deviceProviderCapability,
   deviceStateCapability,
@@ -6320,30 +7484,50 @@ export {
   embeddingEncoderCapability,
   emitDownForOwnedCaps,
   emitReadiness,
+  hB as encodeProfileFromStreamShape,
+  enumSensorCapability,
+  enumerateSchemaFields,
   errMsg,
   evaluateZoneRules,
-  fj as event,
+  hC as event,
+  eventEmitterCapability,
   eventsCapability,
-  fk as expandCapMethods,
+  hD as expandCapMethods,
+  extractSourceInfoFromMetadata,
+  fanControlCapability,
   featureProbeCapability,
+  findTimezone,
+  floodCapability,
   formatForBackend,
   formatForRuntime,
-  fl as getAudioMacroClassIds,
+  gasCapability,
+  hE as getAudioMacroClassIds,
+  getByPath,
   getCapsByProviderKind,
   hfModelUrl,
+  humidifierCapability,
+  humiditySensorCapability,
   hydrateSchema,
+  imageCapability,
   integrationsCapability,
   intercomCapability,
   isAgentOnlyPlacement,
   isDeployableToAgent,
-  fm as isDeviceConfigCap,
+  hF as isDeviceConfigCap,
   isEvent,
+  lawnMowerControlCapability,
   localNetworkCapability,
+  locationSimilarity,
+  lockControlCapability,
   logDestinationCapability,
-  fn as mapAudioLabelToMacro,
+  hG as makeProfileBrokerId,
+  hH as makeSourceBrokerId,
+  hI as mapAudioLabelToMacro,
   maskUrlCredentials,
+  mediaPlayerCapability,
+  mergeSourceInfo,
   meshNetworkCapability,
-  fo as method,
+  hJ as method,
   metricsProviderCapability,
   motionCapability,
   motionDetectionCapability,
@@ -6355,19 +7539,27 @@ export {
   networkQualityCapability,
   nodesCapability,
   normalizeAddonInitResult,
+  hK as normalizeUnit,
   notificationOutputCapability,
+  notifierCapability,
+  numericSensorCapability,
   oauthIntegrationCapability,
   osdCapability,
   parseCameraStreamConfig,
   parseJsonArray,
   parseJsonObject,
   parseJsonUnknown,
+  hL as parseProfileBrokerId,
   parseStreamParamsFormPatch,
+  pickPreferredRtspEntry,
   pipelineAnalyticsCapability,
   pipelineExecutorCapability,
   pipelineOrchestratorCapability,
   pipelineRunnerCapability,
   platformProbeCapability,
+  powerMeterCapability,
+  presenceCapability,
+  pressureSensorCapability,
   privacyMaskCapability,
   ptzAutotrackCapability,
   ptzCapability,
@@ -6375,7 +7567,6 @@ export {
   readinessKey,
   rebootCapability,
   recordingCapability,
-  recordingEngineCapability,
   rectsToCells,
   requiresPython,
   resolveAddonExecution,
@@ -6383,18 +7574,25 @@ export {
   resolveAddonPlacement,
   resolveAddonRuntime,
   resolveDetectionRuntime,
-  fp as resolveDeviceProfile,
+  hM as resolveDeviceProfile,
   resolveModelFormat,
   resolveRunnerId,
   restreamerCapability,
   runInferenceStep,
   scopeKey,
+  scriptRunnerCapability,
+  hN as selectAssignedProfileSlots,
+  setByPath,
   settingsStoreCapability,
+  sleep,
+  sleepCancellable,
+  smokeCapability,
   smtpProviderCapability,
   snapshotCapability,
   snapshotProviderCapability,
   ssoBridgeCapability,
   storageCapability,
+  storageEvictableCapability,
   storageProviderCapability,
   streamBrokerCapability,
   streamCatalogCapability,
@@ -6403,21 +7601,30 @@ export {
   streamQualityLabel,
   streamingEngineCapability,
   switchCapability,
+  synthesizeSourceInfo,
   systemCapability,
+  tamperCapability,
+  temperatureSensorCapability,
   toDeviceSummary,
   toStreamSourceEntry,
   toastCapability,
   turnProviderCapability,
+  updateCapability,
   userManagementCapability,
   userPasskeysCapability,
+  vacuumControlCapability,
+  valveCapability,
+  vibrationCapability,
+  waterHeaterCapability,
+  weatherCapability,
   webrtcCapability,
-  fq as webrtcClientHintsSchema,
+  hO as webrtcClientHintsSchema,
   webrtcSessionCapability,
-  fr as wiringAddonHealthSchema,
-  fs as wiringHealthSnapshotSchema,
-  ft as wiringNodeHealthSchema,
-  fu as wiringProbeKindSchema,
-  fv as wiringProbeResultSchema,
+  hP as wiringAddonHealthSchema,
+  hQ as wiringHealthSnapshotSchema,
+  hR as wiringNodeHealthSchema,
+  hS as wiringProbeKindSchema,
+  hT as wiringProbeResultSchema,
   zodEntriesToConfigUI,
   zoneAnalyticsCapability,
   zoneRulesCapability,