@camstack/types 1.1.52 → 1.1.54

package/dist/capabilities/climate-control.cap.d.ts

@@ -33,8 +33,8 @@ import { DeviceType } from '../device/device-type.js';
  * — any climate device (not just Gree) can advertise either / both axes.
  */
 export declare const HvacModeSchema: z.ZodEnum<{
-    off: "off";
     auto: "auto";
+    off: "off";
     heat: "heat";
     cool: "cool";
     heat_cool: "heat_cool";
@@ -44,8 +44,8 @@ export declare const HvacModeSchema: z.ZodEnum<{
 export type HvacMode = z.infer<typeof HvacModeSchema>;
 export declare const ClimateControlStatusSchema: z.ZodObject<{
     mode: z.ZodEnum<{
-        off: "off";
         auto: "auto";
+        off: "off";
         heat: "heat";
         cool: "cool";
         heat_cool: "heat_cool";
@@ -53,8 +53,8 @@ export declare const ClimateControlStatusSchema: z.ZodObject<{
         dry: "dry";
     }>;
     availableModes: z.ZodArray<z.ZodEnum<{
-        off: "off";
         auto: "auto";
+        off: "off";
         heat: "heat";
         cool: "cool";
         heat_cool: "heat_cool";
@@ -86,8 +86,8 @@ export declare const climateControlCapability: {
         readonly setMode: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             mode: z.ZodEnum<{
-                off: "off";
                 auto: "auto";
+                off: "off";
                 heat: "heat";
                 cool: "cool";
                 heat_cool: "heat_cool";
@@ -128,8 +128,8 @@ export declare const climateControlCapability: {
     readonly status: {
         readonly schema: z.ZodObject<{
             mode: z.ZodEnum<{
-                off: "off";
                 auto: "auto";
+                off: "off";
                 heat: "heat";
                 cool: "cool";
                 heat_cool: "heat_cool";
@@ -137,8 +137,8 @@ export declare const climateControlCapability: {
                 dry: "dry";
             }>;
             availableModes: z.ZodArray<z.ZodEnum<{
-                off: "off";
                 auto: "auto";
+                off: "off";
                 heat: "heat";
                 cool: "cool";
                 heat_cool: "heat_cool";
@@ -168,8 +168,8 @@ export declare const climateControlCapability: {
      */
     readonly runtimeState: z.ZodObject<{
         mode: z.ZodEnum<{
-            off: "off";
             auto: "auto";
+            off: "off";
             heat: "heat";
             cool: "cool";
             heat_cool: "heat_cool";
@@ -177,8 +177,8 @@ export declare const climateControlCapability: {
             dry: "dry";
         }>;
         availableModes: z.ZodArray<z.ZodEnum<{
-            off: "off";
             auto: "auto";
+            off: "off";
             heat: "heat";
             cool: "cool";
             heat_cool: "heat_cool";

package/dist/capabilities/custom-model-registry.cap.d.ts

@@ -106,6 +106,7 @@ export declare const CustomModelDescriptorSchema: z.ZodObject<{
             imagenet: "imagenet";
             none: "none";
         }>>;
+        outputProbabilities: z.ZodOptional<z.ZodBoolean>;
         preprocessMode: z.ZodOptional<z.ZodEnum<{
             letterbox: "letterbox";
             resize: "resize";
@@ -234,6 +235,7 @@ export declare const customModelRegistryCapability: {
                     imagenet: "imagenet";
                     none: "none";
                 }>>;
+                outputProbabilities: z.ZodOptional<z.ZodBoolean>;
                 preprocessMode: z.ZodOptional<z.ZodEnum<{
                     letterbox: "letterbox";
                     resize: "resize";

package/dist/capabilities/day-night.cap.d.ts

@@ -18,9 +18,9 @@ import { DeviceType } from '../device/device-type.js';
  */
 /** IR-cut switching mode. `schedule` = time-of-day table configured on the camera. */
 export declare const DayNightModeSchema: z.ZodEnum<{
+    auto: "auto";
     schedule: "schedule";
     night: "night";
-    auto: "auto";
     day: "day";
 }>;
 /**
@@ -30,9 +30,9 @@ export declare const DayNightModeSchema: z.ZodEnum<{
  */
 export declare const DayNightStatusSchema: z.ZodObject<{
     mode: z.ZodEnum<{
+        auto: "auto";
         schedule: "schedule";
         night: "night";
-        auto: "auto";
         day: "day";
     }>;
     sensitivity: z.ZodOptional<z.ZodNumber>;
@@ -47,9 +47,9 @@ export declare const DayNightStatusSchema: z.ZodObject<{
  */
 export declare const DayNightOptionsSchema: z.ZodObject<{
     modes: z.ZodArray<z.ZodEnum<{
+        auto: "auto";
         schedule: "schedule";
         night: "night";
-        auto: "auto";
         day: "day";
     }>>;
     supportsSensitivity: z.ZodBoolean;
@@ -71,9 +71,9 @@ export declare const DayNightOptionsSchema: z.ZodObject<{
  */
 export declare const DayNightSettingsPatchSchema: z.ZodObject<{
     mode: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
         schedule: "schedule";
         night: "night";
-        auto: "auto";
         day: "day";
     }>>;
     sensitivity: z.ZodOptional<z.ZodNumber>;
@@ -101,9 +101,9 @@ export declare const dayNightCapability: {
             deviceId: z.ZodNumber;
         }, z.core.$strip>, z.ZodObject<{
             modes: z.ZodArray<z.ZodEnum<{
+                auto: "auto";
                 schedule: "schedule";
                 night: "night";
-                auto: "auto";
                 day: "day";
             }>>;
             supportsSensitivity: z.ZodBoolean;
@@ -123,9 +123,9 @@ export declare const dayNightCapability: {
             deviceId: z.ZodNumber;
             settings: z.ZodObject<{
                 mode: z.ZodOptional<z.ZodEnum<{
+                    auto: "auto";
                     schedule: "schedule";
                     night: "night";
-                    auto: "auto";
                     day: "day";
                 }>>;
                 sensitivity: z.ZodOptional<z.ZodNumber>;
@@ -136,9 +136,9 @@ export declare const dayNightCapability: {
     readonly status: {
         readonly schema: z.ZodObject<{
             mode: z.ZodEnum<{
+                auto: "auto";
                 schedule: "schedule";
                 night: "night";
-                auto: "auto";
                 day: "day";
             }>;
             sensitivity: z.ZodOptional<z.ZodNumber>;
@@ -149,9 +149,9 @@ export declare const dayNightCapability: {
     };
     readonly runtimeState: z.ZodObject<{
         mode: z.ZodEnum<{
+            auto: "auto";
             schedule: "schedule";
             night: "night";
-            auto: "auto";
             day: "day";
         }>;
         sensitivity: z.ZodOptional<z.ZodNumber>;

package/dist/capabilities/device-manager.cap.d.ts

@@ -203,8 +203,8 @@ export declare const ConfigEntrySchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const DeviceLinkModeSchema: z.ZodEnum<{
-    manual: "manual";
     auto: "auto";
+    manual: "manual";
 }>;
 export type DeviceLinkMode = z.infer<typeof DeviceLinkModeSchema>;
 /** One resolved linked device — the compact projection consumers need. */
@@ -1051,8 +1051,8 @@ export declare const deviceManagerCapability: {
             deviceId: z.ZodNumber;
         }, z.core.$strip>, z.ZodObject<{
             mode: z.ZodEnum<{
-                manual: "manual";
                 auto: "auto";
+                manual: "manual";
             }>;
             devices: z.ZodArray<z.ZodObject<{
                 deviceId: z.ZodNumber;

package/dist/capabilities/face-gallery.cap.d.ts

@@ -85,8 +85,8 @@ export declare const faceGalleryCapability: {
             limit: z.ZodOptional<z.ZodNumber>;
             filter: z.ZodOptional<z.ZodEnum<{
                 unassigned: "unassigned";
-                recognized: "recognized";
                 all: "all";
+                recognized: "recognized";
             }>>;
         }, z.core.$strip>>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             faceId: z.ZodString;

package/dist/capabilities/image-settings.cap.d.ts

@@ -30,13 +30,13 @@ export declare const ImageRotateSchema: z.ZodEnum<{
 }>;
 /** White-balance mode. `manual` unlocks the normalized `warmth` knob. */
 export declare const WhiteBalanceModeSchema: z.ZodEnum<{
-    manual: "manual";
     auto: "auto";
+    manual: "manual";
 }>;
 /** Exposure mode. */
 export declare const ExposureModeSchema: z.ZodEnum<{
-    manual: "manual";
     auto: "auto";
+    manual: "manual";
 }>;
 /**
  * Backlight-compensation mode:
@@ -70,13 +70,13 @@ export declare const ImageSettingsStatusSchema: z.ZodObject<{
         270: "270";
     }>>;
     whiteBalance: z.ZodOptional<z.ZodEnum<{
-        manual: "manual";
         auto: "auto";
+        manual: "manual";
     }>>;
     warmth: z.ZodOptional<z.ZodNumber>;
     exposureMode: z.ZodOptional<z.ZodEnum<{
-        manual: "manual";
         auto: "auto";
+        manual: "manual";
     }>>;
     backlightMode: z.ZodOptional<z.ZodEnum<{
         off: "off";
@@ -127,8 +127,8 @@ export declare const ImageSettingsOptionsSchema: z.ZodObject<{
         270: "270";
     }>>;
     whiteBalanceModes: z.ZodArray<z.ZodEnum<{
-        manual: "manual";
         auto: "auto";
+        manual: "manual";
     }>>;
     supportsWarmth: z.ZodBoolean;
     warmth: z.ZodOptional<z.ZodObject<{
@@ -137,8 +137,8 @@ export declare const ImageSettingsOptionsSchema: z.ZodObject<{
         step: z.ZodNumber;
     }, z.core.$strip>>;
     exposureModes: z.ZodArray<z.ZodEnum<{
-        manual: "manual";
         auto: "auto";
+        manual: "manual";
     }>>;
     backlightModes: z.ZodArray<z.ZodEnum<{
         off: "off";
@@ -165,13 +165,13 @@ export declare const ImageSettingsPatchSchema: z.ZodObject<{
         270: "270";
     }>>;
     whiteBalance: z.ZodOptional<z.ZodEnum<{
-        manual: "manual";
         auto: "auto";
+        manual: "manual";
     }>>;
     warmth: z.ZodOptional<z.ZodNumber>;
     exposureMode: z.ZodOptional<z.ZodEnum<{
-        manual: "manual";
         auto: "auto";
+        manual: "manual";
     }>>;
     backlightMode: z.ZodOptional<z.ZodEnum<{
         off: "off";
@@ -237,8 +237,8 @@ export declare const imageSettingsCapability: {
                 270: "270";
             }>>;
             whiteBalanceModes: z.ZodArray<z.ZodEnum<{
-                manual: "manual";
                 auto: "auto";
+                manual: "manual";
             }>>;
             supportsWarmth: z.ZodBoolean;
             warmth: z.ZodOptional<z.ZodObject<{
@@ -247,8 +247,8 @@ export declare const imageSettingsCapability: {
                 step: z.ZodNumber;
             }, z.core.$strip>>;
             exposureModes: z.ZodArray<z.ZodEnum<{
-                manual: "manual";
                 auto: "auto";
+                manual: "manual";
             }>>;
             backlightModes: z.ZodArray<z.ZodEnum<{
                 off: "off";
@@ -273,13 +273,13 @@ export declare const imageSettingsCapability: {
                     270: "270";
                 }>>;
                 whiteBalance: z.ZodOptional<z.ZodEnum<{
-                    manual: "manual";
                     auto: "auto";
+                    manual: "manual";
                 }>>;
                 warmth: z.ZodOptional<z.ZodNumber>;
                 exposureMode: z.ZodOptional<z.ZodEnum<{
-                    manual: "manual";
                     auto: "auto";
+                    manual: "manual";
                 }>>;
                 backlightMode: z.ZodOptional<z.ZodEnum<{
                     off: "off";
@@ -305,13 +305,13 @@ export declare const imageSettingsCapability: {
                 270: "270";
             }>>;
             whiteBalance: z.ZodOptional<z.ZodEnum<{
-                manual: "manual";
                 auto: "auto";
+                manual: "manual";
             }>>;
             warmth: z.ZodOptional<z.ZodNumber>;
             exposureMode: z.ZodOptional<z.ZodEnum<{
-                manual: "manual";
                 auto: "auto";
+                manual: "manual";
             }>>;
             backlightMode: z.ZodOptional<z.ZodEnum<{
                 off: "off";
@@ -337,13 +337,13 @@ export declare const imageSettingsCapability: {
             270: "270";
         }>>;
         whiteBalance: z.ZodOptional<z.ZodEnum<{
-            manual: "manual";
             auto: "auto";
+            manual: "manual";
         }>>;
         warmth: z.ZodOptional<z.ZodNumber>;
         exposureMode: z.ZodOptional<z.ZodEnum<{
-            manual: "manual";
             auto: "auto";
+            manual: "manual";
         }>>;
         backlightMode: z.ZodOptional<z.ZodEnum<{
             off: "off";

package/dist/capabilities/media-player.cap.d.ts

@@ -24,8 +24,8 @@ export declare const MediaPlayerStateSchema: z.ZodEnum<{
 }>;
 export type MediaPlayerState = z.infer<typeof MediaPlayerStateSchema>;
 export declare const MediaPlayerRepeatSchema: z.ZodEnum<{
-    off: "off";
     all: "all";
+    off: "off";
     one: "one";
 }>;
 export type MediaPlayerRepeat = z.infer<typeof MediaPlayerRepeatSchema>;
@@ -62,8 +62,8 @@ export declare const MediaPlayerStatusSchema: z.ZodObject<{
     durationMs: z.ZodNullable<z.ZodNumber>;
     shuffle: z.ZodNullable<z.ZodBoolean>;
     repeat: z.ZodNullable<z.ZodEnum<{
-        off: "off";
         all: "all";
+        off: "off";
         one: "one";
     }>>;
     lastChangedAt: z.ZodNumber;
@@ -110,8 +110,8 @@ export declare const mediaPlayerCapability: {
         readonly setRepeat: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             repeat: z.ZodEnum<{
-                off: "off";
                 all: "all";
+                off: "off";
                 one: "one";
             }>;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
@@ -151,8 +151,8 @@ export declare const mediaPlayerCapability: {
             durationMs: z.ZodNullable<z.ZodNumber>;
             shuffle: z.ZodNullable<z.ZodBoolean>;
             repeat: z.ZodNullable<z.ZodEnum<{
-                off: "off";
                 all: "all";
+                off: "off";
                 one: "one";
             }>>;
             lastChangedAt: z.ZodNumber;
@@ -189,8 +189,8 @@ export declare const mediaPlayerCapability: {
         durationMs: z.ZodNullable<z.ZodNumber>;
         shuffle: z.ZodNullable<z.ZodBoolean>;
         repeat: z.ZodNullable<z.ZodEnum<{
-            off: "off";
             all: "all";
+            off: "off";
             one: "one";
         }>>;
         lastChangedAt: z.ZodNumber;

package/dist/capabilities/model-convert.cap.d.ts

@@ -196,6 +196,7 @@ export declare const modelConvertCapability: {
                     imagenet: "imagenet";
                     none: "none";
                 }>>;
+                outputProbabilities: z.ZodOptional<z.ZodBoolean>;
                 preprocessMode: z.ZodOptional<z.ZodEnum<{
                     letterbox: "letterbox";
                     resize: "resize";

package/dist/capabilities/model-distributor.cap.d.ts

@@ -108,6 +108,7 @@ export declare const ModelDistributeInputSchema: z.ZodObject<{
             imagenet: "imagenet";
             none: "none";
         }>>;
+        outputProbabilities: z.ZodOptional<z.ZodBoolean>;
         preprocessMode: z.ZodOptional<z.ZodEnum<{
             letterbox: "letterbox";
             resize: "resize";
@@ -250,6 +251,7 @@ export declare const modelDistributorCapability: {
                     imagenet: "imagenet";
                     none: "none";
                 }>>;
+                outputProbabilities: z.ZodOptional<z.ZodBoolean>;
                 preprocessMode: z.ZodOptional<z.ZodEnum<{
                     letterbox: "letterbox";
                     resize: "resize";

package/dist/capabilities/pipeline-executor.cap.d.ts

@@ -915,6 +915,7 @@ export declare const pipelineExecutorCapability: {
                 frame: "frame";
                 full: "full";
             }>>;
+            deviceKey: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodCustom<FrameResult, FrameResult>, "mutation">;
         /**
          * Batched run — N raw frames packed into one cap call. The provider
@@ -960,6 +961,8 @@ export declare const pipelineExecutorCapability: {
             }, z.core.$strip>>;
             deviceId: z.ZodOptional<z.ZodNumber>;
             sessionId: z.ZodOptional<z.ZodString>;
+            frameId: z.ZodOptional<z.ZodNumber>;
+            deviceKey: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             results: z.ZodReadonly<z.ZodArray<z.ZodCustom<FrameResult, FrameResult>>>;
         }, z.core.$strip>, "mutation">;

package/dist/capabilities/pipeline-runner.cap.d.ts

@@ -202,6 +202,7 @@ declare const RunnerCameraConfigSchema: z.ZodObject<{
         ownerReachableHost: z.ZodOptional<z.ZodString>;
         hubHostnameOverride: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "kind">>;
+    deviceKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
  * Per-device settings UI fields the runner cap owns. Co-located with
@@ -321,6 +322,7 @@ export declare const pipelineRunnerCapability: {
                 ownerReachableHost: z.ZodOptional<z.ZodString>;
                 hubHostnameOverride: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>], "kind">>;
+            deviceKey: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             success: z.ZodLiteral<true>;
         }, z.core.$strip>, "mutation">;

package/dist/capabilities/platform-probe.cap.d.ts

@@ -172,6 +172,7 @@ export declare const platformProbeCapability: {
                     onnx: "onnx";
                     coreml: "coreml";
                     openvino: "openvino";
+                    tflite: "tflite";
                 }>;
                 score: z.ZodNumber;
                 reason: z.ZodString;
@@ -187,12 +188,29 @@ export declare const platformProbeCapability: {
                     onnx: "onnx";
                     coreml: "coreml";
                     openvino: "openvino";
+                    tflite: "tflite";
                 }>;
                 score: z.ZodNumber;
                 reason: z.ZodString;
                 available: z.ZodBoolean;
             }, z.core.$strip>;
             pythonPath: z.ZodNullable<z.ZodString>;
+            devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                backend: z.ZodString;
+                device: z.ZodString;
+                format: z.ZodEnum<{
+                    onnx: "onnx";
+                    coreml: "coreml";
+                    openvino: "openvino";
+                    tflite: "tflite";
+                    pt: "pt";
+                    gguf: "gguf";
+                }>;
+                runtime: z.ZodLiteral<"python">;
+                score: z.ZodNumber;
+                available: z.ZodBoolean;
+            }, z.core.$strip>>>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly getHardware: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
             platform: z.ZodEnum<{
@@ -260,8 +278,8 @@ export declare const platformProbeCapability: {
                 openvino: "openvino";
                 none: "none";
                 tensorrt: "tensorrt";
-                videotoolbox: "videotoolbox";
                 cuda: "cuda";
+                videotoolbox: "videotoolbox";
                 nvdec: "nvdec";
                 vaapi: "vaapi";
                 qsv: "qsv";

package/dist/device/device-control-resolution.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Device-control RESOLUTION LOGIC — the single, presentation-free source of
+ * truth for "given a device's `type` (+ its cap `features`), which control
+ * should render?".
+ *
+ * This module is deliberately framework-free: NO react / react-native / lucide
+ * imports, no JSX, no platform widgets. It encodes only the DECISION; each
+ * client (admin-ui's `@camstack/ui-library` web registry, the RN viewer's
+ * accessory registry) maps the returned control-KIND onto its own
+ * platform-specific components. That's the one duplication we remove — the
+ * presentational components stay platform-specific by necessity.
+ *
+ * Two decision surfaces live here, at two granularities:
+ *
+ *  1. `resolveDeviceControlKind(type)` — the BASE type → control-kind decision
+ *     used by the admin-ui device list / device-detail hero. Exhaustive over
+ *     every `DeviceType`; a light is a single `'light'` kind (dim-vs-plain is
+ *     refined inside the light component).
+ *
+ *  2. `pickAccessoryControl({ type, features })` — the FINER accessory-row
+ *     decision used by the viewer's per-camera accessory list. It refines a
+ *     `light` into `'brightness'` vs `'switch'` and a `sensor`/`presence` into
+ *     a specific sensor cap, because an accessory row renders ONE compact
+ *     control chosen by priority.
+ *
+ * The two agree on every overlapping type EXCEPT `light` (see the notes on
+ * `pickAccessoryControl`): the base decision keeps a dedicated `'light'`
+ * control; the accessory decision collapses a non-dimmable light onto the
+ * generic `'switch'` control. That is a deliberate granularity difference, not
+ * a contradiction — the base kind is what the admin-ui renders, the accessory
+ * pick is what a compact camera-accessory row renders.
+ */
+import { DeviceType } from './device-type.js';
+/**
+ * The abstract control-kind a `DeviceType` resolves to. Each client binds
+ * these kinds to its own components (web: `CONTROL_KIND_COMPONENTS`). A single
+ * kind can back several device types (`'switch'` ← Switch + Siren, `'sensor'`
+ * ← Sensor + Presence, `'dummy'` ← every placeholder/non-controllable type).
+ */
+export type DeviceControlKind = 'cover' | 'valve' | 'humidifier' | 'water-heater' | 'switch' | 'light' | 'fan' | 'sensor' | 'thermostat' | 'climate' | 'button' | 'update' | 'lock' | 'media-player' | 'alarm' | 'control' | 'weather' | 'vacuum' | 'lawn-mower' | 'image' | 'pet-feeder' | 'dummy';
+/**
+ * Exhaustive `DeviceType` → `DeviceControlKind` map. Omitting a new enum member
+ * fails the build here (the single place the type→kind decision is encoded).
+ * `'dummy'` marks types with no interactive control (Camera/Hub/Generic and the
+ * placeholder HA types whose inline control renders a dash).
+ */
+export declare const DEVICE_TYPE_CONTROL_KIND: Record<DeviceType, DeviceControlKind>;
+/**
+ * Runtime-string-safe base resolver: a device row's `type` crosses the wire as
+ * a plain string, so an unrecognised value resolves to `null` instead of
+ * indexing the map with an unverified key. `DEVICE_TYPE_VALUES.has(type)`
+ * narrows the string to a `DeviceType` before indexing (documented enum-string
+ * boundary).
+ */
+export declare function resolveDeviceControlKind(type: string): DeviceControlKind | null;
+/** Identifier of the control kind an accessory row should render. `'none'` = no
+ *  control. A subset of the surfaces the base decision covers, PLUS
+ *  `'brightness'` (a dimmable light refined at the decision layer). */
+export type AccessoryControlKind = 'cover' | 'lock' | 'alarm' | 'valve' | 'brightness' | 'switch' | 'sensor' | 'none';
+/** Kebab feature flag advertised by an accessory that auto-activates when its
+ *  parent camera detects motion. The cap's kebab name is `motion-trigger` (see
+ *  `motion-trigger.cap.ts`). It is INDEPENDENT of the row's primary control: a
+ *  siren/light/switch can expose BOTH a `switch` on/off AND a `motion-trigger`
+ *  "activate on motion" toggle. */
+export declare const MOTION_TRIGGER_FEATURE = "motion-trigger";
+/** True when an accessory advertises the `motion-trigger` cap — drives the
+ *  inline "On motion" toggle rendered alongside its primary control. Pure +
+ *  testable. */
+export declare function hasMotionTrigger(features: readonly string[]): boolean;
+/** Kebab-case sensor cap names → the read-only sensor-value control. The
+ *  accessory pick scans these (in order) to choose which sensor cap to read. */
+export declare const SENSOR_FEATURES: readonly string[];
+/** The chosen control plus the sensor feature (when `kind === 'sensor'`) so the
+ *  renderer knows which sensor cap to read. */
+export interface AccessoryControlPick {
+    readonly kind: AccessoryControlKind;
+    /** The kebab sensor cap name to read, only set when `kind === 'sensor'`. */
+    readonly sensorFeature?: string;
+}
+/** The accessory fields the pick needs: its canonical `DeviceType` (as the
+ *  wire string) plus the secondary cap `features` (used only to refine a light
+ *  or sensor). */
+export interface AccessoryControlInput {
+    readonly type: string;
+    readonly features: readonly string[];
+}
+/**
+ * Pick the primary control for an accessory. The control is chosen by the
+ * device's canonical `type` (the `DeviceType` enum value — the same key
+ * `resolveDeviceControlKind` maps on), NOT by the `features` list (which holds
+ * secondary flags). For a `light` we consult `features` to choose dim vs plain
+ * on/off, and for a `sensor`/`presence` to pick which sensor value to read.
+ * Pure: same input → same output. Returns `{ kind: 'none' }` for types with no
+ * accessory-row control.
+ */
+export declare function pickAccessoryControl(device: AccessoryControlInput): AccessoryControlPick;
+/** A sensor cap → its `(capKey, field, fallbackUnit)` mapping for the read-only
+ *  value row. The kebab cap name is the lookup key. The camelCase `capKey` is
+ *  the tRPC client router key; `field` is the numeric field on that cap's
+ *  status; `fallbackUnit` is used when the status omits a `unit`. */
+export interface SensorMapping {
+    readonly capKey: string;
+    readonly field: string;
+    readonly fallbackUnit?: string;
+}
+/** Kebab sensor cap → its numeric-value mapping. `enum-sensor` is handled
+ *  separately by callers (it reads a raw string `value`, not a numeric field),
+ *  so it intentionally has no entry here. */
+export declare const SENSOR_MAP: Readonly<Record<string, SensorMapping>>;
+/** True when a value is a navigable node: a plain object OR a tRPC v11 client
+ *  proxy node (a callable `Proxy(noop)` → `typeof === 'function'`, NOT an
+ *  object). A `typeof === 'object'`-only check REJECTS every real client proxy,
+ *  so `resolveMutate` would return null and EVERY control becomes a silent
+ *  no-op. Framework-free: operates on the SDK proxy shape only. */
+export declare function isNode(value: unknown): value is Record<string, unknown>;
+/** Resolve `router.<method>.mutate` to a callable, or `null`. Walks the tRPC
+ *  client proxy defensively (each hop guarded by `isNode`). */
+export declare function resolveMutate(router: unknown, method: string): ((input: Record<string, unknown>) => Promise<unknown>) | null;