@camera.ui/sdk 0.0.24 → 0.0.26

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,137 @@ 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: {
+        readonly detected: {
+            readonly type: "boolean";
+        };
+        readonly detections: {
+            readonly type: "object";
+            readonly internal: true;
+        };
+        readonly decibels: {
+            readonly type: "number";
+            readonly unit: "dB";
+        };
+        readonly lastTriggered: {
+            readonly type: "number";
+            readonly internal: true;
+        };
+    };
+    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[];
+}
+/** Runtime value type of a sensor property. */
+type SensorPropertyValueType = 'boolean' | 'number' | 'string' | 'enum' | 'object';
+/**
+ * Per-property value description: what type a property carries, its possible
+ * enum values or numeric range, and whether it is a command or an internal
+ * detail. Consumers (automation pickers, value editors) render from this
+ * instead of hand-maintained tables.
+ */
+interface SensorPropertySpec {
+    readonly type: SensorPropertyValueType;
+    /** Enum properties: value-name → wire value. Names double as i18n key stems. */
+    readonly values?: Readonly<Record<string, string | number>>;
+    /** Object properties: scalar member keys, exposed as value-path variables. */
+    readonly keys?: readonly string[];
+    readonly min?: number;
+    readonly max?: number;
+    readonly unit?: string;
+    /** Accepts external writes (commands, target states, virtual sensor state). */
+    readonly writable?: boolean;
+    /** Not an observable state: hidden from trigger/condition pickers. */
+    readonly internal?: boolean;
+}
+/** 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<Record<string, SensorPropertySpec>>;
+    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 +1251,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 +1305,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 +1351,47 @@ 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: {
+        readonly level: {
+            readonly type: "number";
+            readonly min: 0;
+            readonly max: 100;
+            readonly unit: "%";
+        };
+        readonly charging: {
+            readonly type: "enum";
+            readonly values: {
+                readonly not_chargeable: ChargingState.NotChargeable;
+                readonly not_charging: ChargingState.NotCharging;
+                readonly charging: ChargingState.Charging;
+                readonly full: ChargingState.Full;
+            };
+        };
+        readonly low: {
+            readonly type: "boolean";
+        };
+    };
+    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 +1449,37 @@ 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: {
+        readonly detected: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+    };
+    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 +1547,37 @@ 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: {
+        readonly ring: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+    };
+    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 +1712,24 @@ 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: {
+        readonly detected: {
+            readonly type: "boolean";
+        };
+        readonly detections: {
+            readonly type: "object";
+            readonly internal: true;
+        };
+    };
+    readonly semantics: null;
+};
 
 /** Garage door states (HomeKit-compatible values) */
 declare enum GarageState {
@@ -1585,6 +1841,62 @@ 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: {
+        readonly currentState: {
+            readonly type: "enum";
+            readonly values: {
+                readonly open: GarageState.Open;
+                readonly closed: GarageState.Closed;
+                readonly opening: GarageState.Opening;
+                readonly closing: GarageState.Closing;
+                readonly stopped: GarageState.Stopped;
+            };
+        };
+        readonly targetState: {
+            readonly type: "enum";
+            readonly values: {
+                readonly open: GarageState.Open;
+                readonly closed: GarageState.Closed;
+            };
+            readonly writable: true;
+        };
+        readonly obstructionDetected: {
+            readonly type: "boolean";
+        };
+    };
+    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 +1904,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 +1931,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 +1954,36 @@ 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: {
+        readonly current: {
+            readonly type: "number";
+            readonly min: 0;
+            readonly max: 100;
+            readonly unit: "%";
+            readonly writable: true;
+        };
+    };
+    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 +2041,37 @@ 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: {
+        readonly detected: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+    };
+    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 +2199,28 @@ 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: {
+        readonly detected: {
+            readonly type: "boolean";
+        };
+        readonly detections: {
+            readonly type: "object";
+            readonly internal: true;
+        };
+    };
+    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 +2231,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 +2293,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 +2314,48 @@ 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: {
+        readonly on: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+        readonly brightness: {
+            readonly type: "number";
+            readonly min: 0;
+            readonly max: 100;
+            readonly unit: "%";
+            readonly writable: true;
+        };
+    };
+    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 +2448,53 @@ 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: {
+        readonly currentState: {
+            readonly type: "enum";
+            readonly values: {
+                readonly secured: LockState.Secured;
+                readonly unsecured: LockState.Unsecured;
+                readonly unknown: LockState.Unknown;
+            };
+        };
+        readonly targetState: {
+            readonly type: "enum";
+            readonly values: {
+                readonly secured: LockState.Secured;
+                readonly unsecured: LockState.Unsecured;
+            };
+            readonly writable: true;
+        };
+    };
+    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 +2619,32 @@ 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: {
+        readonly detected: {
+            readonly type: "boolean";
+        };
+        readonly detections: {
+            readonly type: "object";
+            readonly internal: true;
+        };
+        readonly blocked: {
+            readonly type: "boolean";
+            readonly internal: true;
+        };
+        readonly lastTriggered: {
+            readonly type: "number";
+            readonly internal: true;
+        };
+    };
+    readonly semantics: null;
+};
 
 /**
  * Property names of an object detection sensor.
@@ -2282,6 +2788,27 @@ 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: {
+        readonly detected: {
+            readonly type: "boolean";
+        };
+        readonly detections: {
+            readonly type: "object";
+            readonly internal: true;
+        };
+        readonly labels: {
+            readonly type: "object";
+        };
+    };
+    readonly semantics: null;
+};
 
 /**
  * Properties for occupancy sensors
@@ -2339,11 +2866,45 @@ 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: {
+        readonly detected: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+    };
+    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 +2934,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 +3109,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 +3119,47 @@ 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: {
+        readonly position: {
+            readonly type: "object";
+            readonly writable: true;
+            readonly keys: readonly ["pan", "tilt", "zoom"];
+        };
+        readonly moving: {
+            readonly type: "boolean";
+        };
+        readonly presets: {
+            readonly type: "object";
+        };
+        readonly velocity: {
+            readonly type: "object";
+            readonly writable: true;
+            readonly internal: true;
+        };
+        readonly targetPreset: {
+            readonly type: "string";
+            readonly writable: true;
+        };
+        readonly relativeMove: {
+            readonly type: "object";
+            readonly writable: true;
+            readonly internal: true;
+        };
+        readonly home: {
+            readonly type: "boolean";
+            readonly writable: true;
+            readonly internal: true;
+        };
+    };
+    readonly semantics: null;
+};
 
 /** Security system arm/disarm states (HomeKit-compatible values) */
 declare enum SecuritySystemState {
@@ -2652,10 +3256,64 @@ 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: {
+        readonly currentState: {
+            readonly type: "enum";
+            readonly values: {
+                readonly stay_arm: SecuritySystemState.StayArm;
+                readonly away_arm: SecuritySystemState.AwayArm;
+                readonly night_arm: SecuritySystemState.NightArm;
+                readonly disarmed: SecuritySystemState.Disarmed;
+                readonly alarm_triggered: SecuritySystemState.AlarmTriggered;
+            };
+        };
+        readonly targetState: {
+            readonly type: "enum";
+            readonly values: {
+                readonly stay_arm: SecuritySystemState.StayArm;
+                readonly away_arm: SecuritySystemState.AwayArm;
+                readonly night_arm: SecuritySystemState.NightArm;
+                readonly disarmed: SecuritySystemState.Disarmed;
+            };
+            readonly writable: true;
+        };
+    };
+    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 +3324,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 +3381,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 +3402,48 @@ 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: {
+        readonly active: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+        readonly volume: {
+            readonly type: "number";
+            readonly min: 0;
+            readonly max: 100;
+            readonly unit: "%";
+            readonly writable: true;
+        };
+    };
+    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 +3501,37 @@ 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: {
+        readonly detected: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+    };
+    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 +3601,36 @@ 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: {
+        readonly on: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+    };
+    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 +3686,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",
@@ -3326,6 +4030,771 @@ declare abstract class Sensor<TProperties extends object, TStorage extends objec
     private _notifyListeners;
 }
 
+/**
+ * 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 TemperatureInfo}. */
+declare const temperatureMeta: {
+    readonly type: SensorType.Temperature;
+    readonly category: SensorCategory.Info;
+    readonly assignmentKey: "temperature";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: {
+        readonly current: {
+            readonly type: "number";
+            readonly unit: "°C";
+            readonly writable: true;
+        };
+    };
+    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";
+    };
+};
+
+/** 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: {
+        readonly detected: {
+            readonly type: "boolean";
+        };
+        readonly detections: {
+            readonly type: "object";
+            readonly internal: true;
+        };
+        readonly decibels: {
+            readonly type: "number";
+            readonly unit: "dB";
+        };
+        readonly lastTriggered: {
+            readonly type: "number";
+            readonly internal: true;
+        };
+    };
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Battery;
+    readonly category: SensorCategory.Info;
+    readonly assignmentKey: "battery";
+    readonly multiProvider: false;
+    readonly isDetectionType: false;
+    readonly properties: {
+        readonly level: {
+            readonly type: "number";
+            readonly min: 0;
+            readonly max: 100;
+            readonly unit: "%";
+        };
+        readonly charging: {
+            readonly type: "enum";
+            readonly values: {
+                readonly not_chargeable: ChargingState.NotChargeable;
+                readonly not_charging: ChargingState.NotCharging;
+                readonly charging: ChargingState.Charging;
+                readonly full: ChargingState.Full;
+            };
+        };
+        readonly low: {
+            readonly type: "boolean";
+        };
+    };
+    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: {
+        readonly detected: {
+            readonly type: "boolean";
+        };
+        readonly detections: {
+            readonly type: "object";
+            readonly internal: true;
+        };
+        readonly labels: {
+            readonly type: "object";
+        };
+    };
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Clip;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "clip";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: {};
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Contact;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "contact";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: {
+        readonly detected: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+    };
+    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: {
+        readonly ring: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+    };
+    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: {
+        readonly detected: {
+            readonly type: "boolean";
+        };
+        readonly detections: {
+            readonly type: "object";
+            readonly internal: true;
+        };
+    };
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Garage;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "garage";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: {
+        readonly currentState: {
+            readonly type: "enum";
+            readonly values: {
+                readonly open: GarageState.Open;
+                readonly closed: GarageState.Closed;
+                readonly opening: GarageState.Opening;
+                readonly closing: GarageState.Closing;
+                readonly stopped: GarageState.Stopped;
+            };
+        };
+        readonly targetState: {
+            readonly type: "enum";
+            readonly values: {
+                readonly open: GarageState.Open;
+                readonly closed: GarageState.Closed;
+            };
+            readonly writable: true;
+        };
+        readonly obstructionDetected: {
+            readonly type: "boolean";
+        };
+    };
+    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: {
+        readonly current: {
+            readonly type: "number";
+            readonly min: 0;
+            readonly max: 100;
+            readonly unit: "%";
+            readonly writable: true;
+        };
+    };
+    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: {
+        readonly detected: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+    };
+    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: {
+        readonly detected: {
+            readonly type: "boolean";
+        };
+        readonly detections: {
+            readonly type: "object";
+            readonly internal: true;
+        };
+    };
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Light;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "light";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: {
+        readonly on: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+        readonly brightness: {
+            readonly type: "number";
+            readonly min: 0;
+            readonly max: 100;
+            readonly unit: "%";
+            readonly writable: true;
+        };
+    };
+    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: {
+        readonly currentState: {
+            readonly type: "enum";
+            readonly values: {
+                readonly secured: LockState.Secured;
+                readonly unsecured: LockState.Unsecured;
+                readonly unknown: LockState.Unknown;
+            };
+        };
+        readonly targetState: {
+            readonly type: "enum";
+            readonly values: {
+                readonly secured: LockState.Secured;
+                readonly unsecured: LockState.Unsecured;
+            };
+            readonly writable: true;
+        };
+    };
+    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: {
+        readonly detected: {
+            readonly type: "boolean";
+        };
+        readonly detections: {
+            readonly type: "object";
+            readonly internal: true;
+        };
+        readonly blocked: {
+            readonly type: "boolean";
+            readonly internal: true;
+        };
+        readonly lastTriggered: {
+            readonly type: "number";
+            readonly internal: true;
+        };
+    };
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Object;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "object";
+    readonly multiProvider: false;
+    readonly isDetectionType: true;
+    readonly properties: {
+        readonly detected: {
+            readonly type: "boolean";
+        };
+        readonly detections: {
+            readonly type: "object";
+            readonly internal: true;
+        };
+        readonly labels: {
+            readonly type: "object";
+        };
+    };
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.Occupancy;
+    readonly category: SensorCategory.Sensor;
+    readonly assignmentKey: "occupancy";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: {
+        readonly detected: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+    };
+    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: {
+        readonly position: {
+            readonly type: "object";
+            readonly writable: true;
+            readonly keys: readonly ["pan", "tilt", "zoom"];
+        };
+        readonly moving: {
+            readonly type: "boolean";
+        };
+        readonly presets: {
+            readonly type: "object";
+        };
+        readonly velocity: {
+            readonly type: "object";
+            readonly writable: true;
+            readonly internal: true;
+        };
+        readonly targetPreset: {
+            readonly type: "string";
+            readonly writable: true;
+        };
+        readonly relativeMove: {
+            readonly type: "object";
+            readonly writable: true;
+            readonly internal: true;
+        };
+        readonly home: {
+            readonly type: "boolean";
+            readonly writable: true;
+            readonly internal: true;
+        };
+    };
+    readonly semantics: null;
+}, {
+    readonly type: SensorType.SecuritySystem;
+    readonly category: SensorCategory.Control;
+    readonly assignmentKey: "securitySystem";
+    readonly multiProvider: true;
+    readonly isDetectionType: false;
+    readonly properties: {
+        readonly currentState: {
+            readonly type: "enum";
+            readonly values: {
+                readonly stay_arm: SecuritySystemState.StayArm;
+                readonly away_arm: SecuritySystemState.AwayArm;
+                readonly night_arm: SecuritySystemState.NightArm;
+                readonly disarmed: SecuritySystemState.Disarmed;
+                readonly alarm_triggered: SecuritySystemState.AlarmTriggered;
+            };
+        };
+        readonly targetState: {
+            readonly type: "enum";
+            readonly values: {
+                readonly stay_arm: SecuritySystemState.StayArm;
+                readonly away_arm: SecuritySystemState.AwayArm;
+                readonly night_arm: SecuritySystemState.NightArm;
+                readonly disarmed: SecuritySystemState.Disarmed;
+            };
+            readonly writable: true;
+        };
+    };
+    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: {
+        readonly active: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+        readonly volume: {
+            readonly type: "number";
+            readonly min: 0;
+            readonly max: 100;
+            readonly unit: "%";
+            readonly writable: true;
+        };
+    };
+    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: {
+        readonly detected: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+    };
+    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: {
+        readonly on: {
+            readonly type: "boolean";
+            readonly writable: true;
+        };
+    };
+    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: {
+        readonly current: {
+            readonly type: "number";
+            readonly unit: "°C";
+            readonly writable: true;
+        };
+    };
+    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
@@ -4004,38 +5473,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.
  */
@@ -4814,6 +6269,27 @@ declare abstract class ClassifierDetectorSensor<TStorage extends object = Record
      */
     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: {
+        readonly detected: {
+            readonly type: "boolean";
+        };
+        readonly detections: {
+            readonly type: "object";
+            readonly internal: true;
+        };
+        readonly labels: {
+            readonly type: "object";
+        };
+    };
+    readonly semantics: null;
+};
 
 /** A CLIP embedding result for a detected region. */
 interface ClipEmbedding {
@@ -4865,6 +6341,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 semantics: null;
+};
 
 /**
  * Lifecycle events emitted on the PluginAPI EventEmitter. Plugins subscribe
@@ -5847,5 +7333,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, SensorPropertySpec, SensorPropertyType, SensorPropertyValueType, 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 };