@camstack/types 0.1.31 → 0.1.33

package/dist/{index-BKnvgAep.mjs → index-YnRVILXN.mjs}

@@ -1069,9 +1069,9 @@ const DecodedFrameSchema = z.object({
   format: z.enum(["jpeg", "rgb", "bgr", "yuv420", "gray"]),
   timestamp: z.number()
 });
-const BrokerStatusSchema = z.enum(["idle", "connecting", "streaming", "error", "stopped"]);
+const BrokerStatusSchema$1 = z.enum(["idle", "connecting", "streaming", "error", "stopped"]);
 const BrokerStatsSchema = z.object({
-  status: BrokerStatusSchema,
+  status: BrokerStatusSchema$1,
   inputFps: z.number(),
   decodeFps: z.number(),
   encodedSubscribers: z.number(),
@@ -1177,22 +1177,34 @@ const PlaceholderReasonSchema = z.enum([
   "disabled",
   "waking"
 ]);
+const VideoCodecTargetSchema = z.enum(["H264", "H265", "auto"]);
+const AudioCodecTargetSchema = z.enum(["AAC", "Opus", "PCMU", "none"]);
+const MaxResolutionSchema = z.object({
+  width: z.number().int().positive(),
+  height: z.number().int().positive()
+});
+const GetStreamWithCodecInputSchema = z.object({
+  deviceId: z.number().int().nonnegative(),
+  videoCodec: VideoCodecTargetSchema,
+  audioCodec: AudioCodecTargetSchema.optional(),
+  maxResolution: MaxResolutionSchema.optional(),
+  tag: z.string().optional()
+});
+const RtpSourceSchema = z.object({
+  url: z.string(),
+  videoCodec: z.enum(["H264", "H265"]),
+  audioCodec: z.string(),
+  resolution: MaxResolutionSchema,
+  transcoded: z.boolean(),
+  encoder: z.string(),
+  pipelineKey: z.string()
+});
 const streamBrokerCapability = {
   name: "stream-broker",
   scope: "system",
   mode: "singleton",
   exposesDeviceSettings: true,
   methods: {
-    // ── Cam stream lifecycle (publish / retract) ─────────────────────
-    /**
-     * Register a physical camera stream as an input option. Idempotent
-     * for (deviceId, camStreamId) — re-publishing updates metadata
-     * without disturbing profile assignments. The provider calls this
-     * in `onInitialize` for each stream it offers. Third-party addons
-     * may also publish (e.g. an RTMP discovery layer) — camstack has
-     * no notion of "owner" beyond the (deviceId, camStreamId) key.
-     */
-    /* — see STREAM_BROKER_CAP_EVENTS below for cap-event category strings — */
     publishCameraStream: method(
       z.object({
         deviceId: z.number().int().nonnegative(),
@@ -1203,28 +1215,8 @@ const streamBrokerCapability = {
         resolution: CamStreamResolutionSchema.optional(),
         fps: z.number().positive().optional(),
         label: z.string().optional(),
-        /**
-         * Device-level features that the broker / manager / snapshot
-         * orchestrator consult to derive per-stream policy (e.g.
-         * `BatteryOperated` → relax stall watchdog, default pre-buffer
-         * to off, raise snapshot rate-limit). Single source of truth —
-         * publishers no longer set per-stream flags like `allowStall`.
-         */
         deviceFeatures: z.array(z.string()).optional(),
-        /**
-         * Whether this stream participates in the broker's automatic
-         * profile assignment. Defaults `true`. Publishers set `false` for
-         * streams that should be SELECTABLE but not auto-picked — e.g.
-         * Reolink publishes native Baichuan as eligible and RTSP/RTMP
-         * mirrors as ineligible (still assignable manually via
-         * `assignProfile`).
-         */
         autoEligible: z.boolean().optional(),
-        /**
-         * Transport-specific opaque metadata stashed alongside the stream
-         * record. `pull-rfc4571` publishers put the SDP here so the broker
-         * reader can route packets without an in-band DESCRIBE phase.
-         */
         metadata: z.record(z.string(), z.unknown()).optional()
       }),
       z.object({ success: z.literal(true) }),
@@ -1238,12 +1230,6 @@ const streamBrokerCapability = {
       z.object({ success: z.literal(true) }),
       { kind: "mutation", auth: "admin" }
     ),
-    // ── Profile assignment ───────────────────────────────────────────
-    /**
-     * Assign a cam stream to a profile slot. Tears down any existing
-     * broker for that slot and rebuilds against the new source. Persists
-     * the choice — survives reboots.
-     */
     assignProfile: method(
       z.object({
         deviceId: z.number().int().nonnegative(),
@@ -1261,12 +1247,6 @@ const streamBrokerCapability = {
       z.object({ success: z.literal(true) }),
       { kind: "mutation", auth: "admin" }
     ),
-    // ── System-wide views ────────────────────────────────────────────
-    /**
-     * Full dump of every published cam stream across every device.
-     * For dashboards and cross-device tooling; per-device reads go
-     * through the `camera-streams` cap on the device proxy.
-     */
     listAllCameraStreams: method(
       z.void(),
       z.array(CameraStreamSchema).readonly()
@@ -1275,7 +1255,6 @@ const streamBrokerCapability = {
       z.void(),
       z.array(ProfileSlotSchema).readonly()
     ),
-    // ── Broker runtime (stats + client inventory) ────────────────────
     getBrokerStats: method(
       z.object({ brokerId: z.string() }),
       BrokerStatsSchema
@@ -1293,7 +1272,6 @@ const streamBrokerCapability = {
       z.object({ killed: z.boolean() }),
       { kind: "mutation", auth: "admin" }
     ),
-    /** Rebuild the broker for a profile slot in place (re-dial source). */
     restartProfile: method(
       z.object({
         deviceId: z.number().int().nonnegative(),
@@ -1302,24 +1280,28 @@ const streamBrokerCapability = {
       z.object({ success: z.boolean() }),
       { kind: "mutation", auth: "admin" }
     ),
-    // ── Stream URLs ──────────────────────────────────────────────────
     getStreamUrl: method(
       z.object({ streamId: z.string(), format: StreamFormatSchema }),
       z.object({ url: z.string() })
     ),
-    // ── In-process broker access ─────────────────────────────────────
     /**
-     * Return the live IStreamBroker instance for a given brokerId. Same
-     * LOCAL-ONLY contract as before: callers (pipeline-runner) must be
-     * co-located. BrokerId is `${deviceId}/${camStreamId}` — profile
-     * lookup goes through `assignments` if a caller starts from a
-     * profile.
+     * Shared codec-targeted stream API — see Task #184.
+     * Resolution order: source-select → HW transcode → libx264/libx265.
      */
+    getStreamWithCodec: method(
+      GetStreamWithCodecInputSchema,
+      RtpSourceSchema,
+      { kind: "mutation", auth: "admin" }
+    ),
+    releaseStreamWithCodec: method(
+      z.object({ pipelineKey: z.string() }),
+      z.object({ released: z.boolean(), refcount: z.number().int().nonnegative() }),
+      { kind: "mutation", auth: "admin" }
+    ),
     getBroker: method(
       z.object({ brokerId: z.string() }),
       z.custom()
     ),
-    // ── Pre-buffer ───────────────────────────────────────────────────
     setPreBufferDuration: method(
       z.object({ brokerId: z.string(), seconds: z.number().min(0).max(30) }),
       z.void(),
@@ -1329,7 +1311,6 @@ const streamBrokerCapability = {
       z.object({ brokerId: z.string() }),
       z.object({ configuredSec: z.number(), bufferedMs: z.number(), packetCount: z.number() })
     ),
-    // ── RTSP restream ────────────────────────────────────────────────
     getRtspPort: method(z.void(), z.number()),
     getAllRtspEntries: method(
       z.object({ hostname: z.string().optional() }),
@@ -1355,37 +1336,15 @@ const streamBrokerCapability = {
     )
   },
   events: {
-    /**
-     * Emitted when a profile starts consuming a push-kind cam stream.
-     * Push-kind providers (e.g. Reolink Baichuan native streams)
-     * subscribe and begin emitting packets only on demand — battery
-     * cams stay asleep until someone actually watches.
-     */
     onCamStreamDemand: event(z.object({
       deviceId: z.number().int().nonnegative(),
       camStreamId: z.string(),
       profile: CamProfileSchema
     })),
-    /**
-     * Emitted when the last profile consuming a push-kind cam stream
-     * releases it. Providers tear down upstream connections on this
-     * signal.
-     */
     onCamStreamIdle: event(z.object({
       deviceId: z.number().int().nonnegative(),
       camStreamId: z.string()
     })),
-    /**
-     * Emitted by a broker that failed to dial a managed-loopback
-     * source (today: `pull-rfc4571`). The publisher's transport (e.g.
-     * the Reolink lib's RFC 4571 TCP server) idle-tears-down after
-     * ~15s with no clients and may rebind to a different port on
-     * recreate, leaving the URL the broker has cached stale. The owning
-     * camera provider re-runs its publish pipeline on receipt — that
-     * call self-heals the loopback server (`ensureRfc4571Server`) and
-     * `publishCameraStream` propagates the fresh URL back into the
-     * broker's source resolver.
-     */
     onRequestStreamSourceRefresh: event(z.object({
       deviceId: z.number().int().nonnegative(),
       camStreamId: z.string(),
@@ -3659,14 +3618,16 @@ const logDestinationCapability = {
     )
   }
 };
+const StaticDirOutputSchema = z.object({ staticDir: z.string() });
+const VersionOutputSchema = z.object({ version: z.string() });
 const adminUiCapability = {
   name: "admin-ui",
   scope: "system",
   mode: "singleton",
   internal: true,
   methods: {
-    getStaticDir: method(z.void(), z.string()),
-    getVersion: method(z.void(), z.string())
+    getStaticDir: method(z.void(), StaticDirOutputSchema),
+    getVersion: method(z.void(), VersionOutputSchema)
   }
 };
 const SsoBridgeClaimsSchema = z.object({
@@ -3675,7 +3636,16 @@ const SsoBridgeClaimsSchema = z.object({
   isAdmin: z.boolean(),
   provider: z.string(),
   email: z.string().optional(),
-  displayName: z.string().optional()
+  displayName: z.string().optional(),
+  /**
+   * Public HTTPS URL of the hub that issued this token. Used by
+   * cloud-mode OAuth proxies (Alexa Smart Home Lambda, future Google
+   * Home Lambda) to route a request back to the originating hub
+   * without holding routing state of their own. The Lambda decodes the
+   * JWT WITHOUT verifying the signature — the hub re-verifies on every
+   * inbound call so trust still rests with the signing hub.
+   */
+  hubUrl: z.string().optional()
 });
 const ssoBridgeCapability = {
   name: "sso-bridge",
@@ -3757,7 +3727,7 @@ const userPasskeysCapability = {
     )
   }
 };
-const EmailAddressSchema = z.string().email();
+const EmailAddressSchema = z.email();
 const SendEmailInputSchema = z.object({
   to: z.union([EmailAddressSchema, z.array(EmailAddressSchema).min(1)]),
   cc: z.array(EmailAddressSchema).optional(),
@@ -3795,6 +3765,7 @@ const smtpProviderCapability = {
   scope: "system",
   mode: "collection",
   internal: true,
+  providerKind: "email",
   methods: {
     sendEmail: method(
       SendEmailInputSchema,
@@ -3815,204 +3786,125 @@ const smtpProviderCapability = {
     )
   }
 };
-const QosSchema = z.union([z.literal(0), z.literal(1), z.literal(2)]);
-const PublishInputSchema = z.object({
-  topic: z.string(),
-  /** UTF-8 payload. Binary payloads must be base64-encoded by the caller. */
-  payload: z.string(),
-  qos: QosSchema.default(0),
-  retain: z.boolean().default(false)
-});
-const SubscribeInputSchema = z.object({
-  /** MQTT topic filter (supports `+` single-level and `#` multi-level wildcards). */
-  topic: z.string(),
-  qos: QosSchema.default(0),
+const BrokerKindSchema = z.enum(["external", "embedded"]);
+const BrokerStatusSchema = z.enum([
+  "connected",
+  "disconnected",
+  "auth-failed",
+  "unreachable",
+  "tls-error"
+]);
+const BrokerInfoSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  url: z.string(),
+  kind: BrokerKindSchema,
+  status: BrokerStatusSchema,
+  latencyMs: z.number().nullable(),
+  error: z.string().optional(),
+  /** Embedded brokers only: number of MQTT clients currently connected. */
+  connectedClients: z.number().int().nonnegative().optional(),
+  /** Epoch ms of the last live probe (external) or aedes snapshot (embedded). */
+  lastCheckedAt: z.number().optional()
+});
+const BrokerConnectionDetailsSchema = z.object({
+  url: z.string(),
+  username: z.string().optional(),
+  password: z.string().optional(),
   /**
-   * Caller-supplied owner tag. Useful for debugging + the
-   * `listSubscriptions` admin view ("which consumer owns this?").
-   * When omitted, the addon synthesizes one from the caller's addon id.
+   * Suggested prefix for `clientId`. Each consumer should suffix this
+   * with its own discriminator (addon id, instance id) so reconnects
+   * don't kick each other off (MQTT spec: clientId must be unique per
+   * broker).
    */
-  owner: z.string().optional()
+  clientIdPrefix: z.string().optional()
 });
-const SubscribeResultSchema = z.object({
-  success: z.literal(true),
-  /** Server-generated subscription id. Pass to `unsubscribe` to release. */
-  subscriptionId: z.string()
+const AddBrokerInputSchema = z.object({
+  name: z.string().min(1),
+  url: z.string().regex(/^(mqtt|mqtts|ws|wss):\/\//, "URL must start with mqtt(s):// or ws(s)://"),
+  username: z.string().optional(),
+  password: z.string().optional(),
+  clientIdPrefix: z.string().optional()
 });
-const UnsubscribeInputSchema = z.object({
-  /** Subscription id from `subscribe`. */
-  subscriptionId: z.string()
+const AddBrokerResultSchema = z.object({
+  id: z.string()
 });
-const MqttStatusSchema = z.object({
-  /** True iff the addon has an active connection to the broker. */
-  connected: z.boolean(),
-  /** Operator-visible host string (e.g. `mqtt://broker.example:1883`). */
-  brokerUrl: z.string(),
-  /** Active subscription count (per-owner, NOT broker-side topic count). */
-  subscriptionCount: z.number().int(),
-  /** Last error reported by the broker. */
-  error: z.string().optional(),
-  /** Last successful connection timestamp (unix ms). */
-  connectedAt: z.number().optional()
-});
-const SubscriptionInfoSchema = z.object({
-  subscriptionId: z.string(),
-  topic: z.string(),
-  qos: QosSchema,
-  owner: z.string(),
-  /** When this individual subscription was created. */
-  createdAt: z.number()
+const IdInputSchema = z.object({ id: z.string() });
+const TestResultSchema = z.discriminatedUnion("ok", [
+  z.object({ ok: z.literal(true), latencyMs: z.number() }),
+  z.object({ ok: z.literal(false), error: z.string() })
+]);
+const StartEmbeddedInputSchema = z.object({
+  port: z.number().int().min(1).max(65535).default(1883),
+  /** Allow anonymous connect (no username/password). Default: false. */
+  allowAnonymous: z.boolean().default(false),
+  /** Optional shared username/password for clients. */
+  username: z.string().optional(),
+  password: z.string().optional()
+});
+const StartEmbeddedResultSchema = z.object({
+  id: z.string(),
+  url: z.string()
 });
-const mqttProviderCapability = {
-  name: "mqtt-provider",
+const StatusSchema = z.object({
+  brokerCount: z.number(),
+  embeddedRunning: z.boolean()
+});
+const mqttBrokerCapability = {
+  name: "mqtt-broker",
   scope: "system",
   mode: "collection",
-  internal: true,
+  providerKind: "broker",
+  status: { schema: StatusSchema, kind: "poll" },
   methods: {
-    /** Publish a message. Lazy-opens the connection if not yet active. */
-    publish: method(
-      PublishInputSchema,
-      z.object({ success: z.literal(true) }),
-      { kind: "mutation", auth: "admin", access: "create" }
-    ),
-    /**
-     * Subscribe to a topic. Returns a `subscriptionId` to pass to
-     * `unsubscribe`. The addon refcounts broker subscriptions —
-     * multiple consumers on the same topic share one upstream sub.
-     * Messages arrive on `mqtt.message` events with `subscriptionIds[]`
-     * listing which subscriptions matched.
-     */
-    subscribe: method(
-      SubscribeInputSchema,
-      SubscribeResultSchema,
-      { kind: "mutation", auth: "admin", access: "create" }
-    ),
-    /** Release a specific subscription. Tears down the broker sub
-     *  only when the last owner releases. Idempotent. */
-    unsubscribe: method(
-      UnsubscribeInputSchema,
-      z.object({ success: z.literal(true) }),
-      { kind: "mutation", auth: "admin", access: "delete" }
-    ),
-    /** List active per-owner subscriptions on this provider. */
-    listSubscriptions: method(
-      z.void(),
-      z.array(SubscriptionInfoSchema),
-      { auth: "admin" }
-    ),
-    getStatus: method(
-      z.void(),
-      MqttStatusSchema,
-      { auth: "admin" }
-    )
+    listBrokers: method(z.void(), z.array(BrokerInfoSchema)),
+    getBrokerConfig: method(IdInputSchema, BrokerConnectionDetailsSchema),
+    addBroker: method(AddBrokerInputSchema, AddBrokerResultSchema, { kind: "mutation" }),
+    removeBroker: method(IdInputSchema, z.void(), { kind: "mutation" }),
+    testConnection: method(IdInputSchema, TestResultSchema, { kind: "mutation" }),
+    startEmbeddedBroker: method(StartEmbeddedInputSchema, StartEmbeddedResultSchema, { kind: "mutation" }),
+    stopEmbeddedBroker: method(IdInputSchema, z.void(), { kind: "mutation" }),
+    getStatus: method(z.void(), StatusSchema)
   }
 };
-const HaServiceCallSchema = z.object({
-  /** HA domain (e.g. `light`, `switch`, `notify`). */
-  domain: z.string(),
-  /** HA service (e.g. `turn_on`, `toggle`). */
-  service: z.string(),
-  /** Service-specific data payload (e.g. `{entity_id: 'light.kitchen', brightness: 200}`). */
-  serviceData: z.record(z.string(), z.unknown()).optional(),
-  /** Optional target spec (entity_id / device_id / area_id). */
-  target: z.record(z.string(), z.unknown()).optional()
-});
-const HaStateSchema = z.object({
-  entity_id: z.string(),
-  state: z.string(),
-  attributes: z.record(z.string(), z.unknown()).default({}),
-  last_changed: z.string().optional(),
-  last_updated: z.string().optional()
+const LinkStateSchema = z.enum(["unlinked", "linked", "error"]);
+const DeviceExportStatusSchema = z.object({
+  linkState: LinkStateSchema,
+  exposedDeviceCount: z.number(),
+  error: z.string().optional()
 });
-const HaStatusSchema = z.object({
-  connected: z.boolean(),
-  host: z.string(),
-  /** Active per-owner subscription count. */
-  subscriptionCount: z.number().int(),
-  /** Last error reported by the WebSocket. */
-  error: z.string().optional(),
-  /** HA version reported during the auth handshake, when reachable. */
-  haVersion: z.string().optional(),
-  connectedAt: z.number().optional()
+const DeviceKindSchema = z.string();
+const ExposedDeviceSchema = z.object({
+  deviceId: z.string(),
+  exposedAs: z.string().optional(),
+  capabilities: z.array(z.string()).optional()
 });
-const HaSubscribeInputSchema = z.object({
-  /**
-   * Specific HA event type to subscribe to (`state_changed`,
-   * `service_called`, etc.). Empty string = all events (firehose —
-   * only for debugging).
-   */
-  eventType: z.string().optional(),
-  /** Caller-supplied tag for listSubscriptions debugging. */
-  owner: z.string().optional()
-});
-const HaSubscribeResultSchema = z.object({
-  success: z.literal(true),
-  subscriptionId: z.string()
-});
-const HaUnsubscribeInputSchema = z.object({
-  subscriptionId: z.string()
-});
-const HaSubscriptionInfoSchema = z.object({
-  subscriptionId: z.string(),
-  /** Empty string when subscribed to ALL events. */
-  eventType: z.string(),
-  owner: z.string(),
-  createdAt: z.number()
+const ExposeInputSchema = z.object({
+  deviceId: z.string(),
+  capabilities: z.array(z.string()).optional()
 });
-const homeAssistantCapability = {
-  name: "home-assistant",
+const UnexposeInputSchema = z.object({ deviceId: z.string() });
+const deviceExportCapability = {
+  name: "device-export",
   scope: "system",
   mode: "collection",
-  internal: true,
+  providerKind: "device-export",
+  status: { schema: DeviceExportStatusSchema, kind: "poll" },
+  /**
+   * Each export provider contributes its own per-device "Export" panel
+   * (enabled toggle, preferred stream, addon-specific knobs like the
+   * HA-MQTT discovery prefix). The three framework methods
+   * `getDeviceSettingsContribution` / `getDeviceLiveContribution` /
+   * `applyDeviceSettingsPatch` are auto-injected on the provider
+   * interface and routed to the device-details aggregator.
+   */
+  exposesDeviceSettings: true,
   methods: {
-    /**
-     * Subscribe to HA events. Returns a `subscriptionId` to pass to
-     * `unsubscribeEvents`. The addon refcounts upstream subscriptions
-     * so multiple consumers share one HA-side event stream.
-     * Events arrive on the kernel bus under `home-assistant.event`
-     * with `subscriptionIds[]` listing which subs matched.
-     */
-    subscribeEvents: method(
-      HaSubscribeInputSchema,
-      HaSubscribeResultSchema,
-      { kind: "mutation", auth: "admin", access: "create" }
-    ),
-    /** Release a specific subscription. Tears down the upstream sub
-     *  only when the last owner releases. Idempotent. */
-    unsubscribeEvents: method(
-      HaUnsubscribeInputSchema,
-      z.object({ success: z.literal(true) }),
-      { kind: "mutation", auth: "admin", access: "delete" }
-    ),
-    /**
-     * Call an HA service (turn light on, run a script, etc.). Returns
-     * the HA response object — usually `{context, response: ...}`.
-     */
-    callService: method(
-      HaServiceCallSchema,
-      z.object({ result: z.unknown() }),
-      { kind: "mutation", auth: "admin", access: "create" }
-    ),
-    /** Fetch all entity states. Cheap snapshot — HA returns the full
-     *  state registry on every call. */
-    getStates: method(
-      z.void(),
-      z.array(HaStateSchema).readonly(),
-      { auth: "admin" }
-    ),
-    /** Fetch a single entity's current state. `null` when not found. */
-    getState: method(
-      z.object({ entityId: z.string() }),
-      HaStateSchema.nullable(),
-      { auth: "admin" }
-    ),
-    /** List active per-owner subscriptions. */
-    listSubscriptions: method(
-      z.void(),
-      z.array(HaSubscriptionInfoSchema).readonly(),
-      { auth: "admin" }
-    ),
-    getStatus: method(z.void(), HaStatusSchema, { auth: "admin" })
+    getStatus: method(z.void(), DeviceExportStatusSchema),
+    listSupportedDeviceKinds: method(z.void(), z.array(DeviceKindSchema)),
+    listExposedDevices: method(z.void(), z.array(ExposedDeviceSchema)),
+    exposeDevice: method(ExposeInputSchema, z.void(), { kind: "mutation" }),
+    unexposeDevice: method(UnexposeInputSchema, z.void(), { kind: "mutation" })
   }
 };
 const AddonPageDeclarationSchema$1 = z.object({
@@ -4414,6 +4306,29 @@ const webrtcSessionCapability = {
       z.object({ sessionId: z.string(), sdpOffer: z.string() }),
       { kind: "mutation" }
     ),
+    /**
+     * Accept a CLIENT-generated SDP offer and return the server's
+     * SDP answer. Mirrors the WHEP / Alexa
+     * `Alexa.RTCSessionController.InitiateSessionWithOffer` direction
+     * (client offers, server answers) — the dual of `createSession`,
+     * which has the server offer first.
+     *
+     * `target` defaults to the device's adaptive selection when
+     * omitted; an optional `sessionId` lets the client provide its
+     * own correlation id (Alexa supplies one in the directive
+     * payload). The returned `sessionId` is whatever the server uses
+     * to track the session and accepts via `closeSession`.
+     */
+    handleOffer: method(
+      z.object({
+        deviceId: z.number().int().nonnegative(),
+        target: WebrtcStreamTargetSchema.optional(),
+        sdpOffer: z.string(),
+        sessionId: z.string().optional()
+      }),
+      z.object({ sessionId: z.string(), sdpAnswer: z.string() }),
+      { kind: "mutation" }
+    ),
     handleAnswer: method(
       z.object({
         deviceId: z.number().int().nonnegative(),
@@ -5053,12 +4968,12 @@ const audioCodecCapability = {
 };
 const EmbeddingResultSchema = z.object({
   embedding: z.array(z.number()),
-  dimensions: z.number()
+  inferenceMs: z.number()
 });
 const EmbeddingInfoSchema = z.object({
   modelId: z.string(),
-  dimensions: z.number(),
-  inputSize: z.number()
+  embeddingDim: z.number(),
+  ready: z.boolean()
 });
 const embeddingEncoderCapability = {
   name: "embedding-encoder",
@@ -5793,16 +5708,36 @@ const NetworkAccessStatusSchema = z.object({
   endpoint: NetworkEndpointSchema.nullable(),
   error: z.string().optional()
 });
+const NetworkEndpointEntrySchema = NetworkEndpointSchema.extend({
+  /**
+   * Stable id within the provider — typically `<mode>-<sourcePort>` so
+   * the orchestrator can dedupe across `listEndpoints` polls.
+   */
+  id: z.string(),
+  /** Operator-facing label (mirrors `MeshEndpoint.label`). */
+  label: z.string(),
+  /** Optional provider-specific mode tag, used for icon/colour in admin UI. */
+  mode: z.string().optional(),
+  /** Originating local port the ingress fronts (informational). */
+  sourcePort: z.number().optional()
+});
 const networkAccessCapability = {
   name: "network-access",
   scope: "system",
   mode: "collection",
   internal: true,
+  providerKind: "ingress",
   methods: {
     start: method(z.void(), NetworkEndpointSchema, { kind: "mutation" }),
     stop: method(z.void(), z.void(), { kind: "mutation" }),
     getEndpoint: method(z.void(), NetworkEndpointSchema.nullable()),
-    getStatus: method(z.void(), NetworkAccessStatusSchema)
+    getStatus: method(z.void(), NetworkAccessStatusSchema),
+    /**
+     * Enumerate every active ingress entry. Default implementation (when
+     * the provider omits this method) is derived from `getEndpoint()` —
+     * see the remote-access orchestrator for the fallback path.
+     */
+    listEndpoints: method(z.void(), z.array(NetworkEndpointEntrySchema).readonly())
   }
 };
 const RemoteAccessEndpointSchema = z.object({
@@ -6006,20 +5941,59 @@ const notificationOutputCapability = {
     )
   }
 };
+const NotificationRuleConditionsSchema = z.object({
+  deviceIds: z.array(z.number()).readonly().optional(),
+  classNames: z.array(z.string()).readonly().optional(),
+  zoneIds: z.array(z.string()).readonly().optional(),
+  minConfidence: z.number().optional(),
+  source: z.enum(["pipeline", "onboard", "any"]).optional(),
+  schedule: z.object({
+    days: z.array(z.number()).readonly(),
+    startHour: z.number(),
+    endHour: z.number()
+  }).optional(),
+  cooldownSeconds: z.number().optional(),
+  minDwellSeconds: z.number().optional()
+});
+const NotificationRuleTemplateSchema = z.object({
+  title: z.string(),
+  body: z.string(),
+  imageMode: z.enum(["crop", "annotated", "full", "none"])
+});
 const NotificationRuleSchema = z.object({
   id: z.string(),
   name: z.string(),
   enabled: z.boolean(),
-  conditions: z.record(z.string(), z.unknown()),
-  actions: z.array(z.record(z.string(), z.unknown()))
+  eventTypes: z.array(z.string()).readonly(),
+  conditions: NotificationRuleConditionsSchema,
+  outputs: z.array(z.string()).readonly(),
+  template: NotificationRuleTemplateSchema.optional(),
+  priority: z.enum(["low", "normal", "high", "critical"])
+});
+const NotificationTestResultSchema = z.object({
+  ruleId: z.string(),
+  eventId: z.string(),
+  timestamp: z.number(),
+  wouldFire: z.boolean(),
+  reason: z.string().optional()
 });
 const NotificationHistoryEntrySchema = z.object({
   id: z.string(),
   ruleId: z.string(),
+  ruleName: z.string(),
+  eventId: z.string(),
   timestamp: z.number(),
-  deviceId: z.number().optional(),
+  outputs: z.array(z.string()).readonly(),
   success: z.boolean(),
-  error: z.string().optional()
+  error: z.string().optional(),
+  deviceId: z.number().optional()
+});
+const NotificationHistoryFilterSchema = z.object({
+  ruleId: z.string().optional(),
+  deviceId: z.number().optional(),
+  from: z.number().optional(),
+  to: z.number().optional(),
+  limit: z.number().optional()
 });
 const advancedNotifierCapability = {
   name: "advanced-notifier",
@@ -6027,17 +6001,28 @@ const advancedNotifierCapability = {
   mode: "singleton",
   internal: true,
   methods: {
-    getRules: method(z.void(), z.array(NotificationRuleSchema).readonly()),
-    upsertRule: method(NotificationRuleSchema, z.void(), { kind: "mutation" }),
-    deleteRule: method(z.object({ ruleId: z.string() }), z.void(), { kind: "mutation" }),
+    getRules: method(
+      z.void(),
+      z.object({ rules: z.array(NotificationRuleSchema).readonly() })
+    ),
+    upsertRule: method(
+      z.object({ rule: NotificationRuleSchema }),
+      z.object({ success: z.literal(true) }),
+      { kind: "mutation" }
+    ),
+    deleteRule: method(
+      z.object({ ruleId: z.string() }),
+      z.object({ success: z.literal(true) }),
+      { kind: "mutation" }
+    ),
     testRule: method(
       z.object({ ruleId: z.string(), lookbackMinutes: z.number() }),
-      z.array(z.record(z.string(), z.unknown())),
+      z.object({ results: z.array(NotificationTestResultSchema).readonly() }),
       { kind: "mutation" }
     ),
     getHistory: method(
-      z.object({ ruleId: z.string().optional(), limit: z.number().optional() }),
-      z.array(NotificationHistoryEntrySchema)
+      z.object({ filter: NotificationHistoryFilterSchema.optional() }),
+      z.object({ entries: z.array(NotificationHistoryEntrySchema).readonly() })
     )
   }
 };
@@ -7059,6 +7044,47 @@ const intercomCapability = {
       z.object({ deviceId: z.number(), sessionId: z.string() }),
       z.void(),
       { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Open a raw-PCM talk session (no WebRTC SDP plumbing). Used by
+     * non-WebRTC consumers (HomeKit export, Alexa raw audio, test
+     * harnesses) that already have decoded PCM frames and just need a
+     * direct path onto the camera's talk channel. Mutually exclusive
+     * with `startSession` (an active WebRTC session must be stopped
+     * before a raw-PCM session can be opened on the same device, and
+     * vice versa).
+     */
+    startTalkSession: method(
+      z.object({ deviceId: z.number() }),
+      z.object({ sessionId: z.string() }),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Push a chunk of PCM s16le mono onto the active raw-PCM talk
+     * session. Frames are encoded to the firmware's expected codec
+     * (Reolink: IMA ADPCM @ camera sample rate; Hikvision: G.711 @
+     * 8 kHz) inside the provider — callers must resample upstream to
+     * the rate the camera negotiated (typical: 16 kHz Reolink,
+     * 8 kHz Hikvision). PCM is shipped base64-encoded so the payload
+     * survives JSON serialization across tRPC.
+     */
+    pushTalkPcm: method(
+      z.object({
+        deviceId: z.number(),
+        /** PCM frames as little-endian s16, mono. Base64-encoded so
+         *  the payload survives tRPC JSON serialization. */
+        pcmBase64: z.string(),
+        /** Sequence number for ordering / dropping out-of-order frames. */
+        sequenceNumber: z.number().int()
+      }),
+      z.object({ accepted: z.boolean() }),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /** Close the raw-PCM talk session. Idempotent. */
+    endTalkSession: method(
+      z.object({ deviceId: z.number() }),
+      z.void(),
+      { kind: "mutation", auth: "admin" }
     )
   },
   events: {
@@ -7134,6 +7160,33 @@ const HwAccelBackendInputSchema = z.enum([
 const HwAccelResolutionSchema = z.object({
   preferred: z.array(z.string()).readonly()
 });
+const HardwareEncoderIdSchema = z.enum([
+  "h264_videotoolbox",
+  "hevc_videotoolbox",
+  "h264_vaapi",
+  "hevc_vaapi",
+  "h264_nvenc",
+  "hevc_nvenc",
+  "h264_qsv",
+  "hevc_qsv",
+  "h264_amf",
+  "hevc_amf",
+  "libx264",
+  "libx265"
+]);
+const HardwareEncoderProbeSchema = z.object({
+  encoder: HardwareEncoderIdSchema,
+  codec: z.enum(["H264", "H265"]),
+  family: z.enum(["videotoolbox", "vaapi", "nvenc", "qsv", "amf", "software"]),
+  available: z.boolean(),
+  reason: z.string().optional()
+});
+const HardwareEncodersSchema = z.object({
+  encoders: z.array(HardwareEncoderProbeSchema).readonly(),
+  defaultH264: HardwareEncoderIdSchema,
+  defaultH265: HardwareEncoderIdSchema,
+  probedAt: z.number()
+});
 const HardwarePlatformSchema = z.enum(["darwin", "linux", "win32"]);
 const HardwareArchSchema = z.enum(["arm64", "x64"]);
 const GpuInfoSchema = z.object({
@@ -7187,41 +7240,24 @@ const platformProbeCapability = {
   scope: "system",
   mode: "singleton",
   methods: {
-    /** Return cached hardware + scored backends for this node. */
-    getCapabilities: method(
-      z.void(),
-      PlatformCapabilitiesSchema
-    ),
-    /** Convenience getter — hardware only. */
-    getHardware: method(
-      z.void(),
-      HardwareInfoSchema
-    ),
-    /**
-     * Resolve the best (model, runtime, backend, format) for a given list
-     * of requirements, using this node's scored backends as the candidate
-     * pool. Always returns a config — falls back to CPU when no preferred
-     * backend matches.
-     */
+    getCapabilities: method(z.void(), PlatformCapabilitiesSchema),
+    getHardware: method(z.void(), HardwareInfoSchema),
     resolveInferenceConfig: method(
-      z.object({
-        requirements: z.array(ModelRequirementSchema).readonly()
-      }),
+      z.object({ requirements: z.array(ModelRequirementSchema).readonly() }),
       ResolvedInferenceConfigSchema
     ),
-    /**
-     * Resolve the ordered HW acceleration backend list for this node.
-     * Pass `prefer` to hint a specific backend; pass `null` or omit
-     * for auto-detection. Replaces the legacy `$hwaccel.resolve`
-     * Moleculer action — cap routing handles per-node dispatch via
-     * `nodeId`.
-     */
     resolveHwAccel: method(
-      z.object({
-        prefer: HwAccelBackendInputSchema,
-        nodeId: z.string().optional()
-      }),
+      z.object({ prefer: HwAccelBackendInputSchema, nodeId: z.string().optional() }),
       HwAccelResolutionSchema
+    ),
+    /**
+     * Hardware-encoder probe — see Task #185. Cached after first call.
+     */
+    getHardwareEncoders: method(z.void(), HardwareEncodersSchema),
+    refreshHardwareEncoders: method(
+      z.void(),
+      HardwareEncodersSchema,
+      { kind: "mutation", auth: "admin" }
     )
   }
 };
@@ -7433,7 +7469,9 @@ const MeshPeerSchema = z.object({
   id: z.string(),
   /** Hostname / device name as shown in the mesh dashboard. */
   hostname: z.string(),
-  /** Mesh IP(s). Multiple when the peer is dual-stacked. */
+  /** MagicDNS / mesh DNS name (e.g. `peer-foo.tail-abc.ts.net`). Empty when the provider doesn't support DNS or peer-side resolution is disabled. */
+  magicDns: z.string(),
+  /** Mesh IPv4 / IPv6 addresses combined. Multiple when dual-stacked. */
   addresses: z.array(z.string()).readonly(),
   /** Operating system reported by the peer (informational). */
   os: z.string().optional(),
@@ -7442,7 +7480,32 @@ const MeshPeerSchema = z.object({
   /** Last-seen timestamp (epoch ms). 0 when never seen. */
   lastSeenMs: z.number(),
   /** True for the row representing the current host. */
-  isSelf: z.boolean()
+  isSelf: z.boolean(),
+  /**
+   * Connection mode to this peer:
+   *   - `direct`: NAT-traversed P2P (UDP punched)
+   *   - `relay`: traffic relayed through provider edge (Tailscale DERP)
+   *   - `idle`: peer reachable but no recent traffic / handshake
+   */
+  connection: z.enum(["direct", "relay", "idle"]),
+  /** DERP region / relay node identifier when `connection: relay`. Null otherwise. */
+  relay: z.string().nullable(),
+  /** Last successful handshake timestamp (epoch ms). 0 when never. */
+  lastHandshakeMs: z.number(),
+  /** Bytes received from this peer since the daemon started. */
+  rxBytes: z.number(),
+  /** Bytes transmitted to this peer since the daemon started. */
+  txBytes: z.number(),
+  /** ACL tags this peer carries (e.g. `["tag:server"]`). Empty when human-owned. */
+  tags: z.array(z.string()).readonly(),
+  /** True when the peer advertises itself as an exit-node candidate. */
+  exitNodeOption: z.boolean(),
+  /** Subnet routes the peer advertises (e.g. `["192.168.1.0/24"]`). */
+  advertisedRoutes: z.array(z.string()).readonly(),
+  /** Owner account login (e.g. `foo@example.com`). Null for tagged peers. */
+  userLogin: z.string().nullable(),
+  /** Pre-auth key / machine-key expiry (epoch ms). Null when keys don't expire. */
+  keyExpiry: z.number().nullable()
 });
 const MeshStatusSchema = z.object({
   /** True when the host is joined and the daemon reports healthy. */
@@ -7456,27 +7519,44 @@ const MeshStatusSchema = z.object({
   /** Every endpoint this provider exposes for the current host. */
   endpoints: z.array(MeshEndpointSchema$1).readonly(),
   /** Last error from the daemon, when not joined. */
-  error: z.string().optional()
-});
-const PublicIngressConfigSchema = z.object({
-  /** Whether the provider should expose CamStack via its public
-   *  ingress (Tailscale Funnel, etc.). */
-  enabled: z.boolean(),
-  /** Local port to forward. Auto-detected from the hub HTTP port
-   *  when omitted. */
-  port: z.number().int().min(1).max(65535).optional()
-});
-const MeshIngressConfigSchema = z.object({
-  /** Whether the provider should expose CamStack inside the mesh
-   *  via HTTPS (Tailscale Serve, etc.) instead of just raw IP. */
-  enabled: z.boolean(),
-  /** Local port to forward. Auto-detected when omitted. */
-  port: z.number().int().min(1).max(65535).optional()
+  error: z.string().optional(),
+  // ── Account / tenant identity (generic across providers) ────────
+  /**
+   * Tenant / tailnet / network display name (Tailscale = tailnet
+   * domain, Headscale = namespace, ZeroTier = network name). Empty
+   * pre-join. Per-provider semantics, common slot.
+   */
+  tenantName: z.string(),
+  /**
+   * Mesh DNS suffix when the provider exposes peer-resolvable DNS
+   * (Tailscale MagicDNS, Headscale MagicDNS, …). Empty when the
+   * provider doesn't ship DNS (e.g. ZeroTier).
+   */
+  magicDnsSuffix: z.string(),
+  /**
+   * Authenticated user / account login bound to this host. Null when
+   * the provider authenticates with a long-lived network token rather
+   * than a user account (e.g. ZeroTier API token).
+   */
+  userLogin: z.string().nullable(),
+  /**
+   * Provider control-plane URL (Tailscale SaaS `https://login.tailscale.com`,
+   * self-hosted Headscale, ZeroTier Central, …). Empty when not
+   * applicable (rare).
+   */
+  controlPlaneUrl: z.string(),
+  /**
+   * Machine-key / node-key expiry (epoch ms). Null when the provider
+   * doesn't rotate keys for the bound host. Operator-facing surface
+   * for "your access expires on …" banners.
+   */
+  keyExpiry: z.number().nullable()
 });
 const meshNetworkCapability = {
   name: "mesh-network",
   scope: "system",
   mode: "collection",
+  providerKind: "mesh",
   methods: {
     /** Return the current join state + endpoints + peer count. Cheap
      *  poll-target — admin UI hits this every few seconds. */
@@ -7498,35 +7578,54 @@ const meshNetworkCapability = {
       z.object({ joined: z.literal(true) }),
       { kind: "mutation" }
     ),
+    /**
+     * Start an interactive browser-redirect login flow.
+     *
+     * The provider spawns its daemon's join command without a pre-auth
+     * key, captures the verification URL the daemon prints, and returns
+     * it. The admin UI opens the URL in a new tab; the user completes
+     * authentication in the provider's web console and the background
+     * process self-terminates. The caller then polls `getStatus()` until
+     * `joined: true`.
+     *
+     * Mirrors the `tailscale up` (no `--auth-key`) flow.
+     */
+    startLogin: method(
+      z.object({
+        /** Optional hostname override the host should advertise once joined. */
+        hostname: z.string().optional()
+      }),
+      z.object({
+        /** Authentication URL the operator should open in a browser. */
+        loginUrl: z.string()
+      }),
+      { kind: "mutation" }
+    ),
     /** Leave the mesh. After this the meshIp/magicDnsHostname/etc.
-     *  vanish until the next `join`. */
+     *  vanish until the next `join`. The bound account stays — a
+     *  subsequent `join` reuses it without prompting for a new login. */
     leave: method(
       z.void(),
       z.object({ left: z.literal(true) }),
       { kind: "mutation" }
     ),
-    /** Enumerate every peer the daemon currently knows about. */
-    listPeers: method(z.void(), z.object({
-      peers: z.array(MeshPeerSchema).readonly()
-    })),
-    /**
-     * Toggle the public ingress (e.g. Tailscale Funnel) that maps a
-     * local port to the open internet via the provider's edge. Idempotent.
-     */
-    setPublicIngress: method(
-      PublicIngressConfigSchema,
-      z.object({ success: z.literal(true) }),
-      { kind: "mutation" }
-    ),
     /**
-     * Toggle the in-mesh HTTPS ingress (e.g. Tailscale Serve) so peers
-     * inside the mesh hit a valid TLS endpoint instead of the raw IP.
+     * Sign out of the mesh account entirely. Distinct from `leave`:
+     * `leave` only takes the host off-mesh (`tailscale down`) while the
+     * account binding survives, so the next `join` reconnects silently.
+     * `logout` (`tailscale logout`) wipes the daemon's stored
+     * credentials — the next `startLogin` MUST go through a fresh
+     * browser-redirect flow to bind a new account.
      */
-    setMeshIngress: method(
-      MeshIngressConfigSchema,
-      z.object({ success: z.literal(true) }),
+    logout: method(
+      z.void(),
+      z.object({ loggedOut: z.literal(true) }),
       { kind: "mutation" }
     ),
+    /** Enumerate every peer the daemon currently knows about. */
+    listPeers: method(z.void(), z.object({
+      peers: z.array(MeshPeerSchema).readonly()
+    })),
     /**
      * Probe the mesh daemon / API for a sanity check WITHOUT joining.
      * Operator-facing "test connection" button: validates the auth key
@@ -7556,6 +7655,15 @@ const meshNetworkCapability = {
       }),
       { kind: "mutation" }
     )
+    // Provider-specific runtime knobs (accept-routes / advertise-routes /
+    // shields-up / ssh / exit-node, …) live on the addon's own
+    // `getSettingsUISchema` (form-builder), NOT here. Different mesh
+    // providers (Tailscale, Headscale, ZeroTier, Nebula) have very
+    // different config surfaces — picking one shape and forcing all
+    // implementations to honour it would either lose options or
+    // misrepresent them. The Mesh page renders the addon's settings
+    // schema as a "Settings" tab next to the generic Status / Peers
+    // tabs driven by this cap.
   }
 };
 const MeshEndpointSchema = z.object({
@@ -7583,7 +7691,18 @@ const MeshProviderInfoSchema = z.object({
   /** Active endpoints (mesh IP + MagicDNS + optional public Funnel). */
   endpoints: z.array(MeshEndpointSchema).readonly(),
   /** Last error reported by the provider. */
-  error: z.string().optional()
+  error: z.string().optional(),
+  // ── Generic identity fields mirrored from MeshStatus ─────────────
+  /** Tenant / tailnet / network display name. Empty pre-join. */
+  tenantName: z.string(),
+  /** Mesh DNS suffix (e.g. tailXXXX.ts.net). Empty when not configured. */
+  magicDnsSuffix: z.string(),
+  /** Authenticated user / account login. Null for token-only providers. */
+  userLogin: z.string().nullable(),
+  /** Provider control-plane URL. */
+  controlPlaneUrl: z.string(),
+  /** Machine-key expiry (epoch ms). Null when keys don't rotate. */
+  keyExpiry: z.number().nullable()
 });
 const meshOrchestratorCapability = {
   name: "mesh-orchestrator",
@@ -7609,6 +7728,43 @@ const meshOrchestratorCapability = {
       z.object({ addonId: z.string() }),
       z.object({ success: z.literal(true) }),
       { kind: "mutation" }
+    ),
+    /**
+     * Browser-redirect login flow. Forwards to the named provider's
+     * `mesh-network.startLogin` and returns the URL the daemon
+     * prints. UI opens it in a new tab, then polls `listProviders`
+     * for `joined: true`.
+     */
+    startLoginProvider: method(
+      z.object({
+        addonId: z.string(),
+        hostname: z.string().optional()
+      }),
+      z.object({ loginUrl: z.string() }),
+      { kind: "mutation" }
+    ),
+    /**
+     * Sign out of the provider's account entirely (`mesh-network.logout`).
+     * Distinct from `leaveProvider` which only takes the host off-mesh;
+     * `logoutProvider` wipes credentials so the next start requires a
+     * fresh login.
+     */
+    logoutProvider: method(
+      z.object({ addonId: z.string() }),
+      z.object({ loggedOut: z.literal(true) }),
+      { kind: "mutation" }
+    ),
+    /**
+     * Per-provider peer list. Forwards to `mesh-network.listPeers` on
+     * the addressed provider. Separate from `listProviders` because
+     * peer payloads can be large on a heavily-populated tailnet —
+     * fetch only when the operator opens the Peers tab.
+     */
+    listProviderPeers: method(
+      z.object({ addonId: z.string() }),
+      z.object({
+        peers: z.array(MeshPeerSchema).readonly()
+      })
     )
   }
 };
@@ -7696,6 +7852,13 @@ const UserSummarySchema = z.object({
   allowedProviders: z.union([z.array(z.string()), z.literal("*")]),
   allowedDevices: z.record(z.string(), z.union([z.array(z.string()), z.literal("*")])),
   scopes: z.array(TokenScopeSchema).default([]),
+  /**
+   * True iff this user has a CONFIRMED TOTP enrollment. Surfaced on
+   * `listUsers` so the admin Users page can render the "Remove 2FA"
+   * action conditionally without firing one `getTotpStatus` query per
+   * row. Self-service enrollment lives on the user's profile page.
+   */
+  totpEnabled: z.boolean().default(false),
   createdAt: z.number(),
   updatedAt: z.number()
 });
@@ -7994,6 +8157,12 @@ const NodeAddonInputSchema = z.object({
   nodeId: z.string(),
   addonId: z.string()
 });
+const NodeAddonEntrySchema = z.object({
+  id: z.string(),
+  status: z.string(),
+  version: z.string().optional(),
+  packageName: z.string().optional()
+});
 const SuccessSchema = z.object({ success: z.boolean() });
 const RestartProcessResultSchema = z.object({
   success: z.boolean(),
@@ -8054,6 +8223,19 @@ const nodesCapability = {
       z.record(z.string(), ClusterAddonStatusEntrySchema),
       { auth: "admin" }
     ),
+    /**
+     * Direct per-node addon listing — calls `$agent.status` on the target
+     * node (or returns the hub registry for `nodeId === 'hub'`) and surfaces
+     * the full addon roster including `version` + `packageName`. The
+     * `topology` cap also includes addons but strips them down to
+     * `{id, capabilities, status}` for the cluster diagram; this method
+     * is the one the per-node "Addons" tab should call.
+     */
+    getNodeAddons: method(
+      z.object({ nodeId: z.string() }),
+      z.array(NodeAddonEntrySchema).readonly(),
+      { auth: "admin" }
+    ),
     setProcessLogLevel: method(
       z.object({ nodeId: z.string(), level: z.string() }),
       SuccessSchema,
@@ -8467,12 +8649,12 @@ export {
   cameraCredentialsCapability as J,
   decoderCapability as K,
   detectionPipelineCapability as L,
-  deviceManagerCapability as M,
-  deviceOpsCapability as N,
-  deviceStateCapability as O,
-  embeddingEncoderCapability as P,
-  eventsCapability as Q,
-  homeAssistantCapability as R,
+  deviceExportCapability as M,
+  deviceManagerCapability as N,
+  deviceOpsCapability as O,
+  deviceStateCapability as P,
+  embeddingEncoderCapability as Q,
+  eventsCapability as R,
   integrationsCapability as S,
   intercomCapability as T,
   localNetworkCapability as U,
@@ -8481,9 +8663,9 @@ export {
   meshOrchestratorCapability as X,
   metricsProviderCapability as Y,
   motionDetectionCapability as Z,
-  mqttProviderCapability as _,
+  mqttBrokerCapability as _,
   zoneRulesCapability as a,
-  AudioLevelSchema as a$,
+  AudioEventSchema as a$,
   networkAccessCapability as a0,
   networkQualityCapability as a1,
   nodesCapability as a2,
@@ -8497,30 +8679,30 @@ export {
   AUDIO_MACRO_LABELS as aA,
   AccessoriesStatusSchema as aB,
   AccessoryKind as aC,
-  AddonAutoUpdateSchema as aD,
-  AddonListItemSchema as aE,
-  AddonPageDeclarationSchema as aF,
-  AddonPageInfoSchema as aG,
-  AgentLoadSummarySchema as aH,
-  AlertSchema as aI,
-  AlertSeveritySchema as aJ,
-  AlertSourceSchema as aK,
-  AlertStatusSchema as aL,
-  ApiKeyRecordSchema as aM,
-  ApiKeySummarySchema as aN,
-  ArchiveEntrySchema as aO,
-  ArchiveManifestSchema as aP,
-  AudioAnalysisResultSchema as aQ,
-  AudioAnalysisSettingsSchema as aR,
-  AudioChunkInputSchema as aS,
-  AudioClassSummarySchema as aT,
-  AudioClassificationLabelSchema as aU,
-  AudioClassificationResultSchema as aV,
-  AudioCodecInfoSchema as aW,
-  AudioDecodeSessionConfigSchema as aX,
-  AudioEncodeSessionConfigSchema as aY,
-  AudioEncodedChunkSchema as aZ,
-  AudioEventSchema as a_,
+  AddBrokerInputSchema as aD,
+  AddonAutoUpdateSchema as aE,
+  AddonListItemSchema as aF,
+  AddonPageDeclarationSchema as aG,
+  AddonPageInfoSchema as aH,
+  AgentLoadSummarySchema as aI,
+  AlertSchema as aJ,
+  AlertSeveritySchema as aK,
+  AlertSourceSchema as aL,
+  AlertStatusSchema as aM,
+  ApiKeyRecordSchema as aN,
+  ApiKeySummarySchema as aO,
+  ArchiveEntrySchema as aP,
+  ArchiveManifestSchema as aQ,
+  AudioAnalysisResultSchema as aR,
+  AudioAnalysisSettingsSchema as aS,
+  AudioChunkInputSchema as aT,
+  AudioClassSummarySchema as aU,
+  AudioClassificationLabelSchema as aV,
+  AudioClassificationResultSchema as aW,
+  AudioCodecInfoSchema as aX,
+  AudioDecodeSessionConfigSchema as aY,
+  AudioEncodeSessionConfigSchema as aZ,
+  AudioEncodedChunkSchema as a_,
   ptzCapability as aa,
   rebootCapability as ab,
   recordingCapability as ac,
@@ -8548,247 +8730,251 @@ export {
   APPLE_SA_TO_MACRO as ay,
   AUDIO_BACKEND_CHOICES as az,
   zoneAnalyticsCapability as b,
-  DeviceStatusSchema as b$,
-  AudioMetricsHistoryPointSchema as b0,
-  AudioMetricsHistorySchema as b1,
-  AudioMetricsSnapshotSchema as b2,
-  AudioPcmChunkSchema as b3,
-  AuthProviderInfoSchema as b4,
-  AuthResultSchema as b5,
-  AutoUpdateSettingsSchema as b6,
-  AvailableIntegrationTypeSchema as b7,
-  BATTERY_DEVICE_PROFILE as b8,
-  BackupDestinationInfoSchema as b9,
-  CollectionIndexSchema as bA,
-  ConfigEntrySchema$1 as bB,
-  ConfigSectionWithValuesSchema as bC,
-  ConfigTabDeclarationSchema as bD,
-  CreateApiKeyInputSchema as bE,
-  CreateApiKeyResultSchema as bF,
-  CreateIntegrationInputSchema as bG,
-  CreateScopedTokenInputSchema as bH,
-  CreateScopedTokenResultSchema as bI,
-  CreateUserInputSchema as bJ,
-  CustomActionInputSchema as bK,
-  DEFAULT_AUDIO_ANALYZER_CONFIG as bL,
-  DEFAULT_DECODER_HWACCEL_CONFIG as bM,
-  DEVICE_PROFILES as bN,
-  DEVICE_SETTINGS_CONTRIBUTION_METHODS as bO,
-  DEVICE_STATUS_METHOD as bP,
-  DecodedFrameSchema as bQ,
-  DecoderAssignmentSchema as bR,
-  DecoderSessionConfigSchema as bS,
-  DecoderStatsSchema as bT,
-  DeleteIntegrationResultSchema as bU,
-  DetectorOutputSchema as bV,
-  DeviceDiscoveryStatusSchema as bW,
-  DeviceFeature as bX,
-  DeviceInfoSchema as bY,
-  DeviceNetworkStatsSchema as bZ,
-  DeviceRole as b_,
-  BackupEntrySchema as ba,
-  BatteryStatusSchema as bb,
-  BoundingBoxSchema as bc,
-  BrightnessStatusSchema as bd,
-  BrokerAudioClientSchema as be,
-  BrokerClientsSchema as bf,
-  BrokerDecodedClientSchema as bg,
-  BrokerRtspClientSchema as bh,
-  BrokerStatsSchema as bi,
-  BrokerStatusSchema as bj,
-  CAM_PROFILE_ORDER as bk,
-  CamProfileSchema as bl,
-  CamStreamKindSchema as bm,
-  CamStreamResolutionSchema as bn,
-  CameraCredentialsSchema as bo,
-  CameraCredentialsStatusSchema as bp,
-  CameraMetricsSchema as bq,
-  CameraMetricsWithDeviceIdSchema as br,
-  CameraStreamSchema as bs,
-  CapScopeSchema as bt,
-  CapabilityBindingsSchema as bu,
-  ChargingStatus as bv,
-  ClientNetworkStatsSchema as bw,
-  ClusterAddonNodeDeploymentSchema as bx,
-  ClusterAddonStatusEntrySchema as by,
-  CollectionColumnSchema as bz,
+  DeviceExportStatusSchema as b$,
+  AudioLevelSchema as b0,
+  AudioMetricsHistoryPointSchema as b1,
+  AudioMetricsHistorySchema as b2,
+  AudioMetricsSnapshotSchema as b3,
+  AudioPcmChunkSchema as b4,
+  AuthProviderInfoSchema as b5,
+  AuthResultSchema as b6,
+  AutoUpdateSettingsSchema as b7,
+  AvailableIntegrationTypeSchema as b8,
+  BATTERY_DEVICE_PROFILE as b9,
+  ClusterAddonNodeDeploymentSchema as bA,
+  ClusterAddonStatusEntrySchema as bB,
+  CollectionColumnSchema as bC,
+  CollectionIndexSchema as bD,
+  ConfigEntrySchema$1 as bE,
+  ConfigSectionWithValuesSchema as bF,
+  ConfigTabDeclarationSchema as bG,
+  CreateApiKeyInputSchema as bH,
+  CreateApiKeyResultSchema as bI,
+  CreateIntegrationInputSchema as bJ,
+  CreateScopedTokenInputSchema as bK,
+  CreateScopedTokenResultSchema as bL,
+  CreateUserInputSchema as bM,
+  CustomActionInputSchema as bN,
+  DEFAULT_AUDIO_ANALYZER_CONFIG as bO,
+  DEFAULT_DECODER_HWACCEL_CONFIG as bP,
+  DEVICE_PROFILES as bQ,
+  DEVICE_SETTINGS_CONTRIBUTION_METHODS as bR,
+  DEVICE_STATUS_METHOD as bS,
+  DecodedFrameSchema as bT,
+  DecoderAssignmentSchema as bU,
+  DecoderSessionConfigSchema as bV,
+  DecoderStatsSchema as bW,
+  DeleteIntegrationResultSchema as bX,
+  DetectorOutputSchema as bY,
+  DeviceDiscoveryStatusSchema as bZ,
+  ExposeInputSchema as b_,
+  BackupDestinationInfoSchema as ba,
+  BackupEntrySchema as bb,
+  BatteryStatusSchema as bc,
+  BoundingBoxSchema as bd,
+  BrightnessStatusSchema as be,
+  BrokerAudioClientSchema as bf,
+  BrokerClientsSchema as bg,
+  BrokerConnectionDetailsSchema as bh,
+  BrokerDecodedClientSchema as bi,
+  BrokerInfoSchema as bj,
+  BrokerRtspClientSchema as bk,
+  BrokerStatsSchema as bl,
+  BrokerStatusSchema$1 as bm,
+  CAM_PROFILE_ORDER as bn,
+  CamProfileSchema as bo,
+  CamStreamKindSchema as bp,
+  CamStreamResolutionSchema as bq,
+  CameraCredentialsSchema as br,
+  CameraCredentialsStatusSchema as bs,
+  CameraMetricsSchema as bt,
+  CameraMetricsWithDeviceIdSchema as bu,
+  CameraStreamSchema as bv,
+  CapScopeSchema as bw,
+  CapabilityBindingsSchema as bx,
+  ChargingStatus as by,
+  ClientNetworkStatsSchema as bz,
   motionCapability as c,
-  PIPELINE_OWNER_CAPABILITY_NAMES as c$,
-  DeviceType as c0,
-  DiscoveredChildDeviceSchema as c1,
-  DiscoveredChildStatusSchema as c2,
-  DiscoveredDeviceSchema as c3,
-  DoorbellPressEventSchema as c4,
-  DoorbellStatusSchema as c5,
-  EmbeddingInfoSchema as c6,
-  EmbeddingResultSchema as c7,
-  EncodedPacketSchema as c8,
-  EnrichedWidgetMetadataSchema as c9,
-  MotionAnalysisResultSchema as cA,
-  MotionEventSchema as cB,
-  MotionOnMotionChangedDataSchema as cC,
-  MotionRegionSchema as cD,
-  MotionSourceEnum as cE,
-  MotionSourcesSchema as cF,
-  MotionStatusSchema as cG,
-  MotionTriggerRuntimeStateSchema as cH,
-  MotionTriggerStatusSchema as cI,
-  MqttStatusSchema as cJ,
-  NativeDetectionSchema as cK,
-  NativeObjectClassEnum as cL,
-  NativeObjectDetectionStatusSchema as cM,
-  NetworkAccessStatusSchema as cN,
-  NetworkAddressSchema as cO,
-  NetworkEndpointSchema as cP,
-  NotificationHistoryEntrySchema as cQ,
-  NotificationRuleSchema as cR,
-  NotificationSchema as cS,
-  ObjectEventSchema as cT,
-  OrchestratorMetricsSchema as cU,
-  OsdOverlayKindEnum as cV,
-  OsdOverlayPatchSchema as cW,
-  OsdOverlaySchema as cX,
-  OsdPositionEnum as cY,
-  OsdStatusSchema as cZ,
-  PIPELINE_FLOW_CAPABILITY_NAMES as c_,
-  EventItemSchema as ca,
-  EventKindSchema as cb,
-  ExposedResourceSchema as cc,
-  FeatureManifestSchema as cd,
-  FeatureProbeStatusSchema as ce,
-  FrameInputSchema as cf,
-  GlobalMetricsSchema as cg,
-  HWACCEL_OPTIONS as ch,
-  HaServiceCallSchema as ci,
-  HaStateSchema as cj,
-  HaStatusSchema as ck,
-  HealthStatusSchema as cl,
-  HistoryPointSchema as cm,
-  HistoryResolutionEnum as cn,
-  InstalledPackageSchema as co,
-  IntegrationLiteSchema as cp,
-  IntegrationWithStateSchema as cq,
-  IntercomAbilitySchema as cr,
-  IntercomStatusSchema as cs,
-  LocationStatSchema as ct,
-  LogEntrySchema as cu,
-  LogLevelSchema$1 as cv,
-  LogStreamEntrySchema as cw,
-  MODEL_FORMATS as cx,
-  MediaFileSchema as cy,
-  MethodAccessSchema as cz,
+  OsdOverlayPatchSchema as c$,
+  UnexposeInputSchema as c0,
+  DeviceFeature as c1,
+  DeviceInfoSchema as c2,
+  DeviceNetworkStatsSchema as c3,
+  DeviceRole as c4,
+  DeviceStatusSchema as c5,
+  DeviceType as c6,
+  DiscoveredChildDeviceSchema as c7,
+  DiscoveredChildStatusSchema as c8,
+  DiscoveredDeviceSchema as c9,
+  LogLevelSchema$1 as cA,
+  LogStreamEntrySchema as cB,
+  MODEL_FORMATS as cC,
+  MediaFileSchema as cD,
+  MethodAccessSchema as cE,
+  MotionAnalysisResultSchema as cF,
+  MotionEventSchema as cG,
+  MotionOnMotionChangedDataSchema as cH,
+  MotionRegionSchema as cI,
+  MotionSourceEnum as cJ,
+  MotionSourcesSchema as cK,
+  MotionStatusSchema as cL,
+  MotionTriggerRuntimeStateSchema as cM,
+  MotionTriggerStatusSchema as cN,
+  StatusSchema as cO,
+  NativeDetectionSchema as cP,
+  NativeObjectClassEnum as cQ,
+  NativeObjectDetectionStatusSchema as cR,
+  NetworkAccessStatusSchema as cS,
+  NetworkAddressSchema as cT,
+  NetworkEndpointSchema as cU,
+  NotificationHistoryEntrySchema as cV,
+  NotificationRuleSchema as cW,
+  NotificationSchema as cX,
+  ObjectEventSchema as cY,
+  OrchestratorMetricsSchema as cZ,
+  OsdOverlayKindEnum as c_,
+  DoorbellPressEventSchema as ca,
+  DoorbellStatusSchema as cb,
+  EmbeddingInfoSchema as cc,
+  EmbeddingResultSchema as cd,
+  EncodedPacketSchema as ce,
+  EnrichedWidgetMetadataSchema as cf,
+  EventItemSchema as cg,
+  EventKindSchema as ch,
+  ExposedDeviceSchema as ci,
+  ExposedResourceSchema as cj,
+  FeatureManifestSchema as ck,
+  FeatureProbeStatusSchema as cl,
+  FrameInputSchema as cm,
+  GetStreamWithCodecInputSchema as cn,
+  GlobalMetricsSchema as co,
+  HWACCEL_OPTIONS as cp,
+  HealthStatusSchema as cq,
+  HistoryPointSchema as cr,
+  HistoryResolutionEnum as cs,
+  InstalledPackageSchema as ct,
+  IntegrationLiteSchema as cu,
+  IntegrationWithStateSchema as cv,
+  IntercomAbilitySchema as cw,
+  IntercomStatusSchema as cx,
+  LocationStatSchema as cy,
+  LogEntrySchema as cz,
   doorbellCapability as d,
-  StreamFormatSchema as d$,
-  PackageUpdateSchema as d0,
-  PackageVersionInfoSchema as d1,
-  PasskeySummarySchema as d2,
-  PcmSampleFormatSchema as d3,
-  PerScopeBreakdownSchema as d4,
-  PipelineAssignmentSchema as d5,
-  PipelineDefaultStepSchema as d6,
-  PipelineEngineChoiceSchema as d7,
-  PipelineRunResultBridge as d8,
-  PipelineStepInputSchema as d9,
-  ScopedTokenSummarySchema as dA,
-  SearchResultSchema as dB,
-  SegmentSchema as dC,
-  SendEmailInputSchema as dD,
-  SendEmailResultSchema as dE,
-  SettingsPatchSchema as dF,
-  SettingsRecordSchema as dG,
-  SettingsSchemaWithValuesSchema as dH,
-  SettingsUpdateResultSchema as dI,
-  SmtpStatusSchema as dJ,
-  SnapshotImageSchema as dK,
-  SpatialDetectionSchema as dL,
-  SsoBridgeClaimsSchema as dM,
-  AbortUploadInputSchema as dN,
-  BeginDownloadInputSchema as dO,
-  BeginDownloadResultSchema as dP,
-  BeginUploadInputSchema as dQ,
-  BeginUploadResultSchema as dR,
-  EndDownloadInputSchema as dS,
-  FinalizeUploadInputSchema as dT,
-  StorageLocationRefSchema as dU,
-  StorageLocationSchema as dV,
-  StorageLocationTypeSchema as dW,
-  ProviderInfoSchema as dX,
-  ReadChunkInputSchema as dY,
-  TestLocationResultSchema as dZ,
-  WriteChunkInputSchema as d_,
-  PlaceholderReasonSchema as da,
-  PolygonPointSchema as db,
-  ProfileSlotSchema as dc,
-  ProfileSlotStatusSchema as dd,
-  ProviderStatusSchema as de,
-  PtzAutotrackRuntimeStateSchema as df,
-  PtzAutotrackSettingsSchema as dg,
-  PtzAutotrackStatusSchema as dh,
-  PtzAutotrackTargetOptionSchema as di,
-  PtzMoveCommandSchema as dj,
-  PtzPositionSchema as dk,
-  PtzPresetSchema as dl,
-  PublishInputSchema as dm,
-  QueryFilterSchema as dn,
-  RegisteredStreamSchema as dp,
-  RemoteAccessEndpointSchema as dq,
-  RemoteAccessProviderInfoSchema as dr,
-  ReportMotionInputSchema as ds,
-  RtspRestreamEntrySchema as dt,
-  RunnerCameraConfigSchema as du,
-  RunnerCameraDeviceUIFields as dv,
-  RunnerLocalLoadSchema as dw,
-  RunnerLocalMetricsSchema as dx,
-  STORAGE_LOCATION_CARDINALITY as dy,
-  ScopedTokenSchema as dz,
+  StorageLocationSchema as d$,
+  OsdOverlaySchema as d0,
+  OsdPositionEnum as d1,
+  OsdStatusSchema as d2,
+  PIPELINE_FLOW_CAPABILITY_NAMES as d3,
+  PIPELINE_OWNER_CAPABILITY_NAMES as d4,
+  PackageUpdateSchema as d5,
+  PackageVersionInfoSchema as d6,
+  PasskeySummarySchema as d7,
+  PcmSampleFormatSchema as d8,
+  PerScopeBreakdownSchema as d9,
+  RunnerCameraDeviceUIFields as dA,
+  RunnerLocalLoadSchema as dB,
+  RunnerLocalMetricsSchema as dC,
+  STORAGE_LOCATION_CARDINALITY as dD,
+  ScopedTokenSchema as dE,
+  ScopedTokenSummarySchema as dF,
+  SearchResultSchema as dG,
+  SegmentSchema as dH,
+  SendEmailInputSchema as dI,
+  SendEmailResultSchema as dJ,
+  SettingsPatchSchema as dK,
+  SettingsRecordSchema as dL,
+  SettingsSchemaWithValuesSchema as dM,
+  SettingsUpdateResultSchema as dN,
+  SmtpStatusSchema as dO,
+  SnapshotImageSchema as dP,
+  SpatialDetectionSchema as dQ,
+  SsoBridgeClaimsSchema as dR,
+  StartEmbeddedInputSchema as dS,
+  AbortUploadInputSchema as dT,
+  BeginDownloadInputSchema as dU,
+  BeginDownloadResultSchema as dV,
+  BeginUploadInputSchema as dW,
+  BeginUploadResultSchema as dX,
+  EndDownloadInputSchema as dY,
+  FinalizeUploadInputSchema as dZ,
+  StorageLocationRefSchema as d_,
+  PipelineAssignmentSchema as da,
+  PipelineDefaultStepSchema as db,
+  PipelineEngineChoiceSchema as dc,
+  PipelineRunResultBridge as dd,
+  PipelineStepInputSchema as de,
+  PlaceholderReasonSchema as df,
+  PolygonPointSchema as dg,
+  ProfileSlotSchema as dh,
+  ProfileSlotStatusSchema as di,
+  ProviderStatusSchema as dj,
+  PtzAutotrackRuntimeStateSchema as dk,
+  PtzAutotrackSettingsSchema as dl,
+  PtzAutotrackStatusSchema as dm,
+  PtzAutotrackTargetOptionSchema as dn,
+  PtzMoveCommandSchema as dp,
+  PtzPositionSchema as dq,
+  PtzPresetSchema as dr,
+  QueryFilterSchema as ds,
+  RegisteredStreamSchema as dt,
+  RemoteAccessEndpointSchema as du,
+  RemoteAccessProviderInfoSchema as dv,
+  ReportMotionInputSchema as dw,
+  RtpSourceSchema as dx,
+  RtspRestreamEntrySchema as dy,
+  RunnerCameraConfigSchema as dz,
   errMsg as e,
-  StreamInfoSchema as e0,
-  StreamNetworkStatsSchema as e1,
-  StreamSourceEntrySchema$1 as e2,
-  StreamSourceSchema as e3,
-  SubscribeInputSchema as e4,
-  SubscriptionInfoSchema as e5,
-  SwitchStatusSchema as e6,
-  SystemMetricsSchema as e7,
-  TestConnectionResultSchema as e8,
-  ToastSchema as e9,
-  ZoneSchema as eA,
-  ZoneScopeBreakdownSchema as eB,
-  accessoryStableId as eC,
-  deviceMatchesProfile as eD,
-  event as eE,
-  expandCapMethods as eF,
-  getAudioMacroClassIds as eG,
-  mapAudioLabelToMacro as eH,
-  method as eI,
-  resolveDeviceProfile as eJ,
-  webrtcClientHintsSchema as eK,
-  TokenScopeSchema as ea,
-  TopologyNodeSchema as eb,
-  TopologyProcessSchema as ec,
-  TopologyServiceSchema as ed,
-  TrackSchema as ee,
-  TrackStateSchema as ef,
-  TrackedDetectionSchema as eg,
-  TurnProviderInfoSchema as eh,
-  TurnServerSchema as ei,
-  UpdateIntegrationInputSchema as ej,
-  UpdateUserInputSchema as ek,
-  UserRecordSchema as el,
-  UserSummarySchema as em,
-  WELL_KNOWN_TABS as en,
-  WELL_KNOWN_TAB_MAP as eo,
-  WebrtcStreamChoiceSchema as ep,
-  WebrtcStreamTargetSchema as eq,
-  WidgetHostEnum as er,
-  WidgetMetadataSchema as es,
-  WidgetSizeEnum as et,
-  YAMNET_TO_MACRO as eu,
-  ZoneKindEnum as ev,
-  ZoneRuleModeEnum as ew,
-  ZoneRuleSchema as ex,
-  ZoneRuleStageEnum as ey,
-  ZoneRulesArraySchema as ez,
+  StorageLocationTypeSchema as e0,
+  ProviderInfoSchema as e1,
+  ReadChunkInputSchema as e2,
+  TestLocationResultSchema as e3,
+  WriteChunkInputSchema as e4,
+  StreamFormatSchema as e5,
+  StreamInfoSchema as e6,
+  StreamNetworkStatsSchema as e7,
+  StreamSourceEntrySchema$1 as e8,
+  StreamSourceSchema as e9,
+  ZoneRuleModeEnum as eA,
+  ZoneRuleSchema as eB,
+  ZoneRuleStageEnum as eC,
+  ZoneRulesArraySchema as eD,
+  ZoneSchema as eE,
+  ZoneScopeBreakdownSchema as eF,
+  accessoryStableId as eG,
+  deviceMatchesProfile as eH,
+  event as eI,
+  expandCapMethods as eJ,
+  getAudioMacroClassIds as eK,
+  mapAudioLabelToMacro as eL,
+  method as eM,
+  resolveDeviceProfile as eN,
+  webrtcClientHintsSchema as eO,
+  SwitchStatusSchema as ea,
+  SystemMetricsSchema as eb,
+  TestConnectionResultSchema as ec,
+  ToastSchema as ed,
+  TokenScopeSchema as ee,
+  TopologyNodeSchema as ef,
+  TopologyProcessSchema as eg,
+  TopologyServiceSchema as eh,
+  TrackSchema as ei,
+  TrackStateSchema as ej,
+  TrackedDetectionSchema as ek,
+  TurnProviderInfoSchema as el,
+  TurnServerSchema as em,
+  UpdateIntegrationInputSchema as en,
+  UpdateUserInputSchema as eo,
+  UserRecordSchema as ep,
+  UserSummarySchema as eq,
+  WELL_KNOWN_TABS as er,
+  WELL_KNOWN_TAB_MAP as es,
+  WebrtcStreamChoiceSchema as et,
+  WebrtcStreamTargetSchema as eu,
+  WidgetHostEnum as ev,
+  WidgetMetadataSchema as ew,
+  WidgetSizeEnum as ex,
+  YAMNET_TO_MACRO as ey,
+  ZoneKindEnum as ez,
   featureProbeCapability as f,
   deviceStatusCapability as g,
   hydrateSchema as h,
@@ -8811,4 +8997,4 @@ export {
   addonsCapability as y,
   zonesCapability as z
 };
-//# sourceMappingURL=index-BKnvgAep.mjs.map
+//# sourceMappingURL=index-YnRVILXN.mjs.map