@camera.ui/sdk 0.0.1

package/dist/sensor/face.js

@@ -0,0 +1,124 @@
+import { Sensor } from './base.js';
+import { SensorCategory, SensorType } from './types.js';
+/**
+ * Face sensor property keys
+ */
+export var FaceProperty;
+(function (FaceProperty) {
+    FaceProperty["Detected"] = "detected";
+    FaceProperty["Faces"] = "faces";
+})(FaceProperty || (FaceProperty = {}));
+/**
+ * Face Sensor (Specialized)
+ *
+ * Detects and recognizes faces in camera frames.
+ * Can optionally receive person regions from ObjectSensor for focused detection.
+ */
+export class FaceSensor extends Sensor {
+    type = SensorType.Face;
+    category = SensorCategory.Sensor;
+    name;
+    constructor(name = 'Face Sensor') {
+        super();
+        this.name = name;
+        // Initialize defaults
+        this.props.detected = false;
+        this.props.faces = [];
+    }
+    // ========== Properties (Getter/Setter Pairs) ==========
+    /** Whether faces are currently detected */
+    get detected() {
+        return this.rawProps.detected;
+    }
+    /** Set face detected state */
+    set detected(value) {
+        this.props.detected = value;
+    }
+    /** Current face detections */
+    get faces() {
+        return this.rawProps.faces;
+    }
+    /** Set face detections */
+    set faces(value) {
+        this.props.faces = value;
+    }
+    /**
+     * Update face detection state
+     *
+     * @param detected - Whether faces are detected
+     *
+     * @param faces - Array of face detections
+     */
+    setFaces(detected, faces = []) {
+        this.props.detected = detected;
+        this.props.faces = faces;
+    }
+    /** Clear face detection state */
+    clearFaces() {
+        this.props.detected = false;
+        this.props.faces = [];
+    }
+    /**
+     * Get faces with known identity
+     *
+     * @returns Array of recognized faces
+     */
+    getKnownFaces() {
+        return this.faces.filter((f) => f.identity !== undefined);
+    }
+    /**
+     * Get faces without known identity
+     *
+     * @returns Array of unrecognized faces
+     */
+    getUnknownFaces() {
+        return this.faces.filter((f) => f.identity === undefined);
+    }
+    /**
+     * Check if specific identity is detected
+     *
+     * @param identity - Identity label to check
+     *
+     * @returns True if identity is detected, false otherwise
+     */
+    hasIdentity(identity) {
+        return this.faces.some((f) => f.identity === identity);
+    }
+}
+/**
+ * Face Detector Sensor (Active Detection)
+ *
+ * Use this class for frame-based face detection (face-api.js, DeepFace, etc.)
+ * The `inputProperties` getter specifies the required input format.
+ *
+ * Receives cropped person regions from ObjectDetectorSensor for efficient processing.
+ *
+ * @example
+ * ```typescript
+ * class FaceAPIDetector extends FaceDetectorSensor {
+ *   get inputProperties(): VideoInputProperties {
+ *     return { width: 160, height: 160, format: 'rgb' };
+ *   }
+ *
+ *   async detectFaces(frame: VideoFrameData, personRegions?: Detection[]): Promise<FaceResult> {
+ *     const detections = await faceapi.detectAllFaces(frame.data);
+ *     return {
+ *       detected: detections.length > 0,
+ *       faces: detections.map(d => ({
+ *         label: 'face',
+ *         confidence: d.score,
+ *         box: d.box,
+ *         identity: d.identity,
+ *       })),
+ *     };
+ *   }
+ * }
+ * ```
+ */
+export class FaceDetectorSensor extends FaceSensor {
+    /**
+     * Indicates this sensor requires video frames for detection.
+     * Used by the backend to determine streaming requirements.
+     */
+    _requiresFrames = true;
+}

package/dist/sensor/guards.js

@@ -0,0 +1,133 @@
+import { SensorType } from './types.js';
+/**
+ * Type guard for Motion sensors
+ *
+ * Narrows a SensorLike to MotionSensorLike for type-safe property access.
+ *
+ * @param sensor - The sensor to check
+ *
+ * @returns True if the sensor is a Motion sensor
+ */
+export function isMotionSensor(sensor) {
+    return sensor.type === SensorType.Motion;
+}
+/**
+ * Type guard for Object detection sensors
+ *
+ * Narrows a SensorLike to ObjectSensorLike for type-safe property access.
+ *
+ * @param sensor - The sensor to check
+ *
+ * @returns True if the sensor is an Object sensor
+ */
+export function isObjectSensor(sensor) {
+    return sensor.type === SensorType.Object;
+}
+/**
+ * Type guard for Audio sensors
+ *
+ * Narrows a SensorLike to AudioSensorLike for type-safe property access.
+ *
+ * @param sensor - The sensor to check
+ *
+ * @returns True if the sensor is an Audio sensor
+ */
+export function isAudioSensor(sensor) {
+    return sensor.type === SensorType.Audio;
+}
+/**
+ * Type guard for Face detection sensors
+ *
+ * Narrows a SensorLike to FaceSensorLike for type-safe property access.
+ *
+ * @param sensor - The sensor to check
+ *
+ * @returns True if the sensor is a Face sensor
+ */
+export function isFaceSensor(sensor) {
+    return sensor.type === SensorType.Face;
+}
+/**
+ * Type guard for License Plate detection sensors
+ *
+ * Narrows a SensorLike to LicensePlateSensorLike for type-safe property access.
+ *
+ * @param sensor - The sensor to check
+ *
+ * @returns True if the sensor is a License Plate sensor
+ */
+export function isLicensePlateSensor(sensor) {
+    return sensor.type === SensorType.LicensePlate;
+}
+/**
+ * Type guard for Contact sensors
+ *
+ * Narrows a SensorLike to ContactSensorLike for type-safe property access.
+ *
+ * @param sensor - The sensor to check
+ *
+ * @returns True if the sensor is a Contact sensor
+ */
+export function isContactSensor(sensor) {
+    return sensor.type === SensorType.Contact;
+}
+/**
+ * Type guard for Light controls
+ *
+ * Narrows a SensorLike to LightControlLike for type-safe property access.
+ *
+ * @param sensor - The sensor to check
+ *
+ * @returns True if the sensor is a Light control
+ */
+export function isLightControl(sensor) {
+    return sensor.type === SensorType.Light;
+}
+/**
+ * Type guard for Siren controls
+ *
+ * Narrows a SensorLike to SirenControlLike for type-safe property access.
+ *
+ * @param sensor - The sensor to check
+ *
+ * @returns True if the sensor is a Siren control
+ */
+export function isSirenControl(sensor) {
+    return sensor.type === SensorType.Siren;
+}
+/**
+ * Type guard for PTZ controls
+ *
+ * Narrows a SensorLike to PTZControlLike for type-safe property access.
+ *
+ * @param sensor - The sensor to check
+ *
+ * @returns True if the sensor is a PTZ control
+ */
+export function isPTZControl(sensor) {
+    return sensor.type === SensorType.PTZ;
+}
+/**
+ * Type guard for Doorbell triggers
+ *
+ * Narrows a SensorLike to DoorbellTriggerLike for type-safe property access.
+ *
+ * @param sensor - The sensor to check
+ *
+ * @returns True if the sensor is a Doorbell trigger
+ */
+export function isDoorbellTrigger(sensor) {
+    return sensor.type === SensorType.Doorbell;
+}
+/**
+ * Type guard for Battery info sensors
+ *
+ * Narrows a SensorLike to BatteryInfoLike for type-safe property access.
+ *
+ * @param sensor - The sensor to check
+ *
+ * @returns True if the sensor is a Battery info sensor
+ */
+export function isBatteryInfo(sensor) {
+    return sensor.type === SensorType.Battery;
+}

package/dist/sensor/index.js

@@ -0,0 +1,19 @@
+// Base
+export * from './base.js';
+export * from './types.js';
+export * from './guards.js';
+// Detection Sensors
+export * from './audio.js';
+export * from './contact.js';
+export * from './face.js';
+export * from './licensePlate.js';
+export * from './motion.js';
+export * from './object.js';
+// Controls
+export * from './light.js';
+export * from './ptz.js';
+export * from './siren.js';
+// Triggers
+export * from './doorbell.js';
+// Info
+export * from './battery.js';

package/dist/sensor/licensePlate.js

@@ -0,0 +1,116 @@
+import { Sensor } from './base.js';
+import { SensorCategory, SensorType } from './types.js';
+/**
+ * License plate sensor property keys
+ */
+export var LicensePlateProperty;
+(function (LicensePlateProperty) {
+    LicensePlateProperty["Detected"] = "detected";
+    LicensePlateProperty["Plates"] = "plates";
+})(LicensePlateProperty || (LicensePlateProperty = {}));
+/**
+ * License Plate Sensor (Specialized)
+ *
+ * Detects and reads license plates in camera frames.
+ * Can optionally receive vehicle regions from ObjectSensor for focused detection.
+ */
+export class LicensePlateSensor extends Sensor {
+    type = SensorType.LicensePlate;
+    category = SensorCategory.Sensor;
+    name;
+    constructor(name = 'License Plate Sensor') {
+        super();
+        this.name = name;
+        // Initialize defaults
+        this.props.detected = false;
+        this.props.plates = [];
+    }
+    /** Whether license plates are currently detected */
+    get detected() {
+        return this.rawProps.detected;
+    }
+    /** Set license plate detected state */
+    set detected(value) {
+        this.props.detected = value;
+    }
+    /** Current license plate detections */
+    get plates() {
+        return this.rawProps.plates;
+    }
+    /** Set license plate detections */
+    set plates(value) {
+        this.props.plates = value;
+    }
+    /**
+     * Update license plate detection state
+     *
+     * @param detected - Whether license plates are detected
+     *
+     * @param plates - Array of license plate detections
+     */
+    setPlates(detected, plates = []) {
+        this.props.detected = detected;
+        this.props.plates = plates;
+    }
+    /** Clear license plate detection state */
+    clearPlates() {
+        this.props.detected = false;
+        this.props.plates = [];
+    }
+    /**
+     * Get plate texts
+     *
+     * @returns Array of detected plate texts
+     */
+    getPlateTexts() {
+        return this.plates.map((p) => p.plateText);
+    }
+    /**
+     * Check if specific plate is detected
+     *
+     * @param plateText - Plate text to check
+     *
+     * @returns True if plate is detected, false otherwise
+     */
+    hasPlate(plateText) {
+        return this.plates.some((p) => p.plateText === plateText);
+    }
+}
+/**
+ * License Plate Detector Sensor (Active Detection)
+ *
+ * Use this class for frame-based license plate detection (OpenALPR, etc.)
+ * The `inputProperties` getter specifies the required input format.
+ *
+ * Receives cropped vehicle regions from ObjectDetectorSensor for efficient processing.
+ *
+ * @example
+ * ```typescript
+ * class OpenALPRDetector extends LicensePlateDetectorSensor {
+ *   get inputProperties(): VideoInputProperties {
+ *     return { width: 320, height: 160, format: 'rgb' };
+ *   }
+ *
+ *   async detectLicensePlates(frame: VideoFrameData, vehicleRegions?: Detection[]): Promise<LicensePlateResult> {
+ *     const plates = await this.alpr.recognize(frame.data);
+ *     return {
+ *       detected: plates.length > 0,
+ *       plates: plates.map(p => ({
+ *         label: 'license_plate',
+ *         confidence: p.confidence,
+ *         box: p.box,
+ *         plateText: p.text,
+ *         plateConfidence: p.textConfidence,
+ *       })),
+ *     };
+ *   }
+ * }
+ * ```
+ */
+export class LicensePlateDetectorSensor extends LicensePlateSensor {
+    /**
+     * Indicates this sensor requires video frames for detection.
+     * Used by the backend to determine streaming requirements.
+     */
+    _requiresFrames = true;
+}

package/dist/sensor/light.js

@@ -0,0 +1,66 @@
+import { Sensor } from './base.js';
+import { SensorCategory, SensorType } from './types.js';
+/**
+ * Light Capability enum
+ * Describes what Light features this sensor supports
+ * Note: "on" property is always available (standard)
+ */
+export var LightCapability;
+(function (LightCapability) {
+    /** Supports brightness control */
+    LightCapability["Brightness"] = "brightness";
+})(LightCapability || (LightCapability = {}));
+/**
+ * Light control property keys
+ */
+export var LightProperty;
+(function (LightProperty) {
+    LightProperty["On"] = "on";
+    LightProperty["Brightness"] = "brightness";
+})(LightProperty || (LightProperty = {}));
+/**
+ * Light Control
+ *
+ * Bidirectional control for camera spotlight/floodlight.
+ * Properties can be set directly: `light.on = true`
+ */
+export class LightControl extends Sensor {
+    type = SensorType.Light;
+    category = SensorCategory.Control;
+    name;
+    constructor(name = 'Light') {
+        super();
+        this.name = name;
+        // Initialize defaults
+        this.props.on = false;
+        this.props.brightness = 100;
+    }
+    /** Whether light is on */
+    get on() {
+        return this.rawProps.on;
+    }
+    /** Turn light on/off */
+    set on(value) {
+        this.props.on = value;
+    }
+    /** Brightness level (0-100) */
+    get brightness() {
+        return this.rawProps.brightness;
+    }
+    /** Set brightness level (0-100) */
+    set brightness(value) {
+        this.props.brightness = Math.max(0, Math.min(100, value));
+    }
+    /** Turn light on */
+    turnOn() {
+        this.props.on = true;
+    }
+    /** Turn light off */
+    turnOff() {
+        this.props.on = false;
+    }
+    /** Toggle light state */
+    toggle() {
+        this.props.on = !this.on;
+    }
+}

package/dist/sensor/motion.js

@@ -0,0 +1,103 @@
+import { Sensor } from './base.js';
+import { SensorCategory, SensorType } from './types.js';
+/**
+ * Motion sensor property keys
+ */
+export var MotionProperty;
+(function (MotionProperty) {
+    MotionProperty["Detected"] = "detected";
+    MotionProperty["Detections"] = "detections";
+})(MotionProperty || (MotionProperty = {}));
+/**
+ * Motion Sensor
+ *
+ * Base class for external motion detection (Ring, ONVIF events, SMTP, etc.)
+ * Properties can be set directly: `sensor.detected = true`
+ *
+ * For frame-based motion detection, use `MotionDetectorSensor` instead.
+ */
+export class MotionSensor extends Sensor {
+    type = SensorType.Motion;
+    category = SensorCategory.Sensor;
+    name;
+    /**
+     * External motion sensors don't require video frames.
+     * They receive motion events from external sources (SMTP, ONVIF, Ring API, etc.)
+     */
+    _requiresFrames = false;
+    constructor(name = 'Motion Sensor') {
+        super();
+        this.name = name;
+        // Initialize defaults
+        this.props.detected = false;
+        this.props.detections = [];
+    }
+    /** Whether motion is currently detected */
+    get detected() {
+        return this.rawProps.detected;
+    }
+    /** Set motion detected state */
+    set detected(value) {
+        this.props.detected = value;
+    }
+    /** Current motion detections */
+    get detections() {
+        return this.rawProps.detections;
+    }
+    /** Set motion detections */
+    set detections(value) {
+        this.props.detections = value;
+    }
+    /**
+     * Update both detected state and detections at once
+     *
+     * @param detected - Whether motion is detected
+     *
+     * @param detections - Array of motion detections
+     */
+    setMotion(detected, detections = []) {
+        this.props.detected = detected;
+        this.props.detections = detections;
+    }
+    /** Clear motion state */
+    clearMotion() {
+        this.props.detected = false;
+        this.props.detections = [];
+    }
+}
+/**
+ * Motion Detector Sensor (Active Detection)
+ *
+ * Use this class for frame-based motion detection (rust-motion, OpenCV, etc.)
+ * The `inputProperties` getter specifies the required input format.
+ *
+ * For external motion events (Ring, ONVIF, SMTP), use the base `MotionSensor` class instead.
+ *
+ * @example
+ * ```typescript
+ * class RustMotionDetector extends MotionDetectorSensor {
+ *   get inputProperties(): VideoInputProperties {
+ *     return { width: 320, height: 240, format: 'gray' };
+ *   }
+ *
+ *   async detectMotion(frame: VideoFrameData): Promise<MotionResult> {
+ *     const result = await this.rustDetector.process(frame.data);
+ *     return {
+ *       detected: result.motionDetected,
+ *       detections: result.regions.map(r => ({
+ *         label: 'motion',
+ *         confidence: r.intensity,
+ *         box: r.boundingBox,
+ *       })),
+ *     };
+ *   }
+ * }
+ * ```
+ */
+export class MotionDetectorSensor extends MotionSensor {
+    /**
+     * Indicates this sensor requires video frames for detection.
+     * Used by the backend to determine streaming requirements.
+     */
+    _requiresFrames = true;
+}

package/dist/sensor/object.js

@@ -0,0 +1,137 @@
+import { Sensor } from './base.js';
+import { SensorCategory, SensorType } from './types.js';
+/**
+ * Object sensor property keys
+ */
+export var ObjectProperty;
+(function (ObjectProperty) {
+    ObjectProperty["Detected"] = "detected";
+    ObjectProperty["Detections"] = "detections";
+    ObjectProperty["Labels"] = "labels";
+})(ObjectProperty || (ObjectProperty = {}));
+/**
+ * Object Sensor
+ *
+ * Base class for external object detection (Ring, ONVIF events, Eufy, etc.)
+ * Properties can be set directly: `sensor.detected = true`
+ *
+ * For frame-based object detection, use `ObjectDetectorSensor` instead.
+ */
+export class ObjectSensor extends Sensor {
+    type = SensorType.Object;
+    category = SensorCategory.Sensor;
+    name;
+    /**
+     * External object sensors don't require video frames.
+     * They receive detection events from external sources (APIs, ONVIF, etc.)
+     */
+    _requiresFrames = false;
+    constructor(name = 'Object Sensor') {
+        super();
+        this.name = name;
+        // Initialize defaults
+        this.props.detected = false;
+        this.props.detections = [];
+        this.props.labels = [];
+    }
+    /** Whether objects are currently detected */
+    get detected() {
+        return this.rawProps.detected;
+    }
+    /** Set object detected state */
+    set detected(value) {
+        this.props.detected = value;
+    }
+    /** Current object detections */
+    get detections() {
+        return this.rawProps.detections;
+    }
+    /** Set object detections */
+    set detections(value) {
+        this.props.detections = value;
+    }
+    /** Labels currently being detected */
+    get labels() {
+        return this.rawProps.labels;
+    }
+    /** Set detected labels */
+    set labels(value) {
+        this.props.labels = value;
+    }
+    /**
+     * Update object detection state
+     *
+     * @param detected - Whether objects are detected
+     *
+     * @param detections - Array of object detections
+     */
+    setObjects(detected, detections = []) {
+        this.props.detected = detected;
+        this.props.detections = detections;
+        // Extract unique labels from detections
+        const labelSet = new Set(detections.map((d) => d.label));
+        this.props.labels = Array.from(labelSet);
+    }
+    /** Clear object detection state */
+    clearObjects() {
+        this.props.detected = false;
+        this.props.detections = [];
+        this.props.labels = [];
+    }
+    /**
+     * Get detections filtered by label
+     *
+     * @param label - The label to filter detections by
+     *
+     * @returns Array of detections matching the label
+     */
+    getDetectionsByLabel(label) {
+        return this.detections.filter((d) => d.label === label);
+    }
+    /**
+     * Check if specific label is detected
+     *
+     * @param label - Label to check
+     *
+     * @returns True if label is detected, false otherwise
+     */
+    hasLabel(label) {
+        return this.labels.includes(label);
+    }
+}
+/**
+ * Object Detector Sensor (Active Detection)
+ *
+ * Use this class for frame-based object detection (TensorFlow, YOLO, etc.)
+ * The `inputProperties` getter specifies the required input format.
+ *
+ * For external object events, use the base `ObjectSensor` class instead.
+ *
+ * @example
+ * ```typescript
+ * class TensorFlowObjectDetector extends ObjectDetectorSensor {
+ *   get inputProperties(): VideoInputProperties {
+ *     return { width: 640, height: 640, format: 'rgb' };
+ *   }
+ *
+ *   async detectObjects(frame: VideoFrameData): Promise<ObjectResult> {
+ *     const predictions = await this.model.detect(frame.data);
+ *     return {
+ *       detected: predictions.length > 0,
+ *       detections: predictions.map(p => ({
+ *         label: p.class,
+ *         confidence: p.score,
+ *         box: p.bbox,
+ *       })),
+ *     };
+ *   }
+ * }
+ * ```
+ */
+export class ObjectDetectorSensor extends ObjectSensor {
+    /**
+     * Indicates this sensor requires video frames for detection.
+     * Used by the backend to determine streaming requirements.
+     */
+    _requiresFrames = true;
+}