@camstack/types 0.1.40 → 0.1.42

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const index = require("./index-DnpdVFKv.js");
+const index = require("./index-CGMPfVaT.js");
 const zod = require("zod");
 class DisposerChain {
   disposers = [];
@@ -120,10 +120,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";
@@ -157,7 +162,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";
@@ -243,6 +250,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 (fn) => {
+    await set(fn(await get()));
+  };
+  return { get, set, update };
+}
 class BaseAddon {
   _ctx = null;
   _config;
@@ -486,12 +514,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 {
     }
@@ -564,6 +598,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
@@ -689,6 +761,97 @@ 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);
+}
+const ALL_DAYS = [0, 1, 2, 3, 4, 5, 6];
+const ALL_DAY_START = "00:00";
+const ALL_DAY_END = "23:59";
+function bandFromSchedule(schedule, mode, config) {
+  const days = schedule.kind === "timeOfDay" && schedule.days ? schedule.days : [...ALL_DAYS];
+  const start = schedule.kind === "timeOfDay" ? schedule.start : ALL_DAY_START;
+  const end = schedule.kind === "timeOfDay" ? schedule.end : ALL_DAY_END;
+  if (mode === "continuous") {
+    return { days, start, end, mode };
+  }
+  const eventsBand = { days, start, end, mode };
+  return {
+    ...eventsBand,
+    ...config.triggers ? { triggers: config.triggers } : {},
+    ...config.preBufferSec !== void 0 ? { preBufferSec: config.preBufferSec } : {},
+    ...config.postBufferSec !== void 0 ? { postBufferSec: config.postBufferSec } : {}
+  };
+}
+function migrateConfigToBands(config) {
+  if (config.bands) {
+    return config.bands;
+  }
+  if (!config.enabled || config.mode === "off") {
+    return [];
+  }
+  const schedules = config.schedules ?? (config.schedule ? [config.schedule] : [{ kind: "always" }]);
+  const bandMode = config.mode === "continuous" ? "continuous" : "events";
+  return schedules.map((schedule) => bandFromSchedule(schedule, bandMode, config));
+}
 class ReadinessTimeoutError extends Error {
   capName;
   scope;
@@ -1084,34 +1247,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",
@@ -1159,12 +1295,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
@@ -1225,6 +1361,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,
@@ -1266,9 +1447,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",
@@ -1936,22 +2114,61 @@ function createRuntimeStateBridge(params) {
   return { ensureFresh, getStatus };
 }
 const DEVICE_LOCAL_STATE_CAPS = {
+  airQualitySensor: index.airQualitySensorCapability,
+  alarmPanel: index.alarmPanelCapability,
+  ambientLightSensor: index.ambientLightSensorCapability,
   audioMetrics: index.audioMetricsCapability,
+  automationControl: index.automationControlCapability,
   battery: index.batteryCapability,
+  binary: index.binaryCapability,
   brightness: index.brightnessCapability,
   cameraStreams: index.cameraStreamsCapability,
+  carbonMonoxide: index.carbonMonoxideCapability,
+  climateControl: index.climateControlCapability,
+  color: index.colorCapability,
+  connectivity: index.connectivityCapability,
+  consumables: index.consumablesCapability,
+  contact: index.contactCapability,
+  control: index.controlCapability,
+  cover: index.coverCapability,
   deviceDiscovery: index.deviceDiscoveryCapability,
   deviceStatus: index.deviceStatusCapability,
   doorbell: index.doorbellCapability,
+  enumSensor: index.enumSensorCapability,
+  eventEmitter: index.eventEmitterCapability,
+  fanControl: index.fanControlCapability,
   featureProbe: index.featureProbeCapability,
+  flood: index.floodCapability,
+  gas: index.gasCapability,
+  humidifier: index.humidifierCapability,
+  humiditySensor: index.humiditySensorCapability,
+  image: index.imageCapability,
+  lawnMowerControl: index.lawnMowerControlCapability,
+  lockControl: index.lockControlCapability,
+  mediaPlayer: index.mediaPlayerCapability,
   motion: index.motionCapability,
   motionTrigger: index.motionTriggerCapability,
   motionZones: index.motionZonesCapability,
   nativeObjectDetection: index.nativeObjectDetectionCapability,
+  notifier: index.notifierCapability,
+  numericSensor: index.numericSensorCapability,
+  powerMeter: index.powerMeterCapability,
+  presence: index.presenceCapability,
+  pressureSensor: index.pressureSensorCapability,
   privacyMask: index.privacyMaskCapability,
   ptzAutotrack: index.ptzAutotrackCapability,
+  scriptRunner: index.scriptRunnerCapability,
+  smoke: index.smokeCapability,
   streamParams: index.streamParamsCapability,
   switch: index.switchCapability,
+  tamper: index.tamperCapability,
+  temperatureSensor: index.temperatureSensorCapability,
+  update: index.updateCapability,
+  vacuumControl: index.vacuumControlCapability,
+  valve: index.valveCapability,
+  vibration: index.vibrationCapability,
+  waterHeater: index.waterHeaterCapability,
+  weather: index.weatherCapability,
   zoneAnalytics: index.zoneAnalyticsCapability,
   zoneRules: index.zoneRulesCapability,
   zones: index.zonesCapability
@@ -2055,6 +2272,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;
@@ -2095,7 +2322,7 @@ class BaseDevice {
     this.runtimeState = DeviceRuntimeState.fromInitial(initial, writer);
     ctx.bindRuntimeState?.(this.runtimeState);
     ctx.registerNativeCap?.(index.deviceStatusCapability, {});
-    const seed = { online: false, lastChangedAt: Date.now() };
+    const seed = { online: true, lastChangedAt: Date.now() };
     this.runtimeState.setCapState("device-status", seed);
     ctx.registerNativeCap?.(index.featureProbeCapability, {});
     const probeSeed = {
@@ -2108,6 +2335,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() {
   }
   /**
@@ -2124,6 +2366,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 = index.extractSourceInfoFromMetadata(this.ctx.deviceMeta.metadata);
+    const resolved = fromMeta ?? index.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 = index.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: { [index.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
@@ -2374,7 +2681,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 {
@@ -2683,6 +2996,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 zod.z.ZodNullable || s instanceof zod.z.ZodOptional || s instanceof zod.z.ZodDefault) {
+    s = s.unwrap();
+  }
+  return s;
+}
+function leafKind(schema) {
+  const s = unwrap(schema);
+  if (s instanceof zod.z.ZodEnum) return { kind: "enum", enumValues: s.options };
+  if (s instanceof zod.z.ZodNumber) return { kind: "number" };
+  if (s instanceof zod.z.ZodString) return { kind: "string" };
+  if (s instanceof zod.z.ZodBoolean) return { kind: "boolean" };
+  return null;
+}
+function enumerateSchemaFields(schema, prefix = "") {
+  const root = unwrap(schema);
+  if (!(root instanceof zod.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 zod.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();
@@ -2846,8 +3233,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),
@@ -2858,13 +3258,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)
@@ -2872,7 +3285,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),
@@ -2890,8 +3343,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)
@@ -2899,23 +3354,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)
@@ -2941,6 +3454,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)
@@ -2953,12 +3474,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),
@@ -2987,10 +3519,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),
@@ -3013,6 +3548,48 @@ 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 videoclipsInterface = {
+    listClips: (input) => dispatch("videoclips", "videoclips", "listClips", "query", input),
+    getClipPlayback: (input) => dispatch("videoclips", "videoclips", "getClipPlayback", "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),
@@ -3021,7 +3598,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),
@@ -3048,6 +3626,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),
@@ -3059,6 +3640,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),
@@ -3078,6 +3668,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),
@@ -3122,8 +3713,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),
@@ -3143,63 +3743,143 @@ 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,
+    videoclips: videoclipsInterface,
+    waterHeater: waterHeaterInterface,
+    weather: weatherInterface,
     webrtcSession: webrtcSessionInterface,
     zoneAnalytics: zoneAnalyticsInterface,
     zoneRules: zoneRulesInterface,
     zones: zonesInterface,
     addonSettings: addonSettingsInterface,
     cameraPipelineConfig: cameraPipelineConfigInterface,
+    deviceAdoption: deviceAdoptionInterface,
     deviceExport: deviceExportInterface,
     deviceManager: deviceManagerInterface,
     deviceState: deviceStateInterface,
@@ -3207,7 +3887,7 @@ function createDeviceProxy(api, binding, opts) {
     pipelineExecutor: pipelineExecutorInterface,
     pipelineOrchestrator: pipelineOrchestratorInterface,
     pipelineRunner: pipelineRunnerInterface,
-    recordingEngine: recordingEngineInterface,
+    recording: recordingInterface,
     snapshotProvider: snapshotProviderInterface,
     streamBroker: streamBrokerInterface
   };
@@ -3358,6 +4038,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),
@@ -3374,6 +4072,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),
@@ -3392,13 +4099,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),
@@ -3558,32 +4270,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),
@@ -3593,6 +4281,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)
   };
@@ -3613,6 +4302,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),
@@ -3623,6 +4313,7 @@ function createSystemProxy(api) {
     listAllCameraStreams: (input) => dispatch("streamBroker", "listAllCameraStreams", "query", input),
     listAllProfileSlots: (input) => dispatch("streamBroker", "listAllProfileSlots", "query", input),
     getBrokerStats: (input) => dispatch("streamBroker", "getBrokerStats", "query", input),
+    probeStream: (input) => dispatch("streamBroker", "probeStream", "mutation", input),
     listClients: (input) => dispatch("streamBroker", "listClients", "query", input),
     killClient: (input) => dispatch("streamBroker", "killClient", "mutation", input),
     getStreamUrl: (input) => dispatch("streamBroker", "getStreamUrl", "query", input),
@@ -3695,7 +4386,9 @@ function createSystemProxy(api) {
     audioAnalyzer: audioAnalyzerInterface,
     audioCodec: audioCodecInterface,
     backup: backupInterface,
+    broker: brokerInterface,
     decoder: decoderInterface,
+    deviceAdoption: deviceAdoptionInterface,
     deviceExport: deviceExportInterface,
     deviceManager: deviceManagerInterface,
     deviceProvider: deviceProviderInterface,
@@ -3712,8 +4405,7 @@ function createSystemProxy(api) {
     pipelineExecutor: pipelineExecutorInterface,
     pipelineOrchestrator: pipelineOrchestratorInterface,
     pipelineRunner: pipelineRunnerInterface,
-    platformProbe: platformProbeInterface,
-    recordingEngine: recordingEngineInterface,
+    recording: recordingInterface,
     settingsStore: settingsStoreInterface,
     storage: storageInterface,
     streamBroker: streamBrokerInterface,
@@ -4475,6 +5167,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" },
@@ -4685,20 +5386,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",
@@ -4708,12 +5425,24 @@ 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",
+  filesystemBrowse: "filesystem-browse",
+  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",
@@ -4726,6 +5455,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",
@@ -4733,19 +5464,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",
@@ -4753,10 +5489,19 @@ 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",
+  videoclips: "videoclips",
+  waterHeater: "water-heater",
+  weather: "weather",
   webrtc: "webrtc",
   webrtcSession: "webrtc-session",
   zoneAnalytics: "zone-analytics",
@@ -4774,20 +5519,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" },
@@ -4797,12 +5558,24 @@ 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: "filesystemBrowse", name: "filesystem-browse" },
+  { 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" },
@@ -4815,6 +5588,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" },
@@ -4822,19 +5597,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" },
@@ -4842,10 +5622,19 @@ 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: "videoclips", name: "videoclips" },
+  { key: "waterHeater", name: "water-heater" },
+  { key: "weather", name: "weather" },
   { key: "webrtc", name: "webrtc" },
   { key: "webrtcSession", name: "webrtc-session" },
   { key: "zoneAnalytics", name: "zone-analytics" },
@@ -4863,20 +5652,36 @@ const ALL_CAPABILITY_DEFINITIONS = [
   index.addonsCapability,
   index.adminUiCapability,
   index.advancedNotifierCapability,
+  index.airQualitySensorCapability,
+  index.alarmPanelCapability,
   index.alertsCapability,
+  index.ambientLightSensorCapability,
   index.audioAnalysisCapability,
   index.audioAnalyzerCapability,
   index.audioCodecCapability,
   index.audioMetricsCapability,
   index.authProviderCapability,
+  index.automationControlCapability,
   index.backupCapability,
   index.batteryCapability,
+  index.binaryCapability,
   index.brightnessCapability,
+  index.brokerCapability,
+  index.buttonCapability,
   index.cameraCredentialsCapability,
   index.cameraPipelineConfigCapability,
   index.cameraStreamsCapability,
+  index.carbonMonoxideCapability,
+  index.climateControlCapability,
+  index.colorCapability,
+  index.connectivityCapability,
+  index.consumablesCapability,
+  index.contactCapability,
+  index.controlCapability,
+  index.coverCapability,
   index.decoderCapability,
   index.detectionPipelineCapability,
+  index.deviceAdoptionCapability,
   index.deviceDiscoveryCapability,
   index.deviceExportCapability,
   index.deviceManagerCapability,
@@ -4886,12 +5691,24 @@ const ALL_CAPABILITY_DEFINITIONS = [
   index.deviceStatusCapability,
   index.doorbellCapability,
   index.embeddingEncoderCapability,
+  index.enumSensorCapability,
+  index.eventEmitterCapability,
   index.eventsCapability,
+  index.fanControlCapability,
   index.featureProbeCapability,
+  index.filesystemBrowseCapability,
+  index.floodCapability,
+  index.gasCapability,
+  index.humidifierCapability,
+  index.humiditySensorCapability,
+  index.imageCapability,
   index.integrationsCapability,
   index.intercomCapability,
+  index.lawnMowerControlCapability,
   index.localNetworkCapability,
+  index.lockControlCapability,
   index.logDestinationCapability,
+  index.mediaPlayerCapability,
   index.meshNetworkCapability,
   index.metricsProviderCapability,
   index.motionCapability,
@@ -4904,6 +5721,8 @@ const ALL_CAPABILITY_DEFINITIONS = [
   index.networkQualityCapability,
   index.nodesCapability,
   index.notificationOutputCapability,
+  index.notifierCapability,
+  index.numericSensorCapability,
   index.oauthIntegrationCapability,
   index.osdCapability,
   index.pipelineAnalyticsCapability,
@@ -4911,19 +5730,24 @@ const ALL_CAPABILITY_DEFINITIONS = [
   index.pipelineOrchestratorCapability,
   index.pipelineRunnerCapability,
   index.platformProbeCapability,
+  index.powerMeterCapability,
+  index.presenceCapability,
+  index.pressureSensorCapability,
   index.privacyMaskCapability,
   index.ptzCapability,
   index.ptzAutotrackCapability,
   index.rebootCapability,
   index.recordingCapability,
-  index.recordingEngineCapability,
   index.restreamerCapability,
+  index.scriptRunnerCapability,
   index.settingsStoreCapability,
+  index.smokeCapability,
   index.smtpProviderCapability,
   index.snapshotCapability,
   index.snapshotProviderCapability,
   index.ssoBridgeCapability,
   index.storageCapability,
+  index.storageEvictableCapability,
   index.storageProviderCapability,
   index.streamBrokerCapability,
   index.streamCatalogCapability,
@@ -4931,10 +5755,19 @@ const ALL_CAPABILITY_DEFINITIONS = [
   index.streamingEngineCapability,
   index.switchCapability,
   index.systemCapability,
+  index.tamperCapability,
+  index.temperatureSensorCapability,
   index.toastCapability,
   index.turnProviderCapability,
+  index.updateCapability,
   index.userManagementCapability,
   index.userPasskeysCapability,
+  index.vacuumControlCapability,
+  index.valveCapability,
+  index.vibrationCapability,
+  index.videoclipsCapability,
+  index.waterHeaterCapability,
+  index.weatherCapability,
   index.webrtcCapability,
   index.webrtcSessionCapability,
   index.zoneAnalyticsCapability,
@@ -4943,29 +5776,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" },
@@ -5017,6 +5893,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" },
@@ -5047,6 +5926,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" },
@@ -5057,11 +5939,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" },
@@ -5076,6 +5992,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" },
@@ -5087,7 +6010,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" },
@@ -5105,6 +6033,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" },
@@ -5117,13 +6046,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" },
@@ -5131,9 +6069,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" },
@@ -5156,6 +6096,16 @@ 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" },
+  "filesystemBrowse.browse": { capName: "filesystem-browse", capScope: "system", addonId: null, access: "view" },
+  "filesystemBrowse.createDir": { capName: "filesystem-browse", capScope: "system", addonId: null, access: "create" },
+  "filesystemBrowse.listAllowedRoots": { capName: "filesystem-browse", capScope: "system", addonId: null, access: "view" },
+  "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" },
@@ -5168,18 +6118,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" },
@@ -5237,17 +6205,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" },
@@ -5326,7 +6298,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" },
@@ -5348,34 +6322,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" },
@@ -5401,6 +6364,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" },
@@ -5411,6 +6375,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" },
@@ -5440,6 +6406,7 @@ const METHOD_ACCESS_MAP = Object.freeze({
   "streamBroker.listAllCameraStreams": { capName: "stream-broker", capScope: "system", addonId: null, access: "view" },
   "streamBroker.listAllProfileSlots": { capName: "stream-broker", capScope: "system", addonId: null, access: "view" },
   "streamBroker.listClients": { capName: "stream-broker", capScope: "system", addonId: null, access: "view" },
+  "streamBroker.probeStream": { capName: "stream-broker", capScope: "system", addonId: null, access: "create" },
   "streamBroker.publishCameraStream": { capName: "stream-broker", capScope: "system", addonId: null, access: "create" },
   "streamBroker.pullAudioChunks": { capName: "stream-broker", capScope: "system", addonId: null, access: "view" },
   "streamBroker.pullFrameHandles": { capName: "stream-broker", capScope: "system", addonId: null, access: "view" },
@@ -5472,6 +6439,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" },
@@ -5504,6 +6472,21 @@ 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" },
+  "videoclips.getClipPlayback": { capName: "videoclips", capScope: "device", addonId: null, access: "view" },
+  "videoclips.listClips": { capName: "videoclips", capScope: "device", addonId: null, access: "view" },
+  "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" },
@@ -5516,6 +6499,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" },
@@ -5532,6 +6516,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",
@@ -5541,17 +6526,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",
@@ -5560,10 +6556,16 @@ const KNOWN_CAP_NAMES = [
   "device-state",
   "embedding-encoder",
   "events",
+  "fan-control",
+  "filesystem-browse",
+  "humidifier",
   "integrations",
   "intercom",
+  "lawn-mower-control",
   "local-network",
+  "lock-control",
   "log-destination",
+  "media-player",
   "mesh-network",
   "metrics-provider",
   "motion",
@@ -5576,6 +6578,7 @@ const KNOWN_CAP_NAMES = [
   "network-quality",
   "nodes",
   "notification-output",
+  "notifier",
   "oauth-integration",
   "osd",
   "pipeline-analytics",
@@ -5588,14 +6591,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",
@@ -5605,8 +6609,13 @@ const KNOWN_CAP_NAMES = [
   "system",
   "toast",
   "turn-provider",
+  "update",
   "user-management",
   "user-passkeys",
+  "vacuum-control",
+  "valve",
+  "videoclips",
+  "water-heater",
   "webrtc",
   "webrtc-session",
   "zone-analytics",
@@ -5614,31 +6623,52 @@ 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",
+  "videoclips",
+  "water-heater",
   "webrtc-session",
   "zone-analytics",
   "zone-rules",
@@ -5659,12 +6689,15 @@ const SYSTEM_CAP_NAMES = [
   "audio-codec",
   "auth-provider",
   "backup",
+  "broker",
   "decoder",
+  "device-adoption",
   "device-export",
   "device-manager",
   "device-provider",
   "device-state",
   "embedding-encoder",
+  "filesystem-browse",
   "integrations",
   "local-network",
   "log-destination",
@@ -5680,13 +6713,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",
@@ -5734,6 +6768,7 @@ const SCOPE_PRESETS = [
   }
 ];
 const CAP_PROVIDER_KIND_MAP = Object.freeze({
+  "broker": "broker",
   "device-export": "device-export",
   "mesh-network": "mesh",
   "mqtt-broker": "broker",
@@ -5741,6 +6776,7 @@ const CAP_PROVIDER_KIND_MAP = Object.freeze({
   "smtp-provider": "email"
 });
 const PROVIDER_KIND_CAP_NAMES = [
+  "broker",
   "device-export",
   "mesh-network",
   "mqtt-broker",
@@ -5754,6 +6790,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,
@@ -5907,6 +6983,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)) {
@@ -5928,11 +7022,24 @@ exports.AddonAutoUpdateSchema = index.AddonAutoUpdateSchema;
 exports.AddonListItemSchema = index.AddonListItemSchema;
 exports.AddonPageDeclarationSchema = index.AddonPageDeclarationSchema;
 exports.AddonPageInfoSchema = index.AddonPageInfoSchema;
+exports.AdoptionAdoptInputSchema = index.AdoptInputSchema;
+exports.AdoptionAdoptResultSchema = index.AdoptResultSchema;
+exports.AdoptionFilterSchema = index.AdoptionFilterSchema;
+exports.AdoptionGetCandidateInputSchema = index.GetCandidateInputSchema;
+exports.AdoptionListCandidatesInputSchema = index.ListCandidatesInputSchema;
+exports.AdoptionListCandidatesOutputSchema = index.ListCandidatesOutputSchema;
+exports.AdoptionReleaseInputSchema = index.ReleaseInputSchema;
+exports.AdoptionStatusSchema = index.AdoptionStatusSchema;
 exports.AgentLoadSummarySchema = index.AgentLoadSummarySchema;
+exports.AirQualitySensorStatusSchema = index.AirQualitySensorStatusSchema;
+exports.AlarmArmModeSchema = index.AlarmArmModeSchema;
+exports.AlarmPanelStatusSchema = index.AlarmPanelStatusSchema;
+exports.AlarmStateSchema = index.AlarmStateSchema;
 exports.AlertSchema = index.AlertSchema;
 exports.AlertSeveritySchema = index.AlertSeveritySchema;
 exports.AlertSourceSchema = index.AlertSourceSchema;
 exports.AlertStatusSchema = index.AlertStatusSchema;
+exports.AmbientLightSensorStatusSchema = index.AmbientLightSensorStatusSchema;
 exports.ApiKeyRecordSchema = index.ApiKeyRecordSchema;
 exports.ApiKeySummarySchema = index.ApiKeySummarySchema;
 exports.ArchiveEntrySchema = index.ArchiveEntrySchema;
@@ -5945,6 +7052,7 @@ exports.AudioClassificationLabelSchema = index.AudioClassificationLabelSchema;
 exports.AudioClassificationResultSchema = index.AudioClassificationResultSchema;
 exports.AudioCodecInfoSchema = index.AudioCodecInfoSchema;
 exports.AudioDecodeSessionConfigSchema = index.AudioDecodeSessionConfigSchema;
+exports.AudioEncodeSchema = index.AudioEncodeSchema;
 exports.AudioEncodeSessionConfigSchema = index.AudioEncodeSessionConfigSchema;
 exports.AudioEncodedChunkSchema = index.AudioEncodedChunkSchema;
 exports.AudioEventSchema = index.AudioEventSchema;
@@ -5955,21 +7063,36 @@ exports.AudioMetricsSnapshotSchema = index.AudioMetricsSnapshotSchema;
 exports.AudioPcmChunkSchema = index.AudioPcmChunkSchema;
 exports.AuthResultSchema = index.AuthResultSchema;
 exports.AutoUpdateSettingsSchema = index.AutoUpdateSettingsSchema;
+exports.AutomationControlStatusSchema = index.AutomationControlStatusSchema;
 exports.AvailableIntegrationTypeSchema = index.AvailableIntegrationTypeSchema;
 exports.BATTERY_DEVICE_PROFILE = index.BATTERY_DEVICE_PROFILE;
 exports.BackupDestinationInfoSchema = index.BackupDestinationInfoSchema;
 exports.BackupEntrySchema = index.BackupEntrySchema;
 exports.BatteryStatusSchema = index.BatteryStatusSchema;
+exports.BinaryStatusSchema = index.BinaryStatusSchema;
 exports.BoundingBoxSchema = index.BoundingBoxSchema;
 exports.BrightnessStatusSchema = index.BrightnessStatusSchema;
+exports.BrokerAddInputSchema = index.AddInputSchema;
 exports.BrokerAudioClientSchema = index.BrokerAudioClientSchema;
 exports.BrokerClientsSchema = index.BrokerClientsSchema;
 exports.BrokerConnectionDetailsSchema = index.BrokerConnectionDetailsSchema;
+exports.BrokerConsumerAttributionSchema = index.BrokerConsumerAttributionSchema;
+exports.BrokerConsumerKindSchema = index.BrokerConsumerKindSchema;
 exports.BrokerDecodedClientSchema = index.BrokerDecodedClientSchema;
+exports.BrokerEncodedClientSchema = index.BrokerEncodedClientSchema;
+exports.BrokerGetStateInputSchema = index.GetStateInputSchema;
 exports.BrokerInfoSchema = index.BrokerInfoSchema;
+exports.BrokerProviderInfoSchema = index.BrokerProviderInfoSchema;
+exports.BrokerPublishInputSchema = index.PublishInputSchema;
+exports.BrokerRegistryStatusSchema = index.RegistryStatusSchema;
 exports.BrokerRtspClientSchema = index.BrokerRtspClientSchema;
 exports.BrokerStatsSchema = index.BrokerStatsSchema;
+exports.BrokerStatusEnum = index.BrokerStatusEnum;
 exports.BrokerStatusSchema = index.BrokerStatusSchema;
+exports.BrokerSubscribeInputSchema = index.SubscribeInputSchema;
+exports.BrokerSubscribeResultSchema = index.SubscribeResultSchema;
+exports.BrokerTestConnectionResultSchema = index.TestConnectionResultSchema;
+exports.BrokerUnsubscribeInputSchema = index.UnsubscribeInputSchema;
 exports.CAM_PROFILE_ORDER = index.CAM_PROFILE_ORDER;
 exports.CamProfileSchema = index.CamProfileSchema;
 exports.CamStreamDescriptorSchema = index.CamStreamDescriptorSchema;
@@ -5980,17 +7103,31 @@ exports.CameraCredentialsStatusSchema = index.CameraCredentialsStatusSchema;
 exports.CameraMetricsSchema = index.CameraMetricsSchema;
 exports.CameraMetricsWithDeviceIdSchema = index.CameraMetricsWithDeviceIdSchema;
 exports.CameraStreamSchema = index.CameraStreamSchema;
+exports.CandidateQueryFilterSchema = index.CandidateQueryFilterSchema;
 exports.CapScopeSchema = index.CapScopeSchema;
 exports.CapabilityBindingsSchema = index.CapabilityBindingsSchema;
+exports.CarbonMonoxideStatusSchema = index.CarbonMonoxideStatusSchema;
 exports.ChargingStatus = index.ChargingStatus;
 exports.ClientNetworkStatsSchema = index.ClientNetworkStatsSchema;
+exports.ClimateControlStatusSchema = index.ClimateControlStatusSchema;
+exports.ClipPlaybackSchema = index.ClipPlaybackSchema;
+exports.ClipSchema = index.ClipSchema;
 exports.ClusterAddonNodeDeploymentSchema = index.ClusterAddonNodeDeploymentSchema;
 exports.ClusterAddonStatusEntrySchema = index.ClusterAddonStatusEntrySchema;
 exports.CollectionColumnSchema = index.CollectionColumnSchema;
 exports.CollectionIndexSchema = index.CollectionIndexSchema;
+exports.ColorStatusSchema = index.ColorStatusSchema;
 exports.ConfigEntrySchema = index.ConfigEntrySchema;
 exports.ConfigSectionWithValuesSchema = index.ConfigSectionWithValuesSchema;
 exports.ConfigTabDeclarationSchema = index.ConfigTabDeclarationSchema;
+exports.ConnectivityStatusSchema = index.ConnectivityStatusSchema;
+exports.ConsumableItemSchema = index.ConsumableItemSchema;
+exports.ConsumablesStatusSchema = index.ConsumablesStatusSchema;
+exports.ContactStatusSchema = index.ContactStatusSchema;
+exports.ControlKindSchema = index.ControlKindSchema;
+exports.ControlStatusSchema = index.ControlStatusSchema;
+exports.CoverStateSchema = index.CoverStateSchema;
+exports.CoverStatusSchema = index.CoverStatusSchema;
 exports.CreateApiKeyInputSchema = index.CreateApiKeyInputSchema;
 exports.CreateApiKeyResultSchema = index.CreateApiKeyResultSchema;
 exports.CreateIntegrationInputSchema = index.CreateIntegrationInputSchema;
@@ -6027,31 +7164,48 @@ exports.DoorbellPressEventSchema = index.DoorbellPressEventSchema;
 exports.DoorbellStatusSchema = index.DoorbellStatusSchema;
 exports.EmbeddingInfoSchema = index.EmbeddingInfoSchema;
 exports.EmbeddingResultSchema = index.EmbeddingResultSchema;
+exports.EncodeProfileSchema = index.EncodeProfileSchema;
 exports.EncodedPacketSchema = index.EncodedPacketSchema;
 exports.EnrichedWidgetMetadataSchema = index.EnrichedWidgetMetadataSchema;
+exports.EnumSensorDateTimeFormatSchema = index.EnumSensorDateTimeFormatSchema;
+exports.EnumSensorStatusSchema = index.EnumSensorStatusSchema;
+exports.EventEmitterStatusSchema = index.EventEmitterStatusSchema;
+exports.EventFireSchema = index.EventFireSchema;
 exports.EventItemSchema = index.EventItemSchema;
 exports.EventKindSchema = index.EventKindSchema;
 exports.ExportSetupFieldSchema = index.ExportSetupFieldSchema;
 exports.ExportSetupSchema = index.ExportSetupSchema;
 exports.ExposedDeviceSchema = index.ExposedDeviceSchema;
 exports.ExposedResourceSchema = index.ExposedResourceSchema;
+exports.FanControlStatusSchema = index.FanControlStatusSchema;
+exports.FanDirectionSchema = index.FanDirectionSchema;
 exports.FeatureManifestSchema = index.FeatureManifestSchema;
 exports.FeatureProbeStatusSchema = index.FeatureProbeStatusSchema;
+exports.FloodStatusSchema = index.FloodStatusSchema;
 exports.FrameHandleFormatSchema = index.FrameHandleFormatSchema;
 exports.FrameHandleSchema = index.FrameHandleSchema;
 exports.FrameInputSchema = index.FrameInputSchema;
+exports.GasStatusSchema = index.GasStatusSchema;
 exports.GetStreamWithCodecInputSchema = index.GetStreamWithCodecInputSchema;
 exports.GlobalMetricsSchema = index.GlobalMetricsSchema;
 exports.HWACCEL_OPTIONS = index.HWACCEL_OPTIONS;
 exports.HealthStatusSchema = index.HealthStatusSchema;
 exports.HistoryPointSchema = index.HistoryPointSchema;
 exports.HistoryResolutionEnum = index.HistoryResolutionEnum;
+exports.HumidifierStatusSchema = index.HumidifierStatusSchema;
+exports.HumiditySensorStatusSchema = index.HumiditySensorStatusSchema;
+exports.HvacModeSchema = index.HvacModeSchema;
+exports.ImageStatusSchema = index.ImageStatusSchema;
 exports.InstalledPackageSchema = index.InstalledPackageSchema;
 exports.IntegrationLiteSchema = index.IntegrationLiteSchema;
 exports.IntegrationWithStateSchema = index.IntegrationWithStateSchema;
 exports.IntercomAbilitySchema = index.IntercomAbilitySchema;
 exports.IntercomStatusSchema = index.IntercomStatusSchema;
+exports.LawnMowerActivitySchema = index.LawnMowerActivitySchema;
+exports.LawnMowerControlStatusSchema = index.LawnMowerControlStatusSchema;
 exports.LocationStatSchema = index.LocationStatSchema;
+exports.LockControlStatusSchema = index.LockControlStatusSchema;
+exports.LockStateSchema = index.LockStateSchema;
 exports.LogEntrySchema = index.LogEntrySchema;
 exports.LogLevelSchema = index.LogLevelSchema;
 exports.LogStreamEntrySchema = index.LogStreamEntrySchema;
@@ -6066,6 +7220,9 @@ exports.MaskRectShapeSchema = index.MaskRectShapeSchema;
 exports.MaskShapeKindSchema = index.MaskShapeKindSchema;
 exports.MaskShapeSchema = index.MaskShapeSchema;
 exports.MediaFileSchema = index.MediaFileSchema;
+exports.MediaPlayerRepeatSchema = index.MediaPlayerRepeatSchema;
+exports.MediaPlayerStateSchema = index.MediaPlayerStateSchema;
+exports.MediaPlayerStatusSchema = index.MediaPlayerStatusSchema;
 exports.MeshPeerSchema = index.MeshPeerSchema;
 exports.MeshStatusSchema = index.MeshStatusSchema;
 exports.MethodAccessSchema = index.MethodAccessSchema;
@@ -6093,6 +7250,8 @@ exports.NetworkEndpointSchema = index.NetworkEndpointSchema;
 exports.NotificationHistoryEntrySchema = index.NotificationHistoryEntrySchema;
 exports.NotificationRuleSchema = index.NotificationRuleSchema;
 exports.NotificationSchema = index.NotificationSchema;
+exports.NotifierStatusSchema = index.NotifierStatusSchema;
+exports.NumericSensorStatusSchema = index.NumericSensorStatusSchema;
 exports.OauthIntegrationDescriptorSchema = index.OauthIntegrationDescriptorSchema;
 exports.ObjectEventSchema = index.ObjectEventSchema;
 exports.OrchestratorMetricsSchema = index.OrchestratorMetricsSchema;
@@ -6108,6 +7267,9 @@ exports.PackageVersionInfoSchema = index.PackageVersionInfoSchema;
 exports.PasskeySummarySchema = index.PasskeySummarySchema;
 exports.PcmSampleFormatSchema = index.PcmSampleFormatSchema;
 exports.PerScopeBreakdownSchema = index.PerScopeBreakdownSchema;
+exports.PickStreamPreferencesSchema = index.PickStreamPreferencesSchema;
+exports.PickStreamRequirementsSchema = index.PickStreamRequirementsSchema;
+exports.PickedCamStreamSchema = index.PickedCamStreamSchema;
 exports.PipelineAssignmentSchema = index.PipelineAssignmentSchema;
 exports.PipelineDefaultStepSchema = index.PipelineDefaultStepSchema;
 exports.PipelineEngineChoiceSchema = index.PipelineEngineChoiceSchema;
@@ -6115,11 +7277,15 @@ exports.PipelineRunResultBridge = index.PipelineRunResultBridge;
 exports.PipelineStepInputSchema = index.PipelineStepInputSchema;
 exports.PlaceholderReasonSchema = index.PlaceholderReasonSchema;
 exports.PolygonPointSchema = index.PolygonPointSchema;
+exports.PowerMeterStatusSchema = index.PowerMeterStatusSchema;
+exports.PresenceStatusSchema = index.PresenceStatusSchema;
+exports.PressureSensorStatusSchema = index.PressureSensorStatusSchema;
 exports.PrivacyMaskOptionsSchema = index.PrivacyMaskOptionsSchema;
 exports.PrivacyMaskPatchSchema = index.PrivacyMaskPatchSchema;
 exports.PrivacyMaskRegionSchema = index.PrivacyMaskRegionSchema;
 exports.PrivacyMaskShapeSchema = index.PrivacyMaskShapeSchema;
 exports.PrivacyMaskStatusSchema = index.PrivacyMaskStatusSchema;
+exports.ProfileRtspEntrySchema = index.ProfileRtspEntrySchema;
 exports.ProfileSlotSchema = index.ProfileSlotSchema;
 exports.ProfileSlotStatusSchema = index.ProfileSlotStatusSchema;
 exports.ProviderStatusSchema = index.ProviderStatusSchema;
@@ -6132,6 +7298,25 @@ exports.PtzPositionSchema = index.PtzPositionSchema;
 exports.PtzPresetSchema = index.PtzPresetSchema;
 exports.PtzStatusSchema = index.PtzStatusSchema;
 exports.QueryFilterSchema = index.QueryFilterSchema;
+exports.RawStateResultSchema = index.RawStateResultSchema;
+exports.RecordingAvailabilitySchema = index.RecordingAvailabilitySchema;
+exports.RecordingBandModeSchema = index.RecordingBandModeSchema;
+exports.RecordingBandSchema = index.RecordingBandSchema;
+exports.RecordingBandTriggersSchema = index.RecordingBandTriggersSchema;
+exports.RecordingConfigSchema = index.RecordingConfigSchema;
+exports.RecordingDeviceUsageSchema = index.RecordingDeviceUsageSchema;
+exports.RecordingLocationUsageSchema = index.RecordingLocationUsageSchema;
+exports.RecordingManifestSchema = index.RecordingManifestSchema;
+exports.RecordingModeSchema = index.RecordingModeSchema;
+exports.RecordingRangeSchema = index.RecordingRangeSchema;
+exports.RecordingRetentionSchema = index.RecordingRetentionSchema;
+exports.RecordingRuleSchema = index.RecordingRuleSchema;
+exports.RecordingScheduleSchema = index.RecordingScheduleSchema;
+exports.RecordingStatusSchema = index.RecordingStatusSchema;
+exports.RecordingStorageModeSchema = index.RecordingStorageModeSchema;
+exports.RecordingStorageUsageSchema = index.RecordingStorageUsageSchema;
+exports.RecordingTriggersSchema = index.RecordingTriggersSchema;
+exports.RecordingWeekdaySchema = index.RecordingWeekdaySchema;
 exports.RegisteredStreamSchema = index.RegisteredStreamSchema;
 exports.ReportMotionInputSchema = index.ReportMotionInputSchema;
 exports.RtpSourceSchema = index.RtpSourceSchema;
@@ -6140,11 +7325,11 @@ exports.RunnerCameraConfigSchema = index.RunnerCameraConfigSchema;
 exports.RunnerCameraDeviceUIFields = index.RunnerCameraDeviceUIFields;
 exports.RunnerLocalLoadSchema = index.RunnerLocalLoadSchema;
 exports.RunnerLocalMetricsSchema = index.RunnerLocalMetricsSchema;
-exports.STORAGE_LOCATION_CARDINALITY = index.STORAGE_LOCATION_CARDINALITY;
+exports.SOURCE_INFO_METADATA_KEY = index.SOURCE_INFO_METADATA_KEY;
 exports.ScopedTokenSchema = index.ScopedTokenSchema;
 exports.ScopedTokenSummarySchema = index.ScopedTokenSummarySchema;
+exports.ScriptRunnerStatusSchema = index.ScriptRunnerStatusSchema;
 exports.SearchResultSchema = index.SearchResultSchema;
-exports.SegmentSchema = index.SegmentSchema;
 exports.SendEmailInputSchema = index.SendEmailInputSchema;
 exports.SendEmailResultSchema = index.SendEmailResultSchema;
 exports.SettingsPatchSchema = index.SettingsPatchSchema;
@@ -6152,8 +7337,10 @@ exports.SettingsRecordSchema = index.SettingsRecordSchema;
 exports.SettingsSchemaWithValuesSchema = index.SettingsSchemaWithValuesSchema;
 exports.SettingsUpdateResultSchema = index.SettingsUpdateResultSchema;
 exports.ShmRingStatsSchema = index.ShmRingStatsSchema;
+exports.SmokeStatusSchema = index.SmokeStatusSchema;
 exports.SmtpStatusSchema = index.SmtpStatusSchema;
 exports.SnapshotImageSchema = index.SnapshotImageSchema;
+exports.SourceInfoSchema = index.SourceInfoSchema;
 exports.SpatialDetectionSchema = index.SpatialDetectionSchema;
 exports.SsoBridgeClaimsSchema = index.SsoBridgeClaimsSchema;
 exports.StartEmbeddedInputSchema = index.StartEmbeddedInputSchema;
@@ -6164,6 +7351,7 @@ exports.StorageBeginUploadInputSchema = index.BeginUploadInputSchema;
 exports.StorageBeginUploadResultSchema = index.BeginUploadResultSchema;
 exports.StorageEndDownloadInputSchema = index.EndDownloadInputSchema;
 exports.StorageFinalizeUploadInputSchema = index.FinalizeUploadInputSchema;
+exports.StorageLocationDeclarationSchema = index.StorageLocationDeclarationSchema;
 exports.StorageLocationRefSchema = index.StorageLocationRefSchema;
 exports.StorageLocationSchema = index.StorageLocationSchema;
 exports.StorageLocationTypeSchema = index.StorageLocationTypeSchema;
@@ -6171,6 +7359,7 @@ exports.StorageProviderInfoSchema = index.ProviderInfoSchema;
 exports.StorageReadChunkInputSchema = index.ReadChunkInputSchema;
 exports.StorageTestLocationResultSchema = index.TestLocationResultSchema;
 exports.StorageWriteChunkInputSchema = index.WriteChunkInputSchema;
+exports.StreamCodecSchema = index.StreamCodecSchema;
 exports.StreamFormatSchema = index.StreamFormatSchema;
 exports.StreamInfoSchema = index.StreamInfoSchema;
 exports.StreamNetworkStatsSchema = index.StreamNetworkStatsSchema;
@@ -6188,7 +7377,10 @@ exports.SubscribeFramesInputSchema = index.SubscribeFramesInputSchema;
 exports.SubscribeFramesResultSchema = index.SubscribeFramesResultSchema;
 exports.SwitchStatusSchema = index.SwitchStatusSchema;
 exports.SystemMetricsSchema = index.SystemMetricsSchema;
-exports.TestConnectionResultSchema = index.TestConnectionResultSchema;
+exports.TamperStatusSchema = index.TamperStatusSchema;
+exports.TankStatusSchema = index.TankStatusSchema;
+exports.TemperatureSensorStatusSchema = index.TemperatureSensorStatusSchema;
+exports.TestConnectionResultSchema = index.TestConnectionResultSchema$1;
 exports.ToastSchema = index.ToastSchema;
 exports.TokenScopeSchema = index.TokenScopeSchema;
 exports.TopologyNodeSchema = index.TopologyNodeSchema;
@@ -6198,12 +7390,22 @@ exports.TrackSchema = index.TrackSchema;
 exports.TrackStateSchema = index.TrackStateSchema;
 exports.TrackedDetectionSchema = index.TrackedDetectionSchema;
 exports.TurnServerSchema = index.TurnServerSchema;
+exports.UnifiedBrokerInfoSchema = index.BrokerInfoSchema$1;
 exports.UpdateIntegrationInputSchema = index.UpdateIntegrationInputSchema;
+exports.UpdateStatusSchema = index.UpdateStatusSchema;
 exports.UpdateUserInputSchema = index.UpdateUserInputSchema;
 exports.UserRecordSchema = index.UserRecordSchema;
 exports.UserSummarySchema = index.UserSummarySchema;
+exports.VacuumControlStatusSchema = index.VacuumControlStatusSchema;
+exports.VacuumStateSchema = index.VacuumStateSchema;
+exports.ValveStateSchema = index.ValveStateSchema;
+exports.ValveStatusSchema = index.ValveStatusSchema;
+exports.VibrationStatusSchema = index.VibrationStatusSchema;
+exports.VideoEncodeSchema = index.VideoEncodeSchema;
 exports.WELL_KNOWN_TABS = index.WELL_KNOWN_TABS;
 exports.WELL_KNOWN_TAB_MAP = index.WELL_KNOWN_TAB_MAP;
+exports.WaterHeaterStatusSchema = index.WaterHeaterStatusSchema;
+exports.WeatherStatusSchema = index.WeatherStatusSchema;
 exports.WebrtcStreamChoiceSchema = index.WebrtcStreamChoiceSchema;
 exports.WebrtcStreamTargetSchema = index.WebrtcStreamTargetSchema;
 exports.WidgetHostEnum = index.WidgetHostEnum;
@@ -6229,20 +7431,36 @@ exports.addonWidgetsSourceCapability = index.addonWidgetsSourceCapability;
 exports.addonsCapability = index.addonsCapability;
 exports.adminUiCapability = index.adminUiCapability;
 exports.advancedNotifierCapability = index.advancedNotifierCapability;
+exports.airQualitySensorCapability = index.airQualitySensorCapability;
+exports.alarmPanelCapability = index.alarmPanelCapability;
 exports.alertsCapability = index.alertsCapability;
+exports.ambientLightSensorCapability = index.ambientLightSensorCapability;
 exports.audioAnalysisCapability = index.audioAnalysisCapability;
 exports.audioAnalyzerCapability = index.audioAnalyzerCapability;
 exports.audioCodecCapability = index.audioCodecCapability;
 exports.audioMetricsCapability = index.audioMetricsCapability;
 exports.authProviderCapability = index.authProviderCapability;
+exports.automationControlCapability = index.automationControlCapability;
 exports.backupCapability = index.backupCapability;
 exports.batteryCapability = index.batteryCapability;
+exports.binaryCapability = index.binaryCapability;
 exports.brightnessCapability = index.brightnessCapability;
+exports.brokerCapability = index.brokerCapability;
+exports.buttonCapability = index.buttonCapability;
 exports.cameraCredentialsCapability = index.cameraCredentialsCapability;
 exports.cameraPipelineConfigCapability = index.cameraPipelineConfigCapability;
 exports.cameraStreamsCapability = index.cameraStreamsCapability;
+exports.carbonMonoxideCapability = index.carbonMonoxideCapability;
+exports.climateControlCapability = index.climateControlCapability;
+exports.colorCapability = index.colorCapability;
+exports.connectivityCapability = index.connectivityCapability;
+exports.consumablesCapability = index.consumablesCapability;
+exports.contactCapability = index.contactCapability;
+exports.controlCapability = index.controlCapability;
+exports.coverCapability = index.coverCapability;
 exports.decoderCapability = index.decoderCapability;
 exports.detectionPipelineCapability = index.detectionPipelineCapability;
+exports.deviceAdoptionCapability = index.deviceAdoptionCapability;
 exports.deviceDiscoveryCapability = index.deviceDiscoveryCapability;
 exports.deviceExportCapability = index.deviceExportCapability;
 exports.deviceManagerCapability = index.deviceManagerCapability;
@@ -6253,19 +7471,36 @@ exports.deviceStateCapability = index.deviceStateCapability;
 exports.deviceStatusCapability = index.deviceStatusCapability;
 exports.doorbellCapability = index.doorbellCapability;
 exports.embeddingEncoderCapability = index.embeddingEncoderCapability;
+exports.encodeProfileFromStreamShape = index.encodeProfileFromStreamShape;
+exports.enumSensorCapability = index.enumSensorCapability;
 exports.errMsg = index.errMsg;
 exports.event = index.event;
+exports.eventEmitterCapability = index.eventEmitterCapability;
 exports.eventsCapability = index.eventsCapability;
 exports.expandCapMethods = index.expandCapMethods;
+exports.extractSourceInfoFromMetadata = index.extractSourceInfoFromMetadata;
+exports.fanControlCapability = index.fanControlCapability;
 exports.featureProbeCapability = index.featureProbeCapability;
+exports.filesystemBrowseCapability = index.filesystemBrowseCapability;
+exports.floodCapability = index.floodCapability;
+exports.gasCapability = index.gasCapability;
 exports.getAudioMacroClassIds = index.getAudioMacroClassIds;
+exports.humidifierCapability = index.humidifierCapability;
+exports.humiditySensorCapability = index.humiditySensorCapability;
 exports.hydrateSchema = index.hydrateSchema;
+exports.imageCapability = index.imageCapability;
 exports.integrationsCapability = index.integrationsCapability;
 exports.intercomCapability = index.intercomCapability;
 exports.isDeviceConfigCap = index.isDeviceConfigCap;
+exports.lawnMowerControlCapability = index.lawnMowerControlCapability;
 exports.localNetworkCapability = index.localNetworkCapability;
+exports.lockControlCapability = index.lockControlCapability;
 exports.logDestinationCapability = index.logDestinationCapability;
+exports.makeProfileBrokerId = index.makeProfileBrokerId;
+exports.makeSourceBrokerId = index.makeSourceBrokerId;
 exports.mapAudioLabelToMacro = index.mapAudioLabelToMacro;
+exports.mediaPlayerCapability = index.mediaPlayerCapability;
+exports.mergeSourceInfo = index.mergeSourceInfo;
 exports.meshNetworkCapability = index.meshNetworkCapability;
 exports.method = index.method;
 exports.metricsProviderCapability = index.metricsProviderCapability;
@@ -6278,39 +7513,59 @@ exports.nativeObjectDetectionCapability = index.nativeObjectDetectionCapability;
 exports.networkAccessCapability = index.networkAccessCapability;
 exports.networkQualityCapability = index.networkQualityCapability;
 exports.nodesCapability = index.nodesCapability;
+exports.normalizeUnit = index.normalizeUnit;
 exports.notificationOutputCapability = index.notificationOutputCapability;
+exports.notifierCapability = index.notifierCapability;
+exports.numericSensorCapability = index.numericSensorCapability;
 exports.oauthIntegrationCapability = index.oauthIntegrationCapability;
 exports.osdCapability = index.osdCapability;
+exports.parseProfileBrokerId = index.parseProfileBrokerId;
 exports.pipelineAnalyticsCapability = index.pipelineAnalyticsCapability;
 exports.pipelineExecutorCapability = index.pipelineExecutorCapability;
 exports.pipelineOrchestratorCapability = index.pipelineOrchestratorCapability;
 exports.pipelineRunnerCapability = index.pipelineRunnerCapability;
 exports.platformProbeCapability = index.platformProbeCapability;
+exports.powerMeterCapability = index.powerMeterCapability;
+exports.presenceCapability = index.presenceCapability;
+exports.pressureSensorCapability = index.pressureSensorCapability;
 exports.privacyMaskCapability = index.privacyMaskCapability;
 exports.ptzAutotrackCapability = index.ptzAutotrackCapability;
 exports.ptzCapability = index.ptzCapability;
 exports.rebootCapability = index.rebootCapability;
 exports.recordingCapability = index.recordingCapability;
-exports.recordingEngineCapability = index.recordingEngineCapability;
 exports.resolveDeviceProfile = index.resolveDeviceProfile;
 exports.restreamerCapability = index.restreamerCapability;
+exports.scriptRunnerCapability = index.scriptRunnerCapability;
+exports.selectAssignedProfileSlots = index.selectAssignedProfileSlots;
 exports.settingsStoreCapability = index.settingsStoreCapability;
+exports.smokeCapability = index.smokeCapability;
 exports.smtpProviderCapability = index.smtpProviderCapability;
 exports.snapshotCapability = index.snapshotCapability;
 exports.snapshotProviderCapability = index.snapshotProviderCapability;
 exports.ssoBridgeCapability = index.ssoBridgeCapability;
 exports.storageCapability = index.storageCapability;
+exports.storageEvictableCapability = index.storageEvictableCapability;
 exports.storageProviderCapability = index.storageProviderCapability;
 exports.streamBrokerCapability = index.streamBrokerCapability;
 exports.streamCatalogCapability = index.streamCatalogCapability;
 exports.streamParamsCapability = index.streamParamsCapability;
 exports.streamingEngineCapability = index.streamingEngineCapability;
 exports.switchCapability = index.switchCapability;
+exports.synthesizeSourceInfo = index.synthesizeSourceInfo;
 exports.systemCapability = index.systemCapability;
+exports.tamperCapability = index.tamperCapability;
+exports.temperatureSensorCapability = index.temperatureSensorCapability;
 exports.toastCapability = index.toastCapability;
 exports.turnProviderCapability = index.turnProviderCapability;
+exports.updateCapability = index.updateCapability;
 exports.userManagementCapability = index.userManagementCapability;
 exports.userPasskeysCapability = index.userPasskeysCapability;
+exports.vacuumControlCapability = index.vacuumControlCapability;
+exports.valveCapability = index.valveCapability;
+exports.vibrationCapability = index.vibrationCapability;
+exports.videoclipsCapability = index.videoclipsCapability;
+exports.waterHeaterCapability = index.waterHeaterCapability;
+exports.weatherCapability = index.weatherCapability;
 exports.webrtcCapability = index.webrtcCapability;
 exports.webrtcClientHintsSchema = index.webrtcClientHintsSchema;
 exports.webrtcSessionCapability = index.webrtcSessionCapability;
@@ -6333,9 +7588,9 @@ exports.CAP_NAMES_WITH_STATUS = CAP_NAMES_WITH_STATUS;
 exports.CAP_PROVIDER_KIND_MAP = CAP_PROVIDER_KIND_MAP;
 exports.COCO_80_LABELS = COCO_80_LABELS;
 exports.COCO_TO_MACRO = COCO_TO_MACRO;
+exports.DATAPLANE_SECRET_HEADER = DATAPLANE_SECRET_HEADER;
 exports.DEFAULT_ADDON_PLACEMENT = DEFAULT_ADDON_PLACEMENT;
 exports.DEFAULT_FEATURES = DEFAULT_FEATURES;
-exports.DEFAULT_LOCATION_SUBDIRS = DEFAULT_LOCATION_SUBDIRS;
 exports.DEFAULT_RETENTION = DEFAULT_RETENTION;
 exports.DEVICE_CAP_NAMES = DEVICE_CAP_NAMES;
 exports.DEVICE_TYPE_INFO = DEVICE_TYPE_INFO;
@@ -6359,18 +7614,20 @@ exports.ReadinessRegistry = ReadinessRegistry;
 exports.ReadinessTimeoutError = ReadinessTimeoutError;
 exports.RingBuffer = RingBuffer;
 exports.SCOPE_PRESETS = SCOPE_PRESETS;
-exports.STORAGE_LOCATION_TYPES = STORAGE_LOCATION_TYPES;
 exports.STREAM_PROFILE_META = STREAM_PROFILE_META;
 exports.STREAM_QUALITY_LABELS = STREAM_QUALITY_LABELS;
 exports.SUB_DETECTION_TYPES = SUB_DETECTION_TYPES;
 exports.SYSTEM_CAP_NAMES = SYSTEM_CAP_NAMES;
 exports.SystemMirror = SystemMirror;
+exports.TIMEZONES = TIMEZONES;
+exports.applyTransform = applyTransform;
 exports.asBoolean = asBoolean;
 exports.asJsonArray = asJsonArray;
 exports.asJsonObject = asJsonObject;
 exports.asNumber = asNumber;
 exports.asString = asString;
 exports.autoAssignProfiles = autoAssignProfiles;
+exports.bestLocationMatch = bestLocationMatch;
 exports.bindAddonActions = bindAddonActions;
 exports.buildAddonRouteProvider = buildAddonRouteProvider;
 exports.buildStreamParamsConfigSchema = buildStreamParamsConfigSchema;
@@ -6379,6 +7636,7 @@ exports.classifyStream = classifyStream;
 exports.classifyStreams = classifyStreams;
 exports.cosineSimilarity = cosineSimilarity;
 exports.createDeviceProxy = createDeviceProxy;
+exports.createDurableState = createDurableState;
 exports.createEvent = createEvent;
 exports.createLazyTrpcSource = createLazyTrpcSource;
 exports.createMirrorSource = createMirrorSource;
@@ -6387,23 +7645,30 @@ exports.createSliceHandle = createSliceHandle;
 exports.createSystemProxy = createSystemProxy;
 exports.customAction = customAction;
 exports.defineCustomActions = defineCustomActions;
+exports.deviceCustomAction = deviceCustomAction;
 exports.emitDownForOwnedCaps = emitDownForOwnedCaps;
 exports.emitReadiness = emitReadiness;
+exports.enumerateSchemaFields = enumerateSchemaFields;
 exports.evaluateZoneRules = evaluateZoneRules;
+exports.findTimezone = findTimezone;
 exports.formatForBackend = formatForBackend;
 exports.formatForRuntime = formatForRuntime;
+exports.getByPath = getByPath;
 exports.getCapsByProviderKind = getCapsByProviderKind;
 exports.hfModelUrl = hfModelUrl;
 exports.isAgentOnlyPlacement = isAgentOnlyPlacement;
 exports.isDeployableToAgent = isDeployableToAgent;
 exports.isEvent = isEvent;
+exports.locationSimilarity = locationSimilarity;
 exports.maskUrlCredentials = maskUrlCredentials;
+exports.migrateConfigToBands = migrateConfigToBands;
 exports.normalizeAddonInitResult = normalizeAddonInitResult;
 exports.parseCameraStreamConfig = parseCameraStreamConfig;
 exports.parseJsonArray = parseJsonArray;
 exports.parseJsonObject = parseJsonObject;
 exports.parseJsonUnknown = parseJsonUnknown;
 exports.parseStreamParamsFormPatch = parseStreamParamsFormPatch;
+exports.pickPreferredRtspEntry = pickPreferredRtspEntry;
 exports.pythonScriptForBackend = pythonScriptForBackend;
 exports.readinessKey = readinessKey;
 exports.rectsToCells = rectsToCells;
@@ -6417,6 +7682,9 @@ exports.resolveModelFormat = resolveModelFormat;
 exports.resolveRunnerId = resolveRunnerId;
 exports.runInferenceStep = runInferenceStep;
 exports.scopeKey = scopeKey;
+exports.setByPath = setByPath;
+exports.sleep = sleep;
+exports.sleepCancellable = sleepCancellable;
 exports.streamPixels = streamPixels;
 exports.streamQualityLabel = streamQualityLabel;
 exports.toDeviceSummary = toDeviceSummary;