@camera.ui/sdk 0.0.24 → 0.0.25

package/dist/index.d.ts

@@ -843,6 +843,10 @@ interface DeviceStorage<T extends Record<string, any> = Record<string, any>> {
     save(): Promise<void>;
 }
 
+/** Object-detection labels the detector groups its classes into. */
+declare const OBJECT_DETECTION_LABELS: readonly ["person", "vehicle", "animal", "package"];
+/** Union of the object-detection label strings. */
+type ObjectDetectionLabel = (typeof OBJECT_DETECTION_LABELS)[number];
 /** Built-in detection label types recognized across the system. */
 declare const DETECTION_LABELS: readonly ["motion", "person", "vehicle", "animal", "package", "audio"];
 /** Union of the built-in detection label strings. */
@@ -852,24 +856,24 @@ declare const DETECTION_ATTRIBUTES: readonly ["face", "license_plate"];
 /** Union of the built-in detection attribute strings. */
 type DetectionAttribute = (typeof DETECTION_ATTRIBUTES)[number];
 /**
- * Bounding box of a detection. All coordinates are normalized to 0–1
+ * Bounding box of a detection. All coordinates are normalized to 0-1
  * (fraction of frame dimensions), so they are independent of resolution.
  */
 interface BoundingBox {
-    /** X coordinate of the top-left corner (0–1). */
+    /** X coordinate of the top-left corner (0-1). */
     x: number;
-    /** Y coordinate of the top-left corner (0–1). */
+    /** Y coordinate of the top-left corner (0-1). */
     y: number;
-    /** Width as a fraction of frame width (0–1). */
+    /** Width as a fraction of frame width (0-1). */
     width: number;
-    /** Height as a fraction of frame height (0–1). */
+    /** Height as a fraction of frame height (0-1). */
     height: number;
 }
 /** A single detection result emitted by any detection sensor. */
 interface Detection {
     /** Detection label (e.g. `'person'`, `'vehicle'`). */
     label: DetectionLabel;
-    /** Confidence score in the range 0–1. */
+    /** Confidence score in the range 0-1. */
     confidence: number;
     /** Bounding box in normalized coordinates. */
     box: BoundingBox;
@@ -1102,6 +1106,99 @@ declare abstract class AudioDetectorSensor<TStorage extends object = Record<stri
     /** Analyze a single audio frame for events. Called by the backend at the configured cadence. */
     abstract detectAudio(audio: AudioFrameData): Promise<AudioResult>;
 }
+/** Registry metadata for {@link AudioSensor}. */
+declare const audioMeta: {
+    readonly type: SensorType.Audio;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "audio";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: AudioProperty[];
+    readonly semantics: null;
+};
+
+/** Condition under which a sensor arms an automation cascade. */
+interface SensorCascadeTrigger {
+    readonly property: string;
+    readonly value: unknown;
+    readonly sustained: boolean;
+}
+/** Initial property values and capabilities for a user-created virtual sensor. */
+interface SensorVirtualDefaults {
+    readonly properties: Readonly<Record<string, unknown>>;
+    readonly capabilities?: readonly string[];
+}
+/** The kind of thing a sensor is, used by consumers to pick how to render it. */
+declare enum SensorDomain {
+    Binary = "binary",
+    Measurement = "measurement",
+    Switch = "switch",
+    Light = "light",
+    Siren = "siren",
+    Lock = "lock",
+    Cover = "cover",
+    Alarm = "alarm"
+}
+/**
+ * What a sensor means, independent of any transport: which property holds its
+ * state, which takes commands, its unit and state mapping. Consumers (MQTT
+ * discovery, the HA integration) render from this instead of their own switch.
+ */
+interface SensorSemantics {
+    readonly domain: SensorDomain;
+    readonly stateProperty: string;
+    readonly commandProperty: string;
+    readonly deviceClass?: string;
+    readonly unit?: string;
+    readonly icon?: string;
+    readonly diagnostic?: boolean;
+    readonly states?: Readonly<Record<string, number>>;
+    readonly brightness?: {
+        readonly property: string;
+        readonly scale: number;
+    };
+}
+/**
+ * Metadata for a sensor type, declared alongside its class via {@link defineSensor}.
+ *
+ * Collected into the sensor registry, from which plugin assignment keys and the
+ * host's per-type tables derive, so each type is described once instead of in
+ * several parallel tables that drift apart.
+ */
+interface SensorMeta {
+    readonly type: SensorType;
+    readonly category: SensorCategory;
+    readonly assignmentKey: string;
+    readonly multiProvider: boolean;
+    readonly isDetectionType: boolean;
+    readonly properties: readonly string[];
+    readonly shortcutable?: boolean;
+    readonly cascadeTrigger?: SensorCascadeTrigger;
+    readonly propertyCapabilities?: Readonly<Record<string, string>>;
+    readonly virtual?: SensorVirtualDefaults;
+    readonly semantics?: SensorSemantics | null;
+}
+/**
+ * Declares the metadata for a sensor type: how it is assigned, scheduled, and
+ * optionally created as a virtual sensor.
+ *
+ * @param meta - The sensor's metadata.
+ *
+ * @returns The same metadata, with `type` and `assignmentKey` preserved as literal
+ * types so the registry can be checked for completeness and its keys derived.
+ *
+ * @example
+ * ```ts
+ * export const lightMeta = defineSensor({
+ *   type: SensorType.Light,
+ *   category: SensorCategory.Control,
+ *   assignmentKey: 'light',
+ *   multiProvider: true,
+ *   isDetectionType: false,
+ * });
+ * ```
+ */
+declare function defineSensor<const M extends SensorMeta>(meta: M): M;
 
 /** Optional capabilities for battery info sensors */
 declare enum BatteryCapability {
@@ -1116,7 +1213,7 @@ declare enum BatteryCapability {
  * @internal
  */
 declare enum BatteryProperty {
-    /** Battery level percentage (0–100) */
+    /** Battery level percentage (0-100) */
     Level = "level",
     /** Current charging state */
     Charging = "charging",
@@ -1170,7 +1267,7 @@ declare class BatteryInfo<TStorage extends object = Record<string, any>> extends
     /**
      * Report a new battery level (percentage). Clamped to [0, 100].
      *
-     * @param value - Battery level percentage in the range 0–100.
+     * @param value - Battery level percentage in the range 0-100.
      *
      * @example
      * ```ts
@@ -1216,6 +1313,28 @@ declare class BatteryInfo<TStorage extends object = Record<string, any>> extends
      */
     updateValue(_property: string, _value: unknown): void;
 }
+/** Registry metadata for {@link BatteryInfo}. */
+declare const batteryMeta: {
+    readonly type: SensorType.Battery;
+    readonly category: SensorCategory.Info;
+    readonly assignmentKey: "battery";
+    readonly multiProvider: false;
+    readonly isDetectionType: false;
+    readonly properties: BatteryProperty[];
+    readonly shortcutable: true;
+    readonly propertyCapabilities: {
+        readonly charging: BatteryCapability.Charging;
+        readonly low: BatteryCapability.LowBattery;
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Measurement;
+        readonly stateProperty: BatteryProperty.Level;
+        readonly commandProperty: BatteryProperty.Level;
+        readonly deviceClass: "battery";
+        readonly unit: "%";
+        readonly diagnostic: true;
+    };
+};
 
 /**
  * Properties for contact sensors
@@ -1273,6 +1392,32 @@ declare class ContactSensor<TStorage extends object = Record<string, any>> exten
      */
     updateValue(_property: string, _value: unknown): void;
 }
+/** Registry metadata for {@link ContactSensor}. */
+declare const contactMeta: {
+    readonly type: SensorType.Contact;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "contact";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: ContactProperty.Detected[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: ContactProperty;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly detected: false;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Binary;
+        readonly stateProperty: ContactProperty;
+        readonly commandProperty: ContactProperty;
+        readonly deviceClass: "opening";
+    };
+};
 
 /**
  * Properties for doorbell triggers
@@ -1340,6 +1485,32 @@ declare class DoorbellTrigger<TStorage extends object = Record<string, any>> ext
     updateValue(property: string, value: unknown): void;
     _cleanup(): void;
 }
+/** Registry metadata for {@link DoorbellTrigger}. */
+declare const doorbellMeta: {
+    readonly type: SensorType.Doorbell;
+    readonly category: SensorCategory.Trigger;
+    readonly assignmentKey: "doorbell";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: DoorbellProperty.Ring[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: DoorbellProperty;
+        readonly value: true;
+        readonly sustained: false;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly ring: false;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Binary;
+        readonly stateProperty: DoorbellProperty;
+        readonly commandProperty: DoorbellProperty;
+        readonly icon: "mdi:doorbell";
+    };
+};
 
 /**
  * Property names of a face detection sensor.
@@ -1474,6 +1645,16 @@ declare abstract class FaceDetectorSensor<TStorage extends object = Record<strin
      */
     abstract detectFaces(frames: VideoFrameData[]): Promise<FaceResult[]>;
 }
+/** Registry metadata for {@link FaceSensor}. */
+declare const faceMeta: {
+    readonly type: SensorType.Face;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "face";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: FaceProperty[];
+    readonly semantics: null;
+};
 
 /** Garage door states (HomeKit-compatible values) */
 declare enum GarageState {
@@ -1585,6 +1766,40 @@ declare class GarageControl<TStorage extends object = Record<string, any>> exten
      */
     updateValue(property: string, value: unknown): Promise<void>;
 }
+/** Registry metadata for {@link GarageControl}. */
+declare const garageMeta: {
+    readonly type: SensorType.Garage;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "garage";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: GarageProperty[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: GarageProperty.CurrentState;
+        readonly value: 0;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly currentState: 1;
+            readonly targetState: 1;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Cover;
+        readonly stateProperty: GarageProperty.CurrentState;
+        readonly commandProperty: GarageProperty.TargetState;
+        readonly deviceClass: "garage";
+        readonly states: {
+            readonly open: GarageState.Open;
+            readonly closed: GarageState.Closed;
+            readonly opening: GarageState.Opening;
+            readonly closing: GarageState.Closing;
+            readonly stopped: GarageState.Stopped;
+        };
+    };
+};
 
 /**
  * Properties for humidity sensors
@@ -1592,7 +1807,7 @@ declare class GarageControl<TStorage extends object = Record<string, any>> exten
  * @internal
  */
 declare enum HumidityProperty {
-    /** Current relative humidity (0–100%) */
+    /** Current relative humidity (0-100%) */
     Current = "current"
 }
 /**
@@ -1619,7 +1834,7 @@ declare class HumidityInfo<TStorage extends object = Record<string, any>> extend
     /**
      * Report a new humidity reading. Clamped to [0, 100] %.
      *
-     * @param value - Relative humidity percentage in the range 0–100.
+     * @param value - Relative humidity percentage in the range 0-100.
      *
      * @example
      * ```ts
@@ -1642,6 +1857,28 @@ declare class HumidityInfo<TStorage extends object = Record<string, any>> extend
      */
     updateValue(_property: string, _value: unknown): void;
 }
+/** Registry metadata for {@link HumidityInfo}. */
+declare const humidityMeta: {
+    readonly type: SensorType.Humidity;
+    readonly category: SensorCategory.Info;
+    readonly assignmentKey: "humidity";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: HumidityProperty.Current[];
+    readonly shortcutable: true;
+    readonly virtual: {
+        readonly properties: {
+            readonly current: 50;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Measurement;
+        readonly stateProperty: HumidityProperty;
+        readonly commandProperty: HumidityProperty;
+        readonly deviceClass: "humidity";
+        readonly unit: "%";
+    };
+};
 
 /**
  * Properties for leak sensors
@@ -1699,6 +1936,32 @@ declare class LeakSensor<TStorage extends object = Record<string, any>> extends
      */
     updateValue(_property: string, _value: unknown): void;
 }
+/** Registry metadata for {@link LeakSensor}. */
+declare const leakMeta: {
+    readonly type: SensorType.Leak;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "leak";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: LeakProperty.Detected[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: LeakProperty;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly detected: false;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Binary;
+        readonly stateProperty: LeakProperty;
+        readonly commandProperty: LeakProperty;
+        readonly deviceClass: "moisture";
+    };
+};
 
 /**
  * Property names of a license plate detection sensor.
@@ -1826,10 +2089,20 @@ declare abstract class LicensePlateDetectorSensor<TStorage extends object = Reco
      */
     abstract detectLicensePlates(frames: VideoFrameData[]): Promise<LicensePlateResult[]>;
 }
+/** Registry metadata for {@link LicensePlateSensor}. */
+declare const licensePlateMeta: {
+    readonly type: SensorType.LicensePlate;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "licensePlate";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: LicensePlateProperty[];
+    readonly semantics: null;
+};
 
 /** Optional capabilities for light controls */
 declare enum LightCapability {
-    /** Light supports brightness adjustment (0–100) */
+    /** Light supports brightness adjustment (0-100) */
     Brightness = "brightness"
 }
 /**
@@ -1840,7 +2113,7 @@ declare enum LightCapability {
 declare enum LightProperty {
     /** Whether the light is on */
     On = "on",
-    /** Brightness level (0–100) */
+    /** Brightness level (0-100) */
     Brightness = "brightness"
 }
 /**
@@ -1902,7 +2175,7 @@ declare class LightControl<TStorage extends object = Record<string, any>> extend
      * Set brightness. Override to drive hardware and call `await super.setBrightness(value)`
      * after the hardware call succeeds. The default implementation clamps the value to [0, 100].
      *
-     * @param value - Brightness level in the range 0–100.
+     * @param value - Brightness level in the range 0-100.
      *
      * @example
      * ```ts
@@ -1923,6 +2196,36 @@ declare class LightControl<TStorage extends object = Record<string, any>> extend
      */
     updateValue(property: string, value: unknown): Promise<void>;
 }
+/** Registry metadata for {@link LightControl}. */
+declare const lightMeta: {
+    readonly type: SensorType.Light;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "light";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: LightProperty[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: LightProperty.On;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly propertyCapabilities: {
+        readonly brightness: LightCapability;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly on: false;
+            readonly brightness: 100;
+        };
+        readonly capabilities: readonly [LightCapability];
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Light;
+        readonly stateProperty: LightProperty.On;
+        readonly commandProperty: LightProperty.On;
+    };
+};
 
 /** Lock states (HomeKit-compatible values) */
 declare enum LockState {
@@ -2015,6 +2318,36 @@ declare class LockControl<TStorage extends object = Record<string, any>> extends
      */
     updateValue(property: string, value: unknown): Promise<void>;
 }
+/** Registry metadata for {@link LockControl}. */
+declare const lockMeta: {
+    readonly type: SensorType.Lock;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "lock";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: LockProperty[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: LockProperty.CurrentState;
+        readonly value: 1;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly currentState: 0;
+            readonly targetState: 0;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Lock;
+        readonly stateProperty: LockProperty.CurrentState;
+        readonly commandProperty: LockProperty.TargetState;
+        readonly states: {
+            readonly locked: LockState.Secured;
+            readonly unlocked: LockState.Unsecured;
+        };
+    };
+};
 
 /**
  * Property names of a motion sensor.
@@ -2139,6 +2472,16 @@ declare abstract class MotionDetectorSensor<TStorage extends object = Record<str
     /** Analyze a single video frame for motion. Called by the backend at the configured interval. */
     abstract detectMotion(frame: VideoFrameData): Promise<MotionResult>;
 }
+/** Registry metadata for {@link MotionSensor}. */
+declare const motionMeta: {
+    readonly type: SensorType.Motion;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "motion";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: MotionProperty[];
+    readonly semantics: null;
+};
 
 /**
  * Property names of an object detection sensor.
@@ -2282,6 +2625,16 @@ declare abstract class ObjectDetectorSensor<TStorage extends object = Record<str
     /** Analyze a single video frame for objects. Called by the backend at the configured interval. */
     abstract detectObjects(frame: VideoFrameData): Promise<ObjectResult>;
 }
+/** Registry metadata for {@link ObjectSensor}. */
+declare const objectMeta: {
+    readonly type: SensorType.Object;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "object";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: ObjectProperty[];
+    readonly semantics: null;
+};
 
 /**
  * Properties for occupancy sensors
@@ -2339,11 +2692,40 @@ declare class OccupancySensor<TStorage extends object = Record<string, any>> ext
      */
     updateValue(_property: string, _value: unknown): void;
 }
+/** Registry metadata for {@link OccupancySensor}. */
+declare const occupancyMeta: {
+    readonly type: SensorType.Occupancy;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "occupancy";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: OccupancyProperty.Detected[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: OccupancyProperty;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly detected: false;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Binary;
+        readonly stateProperty: OccupancyProperty;
+        readonly commandProperty: OccupancyProperty;
+        readonly deviceClass: "occupancy";
+    };
+};
 
 /** Optional capabilities for PTZ controls. Add to `capabilities` to enable features. */
 declare enum PTZCapability {
+    /** Camera supports panning (horizontal movement) */
     Pan = "pan",
+    /** Camera supports tilting (vertical movement) */
     Tilt = "tilt",
+    /** Camera supports zoom */
     Zoom = "zoom",
     /** Camera supports named position presets */
     Presets = "presets",
@@ -2373,7 +2755,9 @@ declare enum PTZProperty {
     /** Target preset to move to */
     TargetPreset = "targetPreset",
     /** Relative displacement move command (write-only) */
-    RelativeMove = "relativeMove"
+    RelativeMove = "relativeMove",
+    /** Move to the home position (write-only command, carries no state) */
+    Home = "home"
 }
 /** Absolute PTZ position */
 interface PTZPosition {
@@ -2546,7 +2930,7 @@ declare class PTZControl<TStorage extends object = Record<string, any>> extends
      * Cross-process consumer entry point. Dispatches writable properties
      * to semantic methods so plugin overrides (hardware actions) are honored.
      * `moving` and `presets` are observed/discovered state and not externally writable;
-     * only `Position`, `Velocity`, `TargetPreset`, and `RelativeMove` may be set.
+     * only `Position`, `Velocity`, `TargetPreset`, `RelativeMove` and `Home` may be set.
      *
      * @param property - Property name to write.
      *
@@ -2556,6 +2940,16 @@ declare class PTZControl<TStorage extends object = Record<string, any>> extends
      */
     updateValue(property: string, value: unknown): Promise<void>;
 }
+/** Registry metadata for {@link PTZControl}. */
+declare const ptzMeta: {
+    readonly type: SensorType.PTZ;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "ptz";
+    readonly multiProvider: false;
+    readonly isDetectionType: false;
+    readonly properties: PTZProperty[];
+    readonly semantics: null;
+};
 
 /** Security system arm/disarm states (HomeKit-compatible values) */
 declare enum SecuritySystemState {
@@ -2652,10 +3046,43 @@ declare class SecuritySystem<TStorage extends object = Record<string, any>> exte
      */
     updateValue(property: string, value: unknown): Promise<void>;
 }
+/** Registry metadata for {@link SecuritySystem}. */
+declare const securitySystemMeta: {
+    readonly type: SensorType.SecuritySystem;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "securitySystem";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: SecuritySystemProperty[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: SecuritySystemProperty.CurrentState;
+        readonly value: 4;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly currentState: 3;
+            readonly targetState: 3;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Alarm;
+        readonly stateProperty: SecuritySystemProperty.CurrentState;
+        readonly commandProperty: SecuritySystemProperty.TargetState;
+        readonly states: {
+            readonly armed_home: SecuritySystemState.StayArm;
+            readonly armed_away: SecuritySystemState.AwayArm;
+            readonly armed_night: SecuritySystemState.NightArm;
+            readonly disarmed: SecuritySystemState.Disarmed;
+            readonly triggered: SecuritySystemState.AlarmTriggered;
+        };
+    };
+};
 
 /** Optional capabilities for siren controls */
 declare enum SirenCapability {
-    /** Siren supports volume adjustment (0–100) */
+    /** Siren supports volume adjustment (0-100) */
     Volume = "volume"
 }
 /**
@@ -2666,7 +3093,7 @@ declare enum SirenCapability {
 declare enum SirenProperty {
     /** Whether the siren is currently active */
     Active = "active",
-    /** Volume level (0–100) */
+    /** Volume level (0-100) */
     Volume = "volume"
 }
 /**
@@ -2723,7 +3150,7 @@ declare class SirenControl<TStorage extends object = Record<string, any>> extend
      * Set volume. Override to drive hardware and call `await super.setVolume(value)`
      * after success. The default implementation clamps the value to [0, 100].
      *
-     * @param value - Volume level in the range 0–100.
+     * @param value - Volume level in the range 0-100.
      *
      * @example
      * ```ts
@@ -2744,6 +3171,36 @@ declare class SirenControl<TStorage extends object = Record<string, any>> extend
      */
     updateValue(property: string, value: unknown): Promise<void>;
 }
+/** Registry metadata for {@link SirenControl}. */
+declare const sirenMeta: {
+    readonly type: SensorType.Siren;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "siren";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: SirenProperty[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: SirenProperty.Active;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly propertyCapabilities: {
+        readonly volume: SirenCapability;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly active: false;
+            readonly volume: 100;
+        };
+        readonly capabilities: readonly [SirenCapability];
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Siren;
+        readonly stateProperty: SirenProperty.Active;
+        readonly commandProperty: SirenProperty.Active;
+    };
+};
 
 /**
  * Properties for smoke sensors
@@ -2801,6 +3258,32 @@ declare class SmokeSensor<TStorage extends object = Record<string, any>> extends
      */
     updateValue(_property: string, _value: unknown): void;
 }
+/** Registry metadata for {@link SmokeSensor}. */
+declare const smokeMeta: {
+    readonly type: SensorType.Smoke;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "smoke";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: SmokeProperty.Detected[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: SmokeProperty;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly detected: false;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Binary;
+        readonly stateProperty: SmokeProperty;
+        readonly commandProperty: SmokeProperty;
+        readonly deviceClass: "smoke";
+    };
+};
 
 /**
  * Properties for switch controls
@@ -2870,63 +3353,31 @@ declare class SwitchControl<TStorage extends object = Record<string, any>> exten
      */
     updateValue(property: string, value: unknown): Promise<void>;
 }
-
-/**
- * Properties for temperature sensors
- *
- * @internal
- */
-declare enum TemperatureProperty {
-    /** Current temperature in degrees Celsius */
-    Current = "current"
-}
-/**
- * Property value map for temperature info sensors.
- *
- * @internal
- */
-interface TemperatureInfoProperties {
-    [TemperatureProperty.Current]: number;
-}
-/** Read-only proxy interface for a temperature sensor */
-interface TemperatureInfoLike extends SensorLike {
-    readonly type: SensorType.Temperature;
-    readonly onPropertyChanged: Observable<PropertyChangeOf<TemperatureInfoProperties>>;
-    getValue(property: TemperatureProperty.Current): number | undefined;
-    getValue(property: string): unknown;
-}
-/** Temperature info sensor. Reports current temperature in °C. */
-declare class TemperatureInfo<TStorage extends object = Record<string, any>> extends Sensor<TemperatureInfoProperties, TStorage> {
-    readonly type = SensorType.Temperature;
-    readonly category = SensorCategory.Info;
-    constructor(name?: string);
-    get current(): number;
-    /**
-     * Report a new temperature reading. Clamped to [-270, 100] °C.
-     *
-     * @param value - Temperature reading in degrees Celsius.
-     *
-     * @example
-     * ```ts
-     * temperature.setCurrent(21.5);
-     * ```
-     */
-    setCurrent(value: number): void;
-    /**
-     * Read-only sensor: external writes are ignored. Reading via `setCurrent` is plugin-only.
-     *
-     * Called by the cross-process plugin host when a generic property write is received.
-     * Temperature sensors have no externally writable properties, so the parameters are
-     * unused (underscore-prefixed) and the call is a no-op.
-     *
-     * @param _property - Unused — temperature sensors expose no writable properties.
-     *
-     * @param _value - Unused — temperature sensors expose no writable properties.
-     *
-     * @internal
-     */
-    updateValue(_property: string, _value: unknown): void;
-}
+/** Registry metadata for {@link SwitchControl}. */
+declare const switchMeta: {
+    readonly type: SensorType.Switch;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "switch";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: SwitchProperty.On[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: SwitchProperty;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly on: false;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Switch;
+        readonly stateProperty: SwitchProperty;
+        readonly commandProperty: SwitchProperty;
+    };
+};
 
 /**
  * Receives a partial-state delta (only properties that actually changed). One callback
@@ -2982,7 +3433,7 @@ declare enum SensorType {
     Contact = "contact",
     /** Temperature sensor (°C) */
     Temperature = "temperature",
-    /** Humidity sensor (0–100%) */
+    /** Humidity sensor (0-100%) */
     Humidity = "humidity",
     /** Occupancy/presence sensor */
     Occupancy = "occupancy",
@@ -3327,57 +3778,712 @@ declare abstract class Sensor<TProperties extends object, TStorage extends objec
 }
 
 /**
- * Stable reference to a sensor for cascade trigger configuration.
- * Uses composite key (sensorType + sensorName + pluginId) instead of UUID
- * so references survive plugin restarts.
+ * Properties for temperature sensors
+ *
+ * @internal
  */
-interface SensorTriggerRef {
-    /** Sensor type (e.g. 'contact', 'doorbell') */
-    sensorType: SensorType;
-    /** Sensor name (stable across restarts) */
-    sensorName: string;
-    /** Plugin ID that provides this sensor */
-    pluginId: string;
+declare enum TemperatureProperty {
+    /** Current temperature in degrees Celsius */
+    Current = "current"
 }
 /**
- * Sensor trigger settings (contact, doorbell, switch, light, etc.).
+ * Property value map for temperature info sensors.
+ *
+ * @internal
  */
-interface SensorTriggerSettings {
-    /** Sensor trigger timeout in seconds */
-    timeout: number;
-    /** Sensors that also trigger the detection cascade (in addition to motion/audio) */
-    triggers: SensorTriggerRef[];
+interface TemperatureInfoProperties {
+    [TemperatureProperty.Current]: number;
 }
-/**
- * Detection line configuration.
- * Defines a virtual tripwire for line crossing detection.
- * The two points define grab-handle positions; the actual crossing line
- * is perpendicular through their midpoint.
- */
-interface DetectionLine {
-    /** Line display name */
-    name: string;
-    /** Grab-handle positions (0–100%). Crossing line is perpendicular through midpoint. */
-    points: [Point, Point];
-    /** Which crossing direction(s) trigger events */
-    direction: LineDirection;
-    /** Labels to filter (empty = all labels) */
-    labels: DetectionLabel[];
-    /** Line display color (hex) */
-    color: string;
+/** Read-only proxy interface for a temperature sensor */
+interface TemperatureInfoLike extends SensorLike {
+    readonly type: SensorType.Temperature;
+    readonly onPropertyChanged: Observable<PropertyChangeOf<TemperatureInfoProperties>>;
+    getValue(property: TemperatureProperty.Current): number | undefined;
+    getValue(property: string): unknown;
+}
+/** Temperature info sensor. Reports current temperature in °C. */
+declare class TemperatureInfo<TStorage extends object = Record<string, any>> extends Sensor<TemperatureInfoProperties, TStorage> {
+    readonly type = SensorType.Temperature;
+    readonly category = SensorCategory.Info;
+    constructor(name?: string);
+    get current(): number;
+    /**
+     * Report a new temperature reading. Clamped to [-270, 100] °C.
+     *
+     * @param value - Temperature reading in degrees Celsius.
+     *
+     * @example
+     * ```ts
+     * temperature.setCurrent(21.5);
+     * ```
+     */
+    setCurrent(value: number): void;
+    /**
+     * Read-only sensor: external writes are ignored. Reading via `setCurrent` is plugin-only.
+     *
+     * Called by the cross-process plugin host when a generic property write is received.
+     * Temperature sensors have no externally writable properties, so the parameters are
+     * unused (underscore-prefixed) and the call is a no-op.
+     *
+     * @param _property - Unused — temperature sensors expose no writable properties.
+     *
+     * @param _value - Unused — temperature sensors expose no writable properties.
+     *
+     * @internal
+     */
+    updateValue(_property: string, _value: unknown): void;
 }
+/** Registry metadata for {@link TemperatureInfo}. */
+declare const temperatureMeta: {
+    readonly type: SensorType.Temperature;
+    readonly category: SensorCategory.Info;
+    readonly assignmentKey: "temperature";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: TemperatureProperty.Current[];
+    readonly shortcutable: true;
+    readonly virtual: {
+        readonly properties: {
+            readonly current: 20;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Measurement;
+        readonly stateProperty: TemperatureProperty;
+        readonly commandProperty: TemperatureProperty;
+        readonly deviceClass: "temperature";
+        readonly unit: "°C";
+    };
+};
+
 /**
- * Detection zone configuration.
- * Defines areas that restrict or drop detections.
+ * Property names of a classifier sensor.
+ *
+ * @internal
  */
-interface DetectionZone {
-    /** Zone display name */
-    name: string;
-    /** Polygon points (0-100 percentage coordinates) */
-    points: Point[];
-    /** Intersection detection type */
-    type: ZoneType;
-    /** Include/exclude filter mode */
+declare enum ClassifierProperty {
+    /** Whether any classification result is active. */
+    Detected = "detected",
+    /** List of classification results with labels and confidence. */
+    Detections = "detections",
+    /** Unique labels of the current detections (auto-derived when reporting detections). */
+    Labels = "labels"
+}
+/** A classifier detection result with an open attribute for classifier categories. */
+interface ClassifierDetection extends Detection {
+    /** Classifier category (e.g. `'bird'`, `'delivery'`). Open string for any classifier. */
+    attribute: string;
+    /** Classifier sub-category (e.g. `'woodpecker'`, `'amazon'`). */
+    subAttribute: string;
+}
+/**
+ * Property shape carried by a {@link ClassifierSensor}.
+ *
+ * @internal
+ */
+interface ClassifierSensorProperties {
+    [ClassifierProperty.Detected]: boolean;
+    [ClassifierProperty.Detections]: ClassifierDetection[];
+    [ClassifierProperty.Labels]: string[];
+}
+/** Read-only proxy interface for a classifier sensor. */
+interface ClassifierSensorLike extends SensorLike {
+    /** Sensor type discriminant. */
+    readonly type: SensorType.Classifier;
+    /** Property change observable narrowed to classifier properties. */
+    readonly onPropertyChanged: Observable<PropertyChangeOf<ClassifierSensorProperties>>;
+    getValue(property: ClassifierProperty.Detected): boolean | undefined;
+    getValue(property: ClassifierProperty.Detections): ClassifierDetection[] | undefined;
+    getValue(property: ClassifierProperty.Labels): string[] | undefined;
+    getValue(property: string): unknown;
+}
+/**
+ * General-purpose image classifier sensor.
+ *
+ * Plugin authors call `reportDetections(list)` to push classification results.
+ * `detected` and `labels` are auto-derived from the detection list.
+ */
+declare class ClassifierSensor<TStorage extends object = Record<string, any>> extends Sensor<ClassifierSensorProperties, TStorage> {
+    readonly type = SensorType.Classifier;
+    readonly category = SensorCategory.Sensor;
+    _requiresFrames: boolean;
+    constructor(name?: string);
+    /** Whether any classification result is active. */
+    get detected(): boolean;
+    /** Current detection list. */
+    get detections(): ClassifierDetection[];
+    /** Unique labels of the current detections. */
+    get labels(): string[];
+    /**
+     * Report classification results. Auto-derives `detected` and `labels` from the list.
+     *
+     * - `reportDetections(true)` — generic classification trigger. The SDK
+     *   synthesizes a single full-frame detection with empty attribute/subAttribute.
+     * - `reportDetections(true, [...])` — explicit classifier detections.
+     * - `reportDetections(false)` — clear.
+     *
+     * @param detected - Whether any classification result is active.
+     *
+     * @param detections - Optional explicit classifier detections to publish.
+     *
+     * @example
+     * ```ts
+     * import type { ClassifierDetection } from '@camera.ui/sdk';
+     * sensor.reportDetections(true, [
+     *   {
+     *     label: 'animal',
+     *     confidence: 0.88,
+     *     box: { x: 0.1, y: 0.2, width: 0.3, height: 0.4 },
+     *     attribute: 'bird',
+     *     subAttribute: 'woodpecker',
+     *   } satisfies ClassifierDetection,
+     * ]);
+     * sensor.reportDetections(false);
+     * ```
+     */
+    reportDetections(detected: boolean, detections?: ClassifierDetection[]): void;
+    /**
+     * Explicitly clear classifier state (detected = false, detections = [], labels = []).
+     *
+     * @example
+     * ```ts
+     * sensor.clearDetections();
+     * ```
+     */
+    clearDetections(): void;
+    /**
+     * Read-only sensor: external writes are ignored. State is reported via `reportDetections`.
+     *
+     * Called by the cross-process plugin host when a generic property write is received.
+     * Classifier sensors have no externally writable properties, so the parameters are
+     * unused (underscore-prefixed) and the call is a no-op.
+     *
+     * @param _property - Unused — classifier sensors expose no writable properties.
+     *
+     * @param _value - Unused — classifier sensors expose no writable properties.
+     *
+     * @internal
+     */
+    updateValue(_property: string, _value: unknown): void;
+}
+/** Return type for {@link ClassifierDetectorSensor.detectClassifications}. */
+interface ClassifierResult {
+    /** Whether any classification result is emitted for this frame. */
+    detected: boolean;
+    /** Detections emitted for this frame. */
+    detections: ClassifierDetection[];
+}
+/**
+ * Classifier detector that receives video frames from the backend pipeline.
+ * Extend this class and implement {@link detectClassifications} to run image
+ * classification models against trigger regions.
+ */
+declare abstract class ClassifierDetectorSensor<TStorage extends object = Record<string, any>> extends ClassifierSensor<TStorage> {
+    _requiresFrames: boolean;
+    /** Declares the expected input dimensions and trigger labels. The backend scales frames to match. */
+    abstract get modelSpec(): ModelSpec;
+    /**
+     * Classify frames in batch. Each frame is a pre-cropped, pre-scaled
+     * trigger region produced by the upstream object detector. Must return
+     * exactly one ClassifierResult per input frame, in the same order.
+     */
+    abstract detectClassifications(frames: VideoFrameData[]): Promise<ClassifierResult[]>;
+}
+/** Registry metadata for {@link ClassifierSensor}. */
+declare const classifierMeta: {
+    readonly type: SensorType.Classifier;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "classifier";
+    readonly multiProvider: true;
+    readonly isDetectionType: true;
+    readonly properties: ClassifierProperty[];
+    readonly semantics: null;
+};
+
+/** Every sensor's metadata. A new sensor type adds its meta here. */
+declare const SENSOR_META: readonly [{
+    readonly type: SensorType.Audio;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "audio";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: AudioProperty[];
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Battery;
+    readonly category: SensorCategory.Info;
+    readonly assignmentKey: "battery";
+    readonly multiProvider: false;
+    readonly isDetectionType: false;
+    readonly properties: BatteryProperty[];
+    readonly shortcutable: true;
+    readonly propertyCapabilities: {
+        readonly charging: BatteryCapability.Charging;
+        readonly low: BatteryCapability.LowBattery;
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Measurement;
+        readonly stateProperty: BatteryProperty.Level;
+        readonly commandProperty: BatteryProperty.Level;
+        readonly deviceClass: "battery";
+        readonly unit: "%";
+        readonly diagnostic: true;
+    };
+}, {
+    readonly type: SensorType.Classifier;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "classifier";
+    readonly multiProvider: true;
+    readonly isDetectionType: true;
+    readonly properties: ClassifierProperty[];
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Clip;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "clip";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: readonly [];
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Contact;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "contact";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: ContactProperty.Detected[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: ContactProperty;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly detected: false;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Binary;
+        readonly stateProperty: ContactProperty;
+        readonly commandProperty: ContactProperty;
+        readonly deviceClass: "opening";
+    };
+}, {
+    readonly type: SensorType.Doorbell;
+    readonly category: SensorCategory.Trigger;
+    readonly assignmentKey: "doorbell";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: DoorbellProperty.Ring[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: DoorbellProperty;
+        readonly value: true;
+        readonly sustained: false;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly ring: false;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Binary;
+        readonly stateProperty: DoorbellProperty;
+        readonly commandProperty: DoorbellProperty;
+        readonly icon: "mdi:doorbell";
+    };
+}, {
+    readonly type: SensorType.Face;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "face";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: FaceProperty[];
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Garage;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "garage";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: GarageProperty[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: GarageProperty.CurrentState;
+        readonly value: 0;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly currentState: 1;
+            readonly targetState: 1;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Cover;
+        readonly stateProperty: GarageProperty.CurrentState;
+        readonly commandProperty: GarageProperty.TargetState;
+        readonly deviceClass: "garage";
+        readonly states: {
+            readonly open: GarageState.Open;
+            readonly closed: GarageState.Closed;
+            readonly opening: GarageState.Opening;
+            readonly closing: GarageState.Closing;
+            readonly stopped: GarageState.Stopped;
+        };
+    };
+}, {
+    readonly type: SensorType.Humidity;
+    readonly category: SensorCategory.Info;
+    readonly assignmentKey: "humidity";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: HumidityProperty.Current[];
+    readonly shortcutable: true;
+    readonly virtual: {
+        readonly properties: {
+            readonly current: 50;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Measurement;
+        readonly stateProperty: HumidityProperty;
+        readonly commandProperty: HumidityProperty;
+        readonly deviceClass: "humidity";
+        readonly unit: "%";
+    };
+}, {
+    readonly type: SensorType.Leak;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "leak";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: LeakProperty.Detected[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: LeakProperty;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly detected: false;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Binary;
+        readonly stateProperty: LeakProperty;
+        readonly commandProperty: LeakProperty;
+        readonly deviceClass: "moisture";
+    };
+}, {
+    readonly type: SensorType.LicensePlate;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "licensePlate";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: LicensePlateProperty[];
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Light;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "light";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: LightProperty[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: LightProperty.On;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly propertyCapabilities: {
+        readonly brightness: LightCapability;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly on: false;
+            readonly brightness: 100;
+        };
+        readonly capabilities: readonly [LightCapability];
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Light;
+        readonly stateProperty: LightProperty.On;
+        readonly commandProperty: LightProperty.On;
+    };
+}, {
+    readonly type: SensorType.Lock;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "lock";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: LockProperty[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: LockProperty.CurrentState;
+        readonly value: 1;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly currentState: 0;
+            readonly targetState: 0;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Lock;
+        readonly stateProperty: LockProperty.CurrentState;
+        readonly commandProperty: LockProperty.TargetState;
+        readonly states: {
+            readonly locked: LockState.Secured;
+            readonly unlocked: LockState.Unsecured;
+        };
+    };
+}, {
+    readonly type: SensorType.Motion;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "motion";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: MotionProperty[];
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Object;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "object";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: ObjectProperty[];
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Occupancy;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "occupancy";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: OccupancyProperty.Detected[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: OccupancyProperty;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly detected: false;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Binary;
+        readonly stateProperty: OccupancyProperty;
+        readonly commandProperty: OccupancyProperty;
+        readonly deviceClass: "occupancy";
+    };
+}, {
+    readonly type: SensorType.PTZ;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "ptz";
+    readonly multiProvider: false;
+    readonly isDetectionType: false;
+    readonly properties: PTZProperty[];
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.SecuritySystem;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "securitySystem";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: SecuritySystemProperty[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: SecuritySystemProperty.CurrentState;
+        readonly value: 4;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly currentState: 3;
+            readonly targetState: 3;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Alarm;
+        readonly stateProperty: SecuritySystemProperty.CurrentState;
+        readonly commandProperty: SecuritySystemProperty.TargetState;
+        readonly states: {
+            readonly armed_home: SecuritySystemState.StayArm;
+            readonly armed_away: SecuritySystemState.AwayArm;
+            readonly armed_night: SecuritySystemState.NightArm;
+            readonly disarmed: SecuritySystemState.Disarmed;
+            readonly triggered: SecuritySystemState.AlarmTriggered;
+        };
+    };
+}, {
+    readonly type: SensorType.Siren;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "siren";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: SirenProperty[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: SirenProperty.Active;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly propertyCapabilities: {
+        readonly volume: SirenCapability;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly active: false;
+            readonly volume: 100;
+        };
+        readonly capabilities: readonly [SirenCapability];
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Siren;
+        readonly stateProperty: SirenProperty.Active;
+        readonly commandProperty: SirenProperty.Active;
+    };
+}, {
+    readonly type: SensorType.Smoke;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "smoke";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: SmokeProperty.Detected[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: SmokeProperty;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly detected: false;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Binary;
+        readonly stateProperty: SmokeProperty;
+        readonly commandProperty: SmokeProperty;
+        readonly deviceClass: "smoke";
+    };
+}, {
+    readonly type: SensorType.Switch;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "switch";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: SwitchProperty.On[];
+    readonly shortcutable: true;
+    readonly cascadeTrigger: {
+        readonly property: SwitchProperty;
+        readonly value: true;
+        readonly sustained: true;
+    };
+    readonly virtual: {
+        readonly properties: {
+            readonly on: false;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Switch;
+        readonly stateProperty: SwitchProperty;
+        readonly commandProperty: SwitchProperty;
+    };
+}, {
+    readonly type: SensorType.Temperature;
+    readonly category: SensorCategory.Info;
+    readonly assignmentKey: "temperature";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: TemperatureProperty.Current[];
+    readonly shortcutable: true;
+    readonly virtual: {
+        readonly properties: {
+            readonly current: 20;
+        };
+    };
+    readonly semantics: {
+        readonly domain: SensorDomain.Measurement;
+        readonly stateProperty: TemperatureProperty;
+        readonly commandProperty: TemperatureProperty;
+        readonly deviceClass: "temperature";
+        readonly unit: "°C";
+    };
+}];
+/** Union of every declared assignment key, derived from the registry. */
+type SensorAssignmentKey = (typeof SENSOR_META)[number]['assignmentKey'];
+/**
+ * Looks up a sensor's metadata by its type.
+ *
+ * @param type - The sensor type value.
+ *
+ * @returns The metadata, or `undefined` if no sensor declares that type.
+ *
+ * @example
+ * ```ts
+ * const meta = sensorMeta(SensorType.Light);
+ * ```
+ */
+declare function sensorMeta(type: string): SensorMeta | undefined;
+
+/**
+ * Stable reference to a sensor for cascade trigger configuration.
+ * Uses composite key (sensorType + sensorName + pluginId) instead of UUID
+ * so references survive plugin restarts.
+ */
+interface SensorTriggerRef {
+    /** Sensor type (e.g. 'contact', 'doorbell') */
+    sensorType: SensorType;
+    /** Sensor name (stable across restarts) */
+    sensorName: string;
+    /** Plugin ID that provides this sensor */
+    pluginId: string;
+}
+/**
+ * Sensor trigger settings (contact, doorbell, switch, light, etc.).
+ */
+interface SensorTriggerSettings {
+    /** Sensor trigger timeout in seconds */
+    timeout: number;
+    /** Sensors that also trigger the detection cascade (in addition to motion/audio) */
+    triggers: SensorTriggerRef[];
+}
+/**
+ * Detection line configuration.
+ * Defines a virtual tripwire for line crossing detection.
+ * The two points define grab-handle positions; the actual crossing line
+ * is perpendicular through their midpoint.
+ */
+interface DetectionLine {
+    /** Line display name */
+    name: string;
+    /** Grab-handle positions (0–100%). Crossing line is perpendicular through midpoint. */
+    points: [Point, Point];
+    /** Which crossing direction(s) trigger events */
+    direction: LineDirection;
+    /** Labels to filter (empty = all labels) */
+    labels: DetectionLabel[];
+    /** Line display color (hex) */
+    color: string;
+}
+/**
+ * Detection zone configuration.
+ * Defines areas that restrict or drop detections.
+ */
+interface DetectionZone {
+    /** Zone display name */
+    name: string;
+    /** Polygon points (0-100 percentage coordinates) */
+    points: Point[];
+    /** Intersection detection type */
+    type: ZoneType;
+    /** Include/exclude filter mode */
     filter: ZoneFilter;
     /** Labels to filter (empty = all labels) */
     labels: DetectionLabel[];
@@ -4004,38 +5110,24 @@ interface AssignedPlugin {
     /** Plugin display name */
     name: string;
 }
-/**
- * Plugin assignments for camera sensors/features.
- * Maps sensor types to their assigned plugin(s).
- */
-interface PluginAssignments {
-    /** Motion detection plugin */
-    motion?: AssignedPlugin;
-    /** Object detection plugin */
-    object?: AssignedPlugin;
-    /** Audio detection plugin */
-    audio?: AssignedPlugin;
-    /** Face detection plugin */
-    face?: AssignedPlugin;
-    /** License plate detection plugin */
-    licensePlate?: AssignedPlugin;
-    /** PTZ control plugin */
-    ptz?: AssignedPlugin;
-    /** Battery info plugin */
-    battery?: AssignedPlugin;
-    /** Camera controller plugin */
+/** @internal */
+type SingleProviderAssignmentKey = Extract<(typeof SENSOR_META)[number], {
+    multiProvider: false;
+}>['assignmentKey'];
+/** @internal */
+type MultiProviderAssignmentKey = Extract<(typeof SENSOR_META)[number], {
+    multiProvider: true;
+}>['assignmentKey'];
+/**
+ * Plugin assignments for a camera, keyed by the assignment keys the SDK sensor
+ * registry declares. Single-provider sensors and the camera controller hold one
+ * plugin; multi-provider sensors and the hub hold an array. Derived from the
+ * registry so a new sensor type gains its assignment slot automatically.
+ */
+type PluginAssignments = Partial<Record<SingleProviderAssignmentKey, AssignedPlugin>> & Partial<Record<MultiProviderAssignmentKey, AssignedPlugin[]>> & {
     cameraController?: AssignedPlugin;
-    /** Light control plugins */
-    light?: AssignedPlugin[];
-    /** Siren control plugins */
-    siren?: AssignedPlugin[];
-    /** Contact sensor plugins */
-    contact?: AssignedPlugin[];
-    /** Doorbell trigger plugins */
-    doorbell?: AssignedPlugin[];
-    /** Hub/bridge plugins */
     hub?: AssignedPlugin[];
-}
+};
 /**
  * Camera source plugin information.
  */
@@ -4681,140 +5773,6 @@ interface PluginInfo {
     contract: PluginContract;
 }
 
-/**
- * Property names of a classifier sensor.
- *
- * @internal
- */
-declare enum ClassifierProperty {
-    /** Whether any classification result is active. */
-    Detected = "detected",
-    /** List of classification results with labels and confidence. */
-    Detections = "detections",
-    /** Unique labels of the current detections (auto-derived when reporting detections). */
-    Labels = "labels"
-}
-/** A classifier detection result with an open attribute for classifier categories. */
-interface ClassifierDetection extends Detection {
-    /** Classifier category (e.g. `'bird'`, `'delivery'`). Open string for any classifier. */
-    attribute: string;
-    /** Classifier sub-category (e.g. `'woodpecker'`, `'amazon'`). */
-    subAttribute: string;
-}
-/**
- * Property shape carried by a {@link ClassifierSensor}.
- *
- * @internal
- */
-interface ClassifierSensorProperties {
-    [ClassifierProperty.Detected]: boolean;
-    [ClassifierProperty.Detections]: ClassifierDetection[];
-    [ClassifierProperty.Labels]: string[];
-}
-/** Read-only proxy interface for a classifier sensor. */
-interface ClassifierSensorLike extends SensorLike {
-    /** Sensor type discriminant. */
-    readonly type: SensorType.Classifier;
-    /** Property change observable narrowed to classifier properties. */
-    readonly onPropertyChanged: Observable<PropertyChangeOf<ClassifierSensorProperties>>;
-    getValue(property: ClassifierProperty.Detected): boolean | undefined;
-    getValue(property: ClassifierProperty.Detections): ClassifierDetection[] | undefined;
-    getValue(property: ClassifierProperty.Labels): string[] | undefined;
-    getValue(property: string): unknown;
-}
-/**
- * General-purpose image classifier sensor.
- *
- * Plugin authors call `reportDetections(list)` to push classification results.
- * `detected` and `labels` are auto-derived from the detection list.
- */
-declare class ClassifierSensor<TStorage extends object = Record<string, any>> extends Sensor<ClassifierSensorProperties, TStorage> {
-    readonly type = SensorType.Classifier;
-    readonly category = SensorCategory.Sensor;
-    _requiresFrames: boolean;
-    constructor(name?: string);
-    /** Whether any classification result is active. */
-    get detected(): boolean;
-    /** Current detection list. */
-    get detections(): ClassifierDetection[];
-    /** Unique labels of the current detections. */
-    get labels(): string[];
-    /**
-     * Report classification results. Auto-derives `detected` and `labels` from the list.
-     *
-     * - `reportDetections(true)` — generic classification trigger. The SDK
-     *   synthesizes a single full-frame detection with empty attribute/subAttribute.
-     * - `reportDetections(true, [...])` — explicit classifier detections.
-     * - `reportDetections(false)` — clear.
-     *
-     * @param detected - Whether any classification result is active.
-     *
-     * @param detections - Optional explicit classifier detections to publish.
-     *
-     * @example
-     * ```ts
-     * import type { ClassifierDetection } from '@camera.ui/sdk';
-     * sensor.reportDetections(true, [
-     *   {
-     *     label: 'animal',
-     *     confidence: 0.88,
-     *     box: { x: 0.1, y: 0.2, width: 0.3, height: 0.4 },
-     *     attribute: 'bird',
-     *     subAttribute: 'woodpecker',
-     *   } satisfies ClassifierDetection,
-     * ]);
-     * sensor.reportDetections(false);
-     * ```
-     */
-    reportDetections(detected: boolean, detections?: ClassifierDetection[]): void;
-    /**
-     * Explicitly clear classifier state (detected = false, detections = [], labels = []).
-     *
-     * @example
-     * ```ts
-     * sensor.clearDetections();
-     * ```
-     */
-    clearDetections(): void;
-    /**
-     * Read-only sensor: external writes are ignored. State is reported via `reportDetections`.
-     *
-     * Called by the cross-process plugin host when a generic property write is received.
-     * Classifier sensors have no externally writable properties, so the parameters are
-     * unused (underscore-prefixed) and the call is a no-op.
-     *
-     * @param _property - Unused — classifier sensors expose no writable properties.
-     *
-     * @param _value - Unused — classifier sensors expose no writable properties.
-     *
-     * @internal
-     */
-    updateValue(_property: string, _value: unknown): void;
-}
-/** Return type for {@link ClassifierDetectorSensor.detectClassifications}. */
-interface ClassifierResult {
-    /** Whether any classification result is emitted for this frame. */
-    detected: boolean;
-    /** Detections emitted for this frame. */
-    detections: ClassifierDetection[];
-}
-/**
- * Classifier detector that receives video frames from the backend pipeline.
- * Extend this class and implement {@link detectClassifications} to run image
- * classification models against trigger regions.
- */
-declare abstract class ClassifierDetectorSensor<TStorage extends object = Record<string, any>> extends ClassifierSensor<TStorage> {
-    _requiresFrames: boolean;
-    /** Declares the expected input dimensions and trigger labels. The backend scales frames to match. */
-    abstract get modelSpec(): ModelSpec;
-    /**
-     * Classify frames in batch. Each frame is a pre-cropped, pre-scaled
-     * trigger region produced by the upstream object detector. Must return
-     * exactly one ClassifierResult per input frame, in the same order.
-     */
-    abstract detectClassifications(frames: VideoFrameData[]): Promise<ClassifierResult[]>;
-}
-
 /** A CLIP embedding result for a detected region. */
 interface ClipEmbedding {
     /** Detection label this embedding was computed for (e.g. `'person'`, `'vehicle'`). */
@@ -4865,6 +5823,16 @@ declare abstract class ClipDetectorSensor<TStorage extends object = Record<strin
      */
     updateValue(_property: string, _value: unknown): void;
 }
+/** Registry metadata for {@link ClipDetectorSensor}. */
+declare const clipMeta: {
+    readonly type: SensorType.Clip;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "clip";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: readonly [];
+    readonly semantics: null;
+};
 
 /**
  * Lifecycle events emitted on the PluginAPI EventEmitter. Plugins subscribe
@@ -5847,5 +6815,5 @@ interface OAuthClientCredentialsCapable extends OAuthCapable {
     configureClientCredentials(clientId: string, clientSecret: string): Promise<OAuthState>;
 }
 
-export { API_EVENT, AudioDetectorSensor, AudioProperty, AudioSensor, BASE_AUDIO_LABELS, BasePlugin, BatteryCapability, BatteryInfo, BatteryProperty, BehaviorSubject, ChargingState, ClassifierDetectorSensor, ClassifierProperty, ClassifierSensor, ClipDetectorSensor, ContactProperty, ContactSensor, DETECTION_ATTRIBUTES, DETECTION_LABELS, Disposable, DoorbellProperty, DoorbellTrigger, EVENT_TRIGGER_TYPES, FaceDetectorSensor, FaceProperty, FaceSensor, GarageControl, GarageProperty, GarageState, HumidityInfo, HumidityProperty, LeakProperty, LeakSensor, LicensePlateDetectorSensor, LicensePlateProperty, LicensePlateSensor, LightCapability, LightControl, LightProperty, LockControl, LockProperty, LockState, MotionDetectorSensor, MotionProperty, MotionSensor, ObjectDetectorSensor, ObjectProperty, ObjectSensor, Observable, OccupancyProperty, OccupancySensor, PTZCapability, PTZControl, PTZProperty, PluginCapability, PluginInterface, PluginRole, RING_AUTO_RESET_MS, ReplaySubject, RtpPacket, SecuritySystem, SecuritySystemProperty, SecuritySystemState, Sensor, SensorCategory, SensorType, Severity, SirenCapability, SirenControl, SirenProperty, SmokeProperty, SmokeSensor, Subject, SwitchControl, SwitchProperty, TemperatureInfo, TemperatureProperty, canCreateCameras, canProvideSensorsToAnyCameras, distinctUntilChanged, filter, firstValueFrom, getContractValidationErrors, hasCapability, hasInterface, isHub, map, mergeMap, pairwise, share, validateContractConsistency };
-export type { AssignedPlugin, AudioCodec, AudioCodecProperties, AudioDetectionInterface, AudioDetectionPluginResponse, AudioDetectionSettings, AudioFFmpegCodec, AudioFrameData, AudioInputSpec, AudioLabel, AudioMetadata, AudioModelSpec, AudioResult, AudioSensorLike, AudioSensorProperties, AudioStreamInfo, BaseAudioLabel, BaseCamera, BaseCameraConfig, BatteryInfoLike, BatteryInfoProperties, BoundingBox, Camera, CameraAspectRatio, CameraAspectRatioPreset, CameraConfig, CameraConfigInputSettings, CameraDetectionSettings, CameraDevice, CameraDeviceSource, CameraFrameWorkerSettings, CameraImplementation, CameraInformation, CameraInput, CameraPluginInfo, CameraRole, CameraSource, CameraType, CameraUiSettings, ClassifierDetection, ClassifierDetectionInterface, ClassifierDetectionPluginResponse, ClassifierResult, ClassifierSensorLike, ClassifierSensorProperties, ClipDetectionInterface, ClipDetectionPluginResponse, ClipEmbedding, ClipResult, ClipTextEmbeddingResult, ContactSensorLike, ContactSensorProperties, CoreManager, CoreManagerEvent, CreateDownloadOptions, CreateStreamDownloadOptions, Detection, DetectionAttribute, DetectionEvent, DetectionEventState, DetectionEventType, DetectionLabel, DetectionLine, DetectionZone, DeviceManager, DeviceStorage, DiscoveredCamera, DiscoveryProvider, DoorbellTriggerLike, DoorbellTriggerProperties, DownloadCleanup, DownloadManager, DownloadToken, EventAttribute, EventDescription, EventDetection, EventSegment, EventTrigger, EventTriggerType, FMTPInfo, FaceDetection, FaceDetectionInterface, FaceDetectionPluginResponse, FaceResult, FaceSensorLike, FaceSensorProperties, Fmp4Session, Fmp4SessionOptions, FormSubmitResponse, FormSubmitSchema, GarageControlLike, GarageControlProperties, Go2RtcRTSPSource, Go2RtcSnapshotSource, Go2RtcWSSource, HardwareAcceleration, HumidityInfoLike, HumidityInfoProperties, ImageMetadata, JsonArraySchema, JsonBaseSchema, JsonBaseSchemaWithoutCallbacks, JsonBooleanSchema, JsonEnumSchema, JsonFactorySchema, JsonNumberSchema, JsonSchema, JsonSchemaArray, JsonSchemaArrayWithoutCallbacks, JsonSchemaBoolean, JsonSchemaBooleanWithoutCallbacks, JsonSchemaButton, JsonSchemaEnum, JsonSchemaEnumWithoutCallbacks, JsonSchemaNumber, JsonSchemaNumberWithoutCallbacks, JsonSchemaString, JsonSchemaStringWithoutCallbacks, JsonSchemaSubmit, JsonSchemaType, JsonSchemaWithoutCallbacks, JsonSchemaWithoutKey, JsonStringSchema, LeakSensorLike, LeakSensorProperties, LicensePlateDetection, LicensePlateDetectionInterface, LicensePlateDetectionPluginResponse, LicensePlateResult, LicensePlateSensorLike, LicensePlateSensorProperties, LightControlLike, LightControlProperties, LineDirection, LockControlLike, LockControlProperties, LoggerService, ModelSpec, MotionDetectionInterface, MotionDetectionPluginResponse, MotionDetectionSettings, MotionResolution, MotionResult, MotionSensorLike, MotionSensorProperties, Notification, NotificationManager, NotifierDevice, NotifierInterface, OAuthAuthCodeFlowCapable, OAuthCapable, OAuthClientCredentialsCapable, OAuthDeviceFlowCapable, OAuthMetadata, OAuthProviderConfig, OAuthProviderDeclaration, OAuthState, OAuthStatus, ObjectDetectionInterface, ObjectDetectionPluginResponse, ObjectDetectionSettings, ObjectModelSpec, ObjectResult, ObjectSensorLike, ObjectSensorProperties, OccupancySensorLike, OccupancySensorProperties, OperatorFn, PTZControlLike, PTZControlProperties, PTZDirection, PTZPosition, PTZRelativeMove, PluginAPI, PluginAssignments, PluginConfig, PluginContract, PluginInfo, PluginInterfaces, Point, ProbeAudioCodec, ProbeConfig, ProbeStream, PropertyChangeOf, PtzAutotrackSettings, PythonVersion, RTPInfo, RTSPAudioCodec, RTSPUrlOptions, RtpSession, RtpSessionBackchannelOptions, RtpSessionOptions, SchemaCondition, SchemaConditionOperator, SchemaConfig, SecuritySystemLike, SecuritySystemProperties, SensorCapability, SensorLike, SensorPropertyType, SensorTriggerRef, SensorTriggerSettings, SirenControlLike, SirenControlProperties, SmokeSensorLike, SmokeSensorProperties, SnapshotInterface, SnapshotSettings, SnapshotUrlOptions, StreamDirection, StreamUrls, StreamingInterface, StreamingRole, SwitchControlLike, SwitchControlProperties, TemperatureInfoLike, TemperatureInfoProperties, ToastMessage, TrackedDetection, VideoCodec, VideoCodecProperties, VideoFFmpegCodec, VideoFrameData, VideoInputSpec, VideoStreamInfo, VideoStreamingMode, ZoneFilter, ZoneType };
+export { API_EVENT, AudioDetectorSensor, AudioProperty, AudioSensor, BASE_AUDIO_LABELS, BasePlugin, BatteryCapability, BatteryInfo, BatteryProperty, BehaviorSubject, ChargingState, ClassifierDetectorSensor, ClassifierProperty, ClassifierSensor, ClipDetectorSensor, ContactProperty, ContactSensor, DETECTION_ATTRIBUTES, DETECTION_LABELS, Disposable, DoorbellProperty, DoorbellTrigger, EVENT_TRIGGER_TYPES, FaceDetectorSensor, FaceProperty, FaceSensor, GarageControl, GarageProperty, GarageState, HumidityInfo, HumidityProperty, LeakProperty, LeakSensor, LicensePlateDetectorSensor, LicensePlateProperty, LicensePlateSensor, LightCapability, LightControl, LightProperty, LockControl, LockProperty, LockState, MotionDetectorSensor, MotionProperty, MotionSensor, OBJECT_DETECTION_LABELS, ObjectDetectorSensor, ObjectProperty, ObjectSensor, Observable, OccupancyProperty, OccupancySensor, PTZCapability, PTZControl, PTZProperty, PluginCapability, PluginInterface, PluginRole, RING_AUTO_RESET_MS, ReplaySubject, RtpPacket, SENSOR_META, SecuritySystem, SecuritySystemProperty, SecuritySystemState, Sensor, SensorCategory, SensorDomain, SensorType, Severity, SirenCapability, SirenControl, SirenProperty, SmokeProperty, SmokeSensor, Subject, SwitchControl, SwitchProperty, TemperatureInfo, TemperatureProperty, audioMeta, batteryMeta, canCreateCameras, canProvideSensorsToAnyCameras, classifierMeta, clipMeta, contactMeta, defineSensor, distinctUntilChanged, doorbellMeta, faceMeta, filter, firstValueFrom, garageMeta, getContractValidationErrors, hasCapability, hasInterface, humidityMeta, isHub, leakMeta, licensePlateMeta, lightMeta, lockMeta, map, mergeMap, motionMeta, objectMeta, occupancyMeta, pairwise, ptzMeta, securitySystemMeta, sensorMeta, share, sirenMeta, smokeMeta, switchMeta, temperatureMeta, validateContractConsistency };
+export type { AssignedPlugin, AudioCodec, AudioCodecProperties, AudioDetectionInterface, AudioDetectionPluginResponse, AudioDetectionSettings, AudioFFmpegCodec, AudioFrameData, AudioInputSpec, AudioLabel, AudioMetadata, AudioModelSpec, AudioResult, AudioSensorLike, AudioSensorProperties, AudioStreamInfo, BaseAudioLabel, BaseCamera, BaseCameraConfig, BatteryInfoLike, BatteryInfoProperties, BoundingBox, Camera, CameraAspectRatio, CameraAspectRatioPreset, CameraConfig, CameraConfigInputSettings, CameraDetectionSettings, CameraDevice, CameraDeviceSource, CameraFrameWorkerSettings, CameraImplementation, CameraInformation, CameraInput, CameraPluginInfo, CameraRole, CameraSource, CameraType, CameraUiSettings, ClassifierDetection, ClassifierDetectionInterface, ClassifierDetectionPluginResponse, ClassifierResult, ClassifierSensorLike, ClassifierSensorProperties, ClipDetectionInterface, ClipDetectionPluginResponse, ClipEmbedding, ClipResult, ClipTextEmbeddingResult, ContactSensorLike, ContactSensorProperties, CoreManager, CoreManagerEvent, CreateDownloadOptions, CreateStreamDownloadOptions, Detection, DetectionAttribute, DetectionEvent, DetectionEventState, DetectionEventType, DetectionLabel, DetectionLine, DetectionZone, DeviceManager, DeviceStorage, DiscoveredCamera, DiscoveryProvider, DoorbellTriggerLike, DoorbellTriggerProperties, DownloadCleanup, DownloadManager, DownloadToken, EventAttribute, EventDescription, EventDetection, EventSegment, EventTrigger, EventTriggerType, FMTPInfo, FaceDetection, FaceDetectionInterface, FaceDetectionPluginResponse, FaceResult, FaceSensorLike, FaceSensorProperties, Fmp4Session, Fmp4SessionOptions, FormSubmitResponse, FormSubmitSchema, GarageControlLike, GarageControlProperties, Go2RtcRTSPSource, Go2RtcSnapshotSource, Go2RtcWSSource, HardwareAcceleration, HumidityInfoLike, HumidityInfoProperties, ImageMetadata, JsonArraySchema, JsonBaseSchema, JsonBaseSchemaWithoutCallbacks, JsonBooleanSchema, JsonEnumSchema, JsonFactorySchema, JsonNumberSchema, JsonSchema, JsonSchemaArray, JsonSchemaArrayWithoutCallbacks, JsonSchemaBoolean, JsonSchemaBooleanWithoutCallbacks, JsonSchemaButton, JsonSchemaEnum, JsonSchemaEnumWithoutCallbacks, JsonSchemaNumber, JsonSchemaNumberWithoutCallbacks, JsonSchemaString, JsonSchemaStringWithoutCallbacks, JsonSchemaSubmit, JsonSchemaType, JsonSchemaWithoutCallbacks, JsonSchemaWithoutKey, JsonStringSchema, LeakSensorLike, LeakSensorProperties, LicensePlateDetection, LicensePlateDetectionInterface, LicensePlateDetectionPluginResponse, LicensePlateResult, LicensePlateSensorLike, LicensePlateSensorProperties, LightControlLike, LightControlProperties, LineDirection, LockControlLike, LockControlProperties, LoggerService, ModelSpec, MotionDetectionInterface, MotionDetectionPluginResponse, MotionDetectionSettings, MotionResolution, MotionResult, MotionSensorLike, MotionSensorProperties, Notification, NotificationManager, NotifierDevice, NotifierInterface, OAuthAuthCodeFlowCapable, OAuthCapable, OAuthClientCredentialsCapable, OAuthDeviceFlowCapable, OAuthMetadata, OAuthProviderConfig, OAuthProviderDeclaration, OAuthState, OAuthStatus, ObjectDetectionInterface, ObjectDetectionLabel, ObjectDetectionPluginResponse, ObjectDetectionSettings, ObjectModelSpec, ObjectResult, ObjectSensorLike, ObjectSensorProperties, OccupancySensorLike, OccupancySensorProperties, OperatorFn, PTZControlLike, PTZControlProperties, PTZDirection, PTZPosition, PTZRelativeMove, PluginAPI, PluginAssignments, PluginConfig, PluginContract, PluginInfo, PluginInterfaces, Point, ProbeAudioCodec, ProbeConfig, ProbeStream, PropertyChangeOf, PtzAutotrackSettings, PythonVersion, RTPInfo, RTSPAudioCodec, RTSPUrlOptions, RtpSession, RtpSessionBackchannelOptions, RtpSessionOptions, SchemaCondition, SchemaConditionOperator, SchemaConfig, SecuritySystemLike, SecuritySystemProperties, SensorAssignmentKey, SensorCapability, SensorCascadeTrigger, SensorLike, SensorMeta, SensorPropertyType, SensorSemantics, SensorTriggerRef, SensorTriggerSettings, SensorVirtualDefaults, SirenControlLike, SirenControlProperties, SmokeSensorLike, SmokeSensorProperties, SnapshotInterface, SnapshotSettings, SnapshotUrlOptions, StreamDirection, StreamUrls, StreamingInterface, StreamingRole, SwitchControlLike, SwitchControlProperties, TemperatureInfoLike, TemperatureInfoProperties, ToastMessage, TrackedDetection, VideoCodec, VideoCodecProperties, VideoFFmpegCodec, VideoFrameData, VideoInputSpec, VideoStreamInfo, VideoStreamingMode, ZoneFilter, ZoneType };