@camstack/types 0.1.1 → 0.1.2

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import * as _trpc_server from '@trpc/server';
 import { ChildProcess } from 'node:child_process';
 
 interface BoundingBox {
@@ -37,6 +38,54 @@ interface ClassMapDefinition {
     readonly preserveOriginal: boolean;
 }
 
+/** Zone purpose per pipeline stage */
+type ZoneMode = 'include' | 'exclude' | 'monitor';
+/** Motion event source for a camera */
+type MotionSource = 'sensor' | 'stream' | 'smart';
+/** A polygon zone with independent motion/detection behavior */
+interface CameraZone {
+    readonly id: string;
+    readonly name: string;
+    /** Polygon vertices as fraction of frame (0–1) */
+    readonly polygon: readonly {
+        readonly x: number;
+        readonly y: number;
+    }[];
+    /** Zone purpose for motion detection stage */
+    readonly motionMode: ZoneMode;
+    /** Zone purpose for pipeline detection stage */
+    readonly detectionMode: ZoneMode;
+    /** Minimum overlap fraction (0–1) for bbox/mask to count as "in zone" */
+    readonly overlapThreshold: number;
+    /** Use segmentation mask for overlap when available (vs bbox only) */
+    readonly preferMask: boolean;
+    /** Only apply to these detection classes (empty/undefined = all) */
+    readonly classFilter?: readonly string[];
+    /** Seconds of no movement before emitting stationary alert for this zone */
+    readonly stationaryAlertSeconds?: number;
+    /** Visual color for UI rendering */
+    readonly color: string;
+}
+/** Per-camera zone configuration */
+interface CameraZoneConfig {
+    readonly deviceId: string;
+    readonly zones: readonly CameraZone[];
+    /** Auto-generate rectangular border exclusion zone */
+    readonly autoBorderExclude: {
+        readonly enabled: boolean;
+        /** Fraction of frame edge to exclude (0–0.2 typical) */
+        readonly percent: number;
+    };
+}
+/** Zone membership annotation on a detection */
+interface DetectionZoneMembership {
+    readonly zoneId: string;
+    readonly zoneName: string;
+    /** Overlap fraction 0–1 */
+    readonly overlap: number;
+    readonly mode: ZoneMode;
+}
+
 interface SpatialDetection {
     readonly class: string;
     readonly originalClass: string;
@@ -74,6 +123,59 @@ interface ClassifierOutput {
     readonly inferenceMs: number;
     readonly modelId: string;
 }
+interface RefinerOutput {
+    /** Base64-encoded binary mask for the refined detection region */
+    readonly mask: string;
+    readonly maskWidth: number;
+    readonly maskHeight: number;
+    readonly inferenceMs: number;
+    readonly modelId: string;
+}
+/** Origin type of a label — what kind of pipeline step produced it */
+type LabelOrigin = 'classification' | 'face' | 'plate' | 'recognition' | 'unknown';
+/** A label produced by any classifier/recognizer step in the pipeline */
+interface LabelData {
+    /** The classification/recognition result (e.g., "Sunbird", "EA0202AA", "Dodge Journey SUV 2012") */
+    readonly label: string;
+    /** Confidence of the classification */
+    readonly score: number;
+    /** Bounding box of the source region this label applies to [x1, y1, x2, y2] */
+    readonly box: readonly [number, number, number, number];
+    /** Source addon that produced this label */
+    readonly addonId: string;
+    /** Origin type — what kind of step produced this label */
+    readonly origin: LabelOrigin;
+}
+/** A detection produced by the pipeline executor with accumulated labels */
+interface PipelineDetection {
+    readonly className: string;
+    readonly originalClass?: string;
+    readonly confidence: number;
+    readonly bbox: readonly [number, number, number, number];
+    /** Accumulated labels from all classifier/recognizer steps in the pipeline */
+    readonly labelsData: readonly LabelData[];
+    /** Base64-encoded binary segmentation mask (when using -seg models or refiner) */
+    readonly mask?: string;
+    readonly maskWidth?: number;
+    readonly maskHeight?: number;
+    /** Sub-detections from cropper steps (face bbox, plate bbox) — for debug */
+    readonly children?: readonly PipelineDetection[];
+    readonly zones?: readonly DetectionZoneMembership[];
+    readonly embeddingId?: string;
+}
+interface PipelineStepTiming {
+    readonly addonId: string;
+    readonly modelId: string;
+    readonly ms: number;
+    readonly detections: number;
+}
+interface PipelineRunResult {
+    readonly detections: readonly PipelineDetection[];
+    readonly stepTimings: readonly PipelineStepTiming[];
+    readonly totalMs: number;
+    readonly imageWidth: number;
+    readonly imageHeight: number;
+}
 
 type ObjectState = 'entering' | 'moving' | 'stationary' | 'leaving' | 'loitering';
 interface TrackedDetection extends SpatialDetection {
@@ -95,6 +197,8 @@ interface TrackedObjectState {
 }
 
 type DetectionEventType = 'object.detected' | 'object.classified' | 'object.entering' | 'object.leaving' | 'object.stationary' | 'object.loitering' | 'zone.enter' | 'zone.exit' | 'tripwire.cross' | 'audio.detected';
+type TrackEventType = 'track.new' | 'track.update' | 'track.stationary' | 'track.moving' | 'track.zone-enter' | 'track.zone-exit' | 'track.zone-dwell' | 'track.ended';
+type AnalysisEventType = DetectionEventType | TrackEventType;
 interface ZoneEvent {
     readonly type: 'zone-enter' | 'zone-exit' | 'zone-loiter' | 'tripwire-cross';
     readonly zoneId: string;
@@ -196,10 +300,29 @@ interface KnownAudioEvent {
 }
 
 type ModelFormat$1 = 'onnx' | 'coreml' | 'openvino' | 'tflite' | 'pt';
-type ModelOutputFormat = 'yolo' | 'ssd' | 'embedding' | 'classification' | 'ocr';
+type ModelOutputFormat = 'yolo' | 'ssd' | 'embedding' | 'classification' | 'ocr' | 'segmentation';
 interface ModelFormatEntry {
     readonly url: string;
     readonly sizeMB: number;
+    /** Whether this format is a directory bundle (e.g., .mlpackage) rather than a single file */
+    readonly isDirectory?: boolean;
+    /**
+     * For directory formats: list of files relative to the directory root.
+     * The downloader fetches each file from `{url}/{file}` and saves to `{modelDir}/{file}`.
+     * If omitted for a directory format, the downloader probes HuggingFace API (slower).
+     */
+    readonly files?: readonly string[];
+    /** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
+    readonly runtimes?: readonly ('node' | 'python')[];
+}
+/**
+ * Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
+ * The downloader fetches from `url` and saves to `{modelsDir}/{filename}`.
+ */
+interface ModelExtraFile {
+    readonly url: string;
+    readonly filename: string;
+    readonly sizeMB: number;
 }
 interface ModelCatalogEntry {
     readonly id: string;
@@ -213,6 +336,11 @@ interface ModelCatalogEntry {
     readonly labels: readonly LabelDefinition[];
     readonly inputLayout?: 'nchw' | 'nhwc';
     readonly inputNormalization?: 'zero-one' | 'imagenet' | 'none';
+    /**
+     * Auxiliary files required at runtime (labels JSON, charset dict, etc.).
+     * Downloaded into the same modelsDir alongside the model file.
+     */
+    readonly extraFiles?: readonly ModelExtraFile[];
 }
 interface DetectionModel {
     readonly id: string;
@@ -249,7 +377,7 @@ interface CustomModelMetadata {
     readonly outputFormat: ModelOutputFormat;
 }
 
-type PipelineSlot = 'detector' | 'cropper' | 'classifier';
+type PipelineSlot = 'detector' | 'cropper' | 'classifier' | 'refiner';
 interface PipelineNode {
     readonly step: string;
     readonly addon: string;
@@ -275,7 +403,7 @@ interface StepError {
 interface StepResult {
     readonly addon: string;
     readonly slot: PipelineSlot;
-    readonly output: DetectorOutput | CropperOutput | ClassifierOutput;
+    readonly output: DetectorOutput | CropperOutput | ClassifierOutput | RefinerOutput;
     readonly parentResultId?: string;
     readonly resultId: string;
     readonly inferenceMs: number;
@@ -516,6 +644,2829 @@ interface GroundTruth {
     readonly annotations: readonly GroundTruthAnnotation[];
 }
 
+interface PipelineAddonSchema {
+    readonly id: string;
+    readonly name: string;
+    readonly slot: PipelineSlot;
+    readonly inputClasses: readonly string[];
+    readonly outputClasses: readonly string[];
+    /** Which child slots this addon can host (e.g. detector hosts cropper/classifier) */
+    readonly childSlots: readonly PipelineSlot[];
+    /** Available models with download status per format */
+    readonly models: readonly PipelineModelOption[];
+    readonly defaultModelId: string;
+    readonly defaultConfidence: number;
+    /** Best runtime for this addon on this agent — resolved by PlatformScorer */
+    readonly defaultRuntime: string;
+    /** Best backend for this addon on this agent — resolved by PlatformScorer */
+    readonly defaultBackend: string;
+}
+interface PipelineModelOption {
+    readonly id: string;
+    readonly name: string;
+    readonly formats: Partial<Readonly<Record<ModelFormat$1, {
+        downloaded: boolean;
+        sizeMB: number;
+    }>>>;
+}
+interface PipelineSlotSchema {
+    readonly id: PipelineSlot;
+    readonly label: string;
+    readonly priority: number;
+    /** Which slot is the parent (null for root detectors) */
+    readonly parentSlot: PipelineSlot | null;
+    readonly addons: readonly PipelineAddonSchema[];
+}
+interface PipelineSchema {
+    readonly slots: readonly PipelineSlotSchema[];
+}
+/** A fully-resolved pipeline step with all defaults from PlatformScorer */
+interface PipelineDefaultStep {
+    readonly addonId: string;
+    readonly addonName: string;
+    readonly slot: PipelineSlot;
+    readonly inputClasses: readonly string[];
+    readonly outputClasses: readonly string[];
+    readonly enabled: boolean;
+    readonly agentId: string;
+    readonly runtime: string;
+    readonly backend: string;
+    readonly modelId: string;
+    readonly confidence: number;
+    readonly classFilters: readonly string[];
+    readonly children: readonly PipelineDefaultStep[];
+}
+interface PipelineTemplateStep {
+    readonly addonId: string;
+    readonly enabled: boolean;
+    readonly agentId: string;
+    readonly runtime: string;
+    readonly backend: string;
+    readonly modelId: string;
+    readonly confidence: number;
+    readonly classFilters: readonly string[];
+    readonly children: readonly PipelineTemplateStep[];
+}
+interface PipelineTemplate {
+    readonly id: string;
+    readonly name: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly steps: readonly PipelineTemplateStep[];
+}
+interface TemplateValidationResult {
+    readonly valid: boolean;
+    readonly steps: readonly PipelineTemplateStep[];
+    readonly warnings: readonly string[];
+}
+
+// src/interfaces/storage-backend.ts
+
+// src/types/device-type.ts
+var DeviceType$2 = /* @__PURE__ */ ((DeviceType2) => {
+  DeviceType2["Camera"] = "camera";
+  return DeviceType2;
+})(DeviceType$2 || {});
+
+type AppRouter = _trpc_server.TRPCBuiltRouter<{
+    ctx: {
+        user: {
+            id: string;
+            username: string;
+            role: string;
+        } | null;
+    };
+    meta: object;
+    errorShape: _trpc_server.TRPCDefaultErrorShape;
+    transformer: true;
+}, _trpc_server.TRPCDecorateCreateRouterOptions<{
+    toast?: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        onToast: _trpc_server.TRPCSubscriptionProcedure<{
+            input: void;
+            output: undefined;
+            meta: object;
+        }>;
+    }>> | undefined;
+    scopedTokens?: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        create: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                name: string;
+                scopes: {
+                    type: "addon" | "route-prefix" | "capability";
+                    target: string;
+                }[];
+                expiresAt?: number | undefined;
+            };
+            output: {
+                token: string;
+                id: string;
+                name: string;
+                tokenPrefix: string;
+                scopes: undefined[];
+                expiresAt: number | undefined;
+                createdAt: number;
+            };
+            meta: object;
+        }>;
+        list: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: string;
+                name: string;
+                tokenPrefix: string;
+                scopes: undefined[];
+                expiresAt: number | undefined;
+                lastUsedAt: number | undefined;
+                createdAt: number;
+            }[];
+            meta: object;
+        }>;
+        revoke: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                tokenId: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+    }>> | undefined;
+    notifications?: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        listOutputs: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: readonly {
+                id: string;
+                name: string;
+                icon: string;
+            }[];
+            meta: object;
+        }>;
+        getRouting: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: Record<string, string[]>;
+            meta: object;
+        }>;
+        setRouting: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                category: string;
+                outputIds: string[];
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        sendTest: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                outputId: string;
+            };
+            output: {
+                success: boolean;
+                error?: string;
+            };
+            meta: object;
+        }>;
+    }>> | undefined;
+    inference?: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        getCapabilities: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: undefined;
+            meta: object;
+        }>;
+        getAddonModels: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                addonId: string;
+            };
+            output: readonly undefined[];
+            meta: object;
+        }>;
+        downloadModel: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                addonId: string;
+                format: "onnx" | "coreml" | "openvino" | "tflite" | "pt";
+                modelId: string;
+            };
+            output: {
+                filePath: string;
+                sizeMB: number;
+                durationMs: number;
+            };
+            meta: object;
+        }>;
+        onDownloadProgress: _trpc_server.TRPCSubscriptionProcedure<{
+            input: void;
+            output: {
+                modelId: string;
+                format: string;
+                downloadedBytes: number;
+                totalBytes: number;
+                percent: number;
+            };
+            meta: object;
+        }>;
+        onPipelineProgress: _trpc_server.TRPCSubscriptionProcedure<{
+            input: void;
+            output: undefined;
+            meta: object;
+        }>;
+        releaseEngine: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                addonId: string;
+                backend: string;
+                runtime: "node" | "python";
+                modelId: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        listReferenceImages: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: string;
+                filename: string;
+                sizeKB: number;
+            }[];
+            meta: object;
+        }>;
+        getReferenceImage: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                filename: string;
+            };
+            output: {
+                base64: string;
+                filename: string;
+            } | null;
+            meta: object;
+        }>;
+        runDetection: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                addonId: string;
+                backend: string;
+                runtime: "node" | "python";
+                modelId?: string | undefined;
+                referenceImage?: string | undefined;
+                imageBase64?: string | undefined;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        detect: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                frame: {
+                    data: string;
+                    timestamp: number;
+                    cameraId: string;
+                    width: number;
+                    height: number;
+                };
+                addonId: string;
+                confidence?: number | undefined;
+            };
+            output: any;
+            meta: object;
+        }>;
+        runPipeline: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                steps: any[];
+                referenceImage?: string | undefined;
+                imageBase64?: string | undefined;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+    }>> | undefined;
+    auth: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        login: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                password: string;
+                username: string;
+            };
+            output: {
+                token: string;
+                user: {
+                    id: string;
+                    username: string;
+                    role: undefined;
+                };
+            };
+            meta: object;
+        }>;
+        me: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: undefined;
+            meta: object;
+        }>;
+        logout: _trpc_server.TRPCMutationProcedure<{
+            input: void;
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        listProviders: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: string;
+                name: string;
+                icon: string;
+                flowType: "credentials" | "redirect" | "token";
+            }[];
+            meta: object;
+        }>;
+    }>>;
+    users: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        list: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: Omit<undefined, "passwordHash">[];
+            meta: object;
+        }>;
+        create: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                password: string;
+                username: string;
+                role: "admin" | "super_admin" | "viewer";
+                allowedProviders?: string[] | "*" | undefined;
+                allowedDevices?: Record<string, string[] | "*"> | undefined;
+            };
+            output: {
+                id: string;
+                username: string;
+                role: undefined;
+                allowedProviders: string[] | "*";
+                allowedDevices: Record<string, string[] | "*">;
+                createdAt: number;
+                updatedAt: number;
+            };
+            meta: object;
+        }>;
+        update: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+                role?: "admin" | "super_admin" | "viewer" | undefined;
+                allowedProviders?: string[] | "*" | undefined;
+                allowedDevices?: Record<string, string[] | "*"> | undefined;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        delete: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        resetPassword: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+                newPassword: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+    }>>;
+    system: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        info: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                version: string;
+                uptime: number;
+                nodeVersion: string;
+                platform: NodeJS.Platform;
+                features: undefined;
+            };
+            meta: object;
+        }>;
+        health: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                status: "ok";
+                uptime: number;
+            };
+            meta: object;
+        }>;
+        featureFlags: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: undefined;
+            meta: object;
+        }>;
+        getRetentionConfig: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: unknown;
+            meta: object;
+        }>;
+        setRetentionConfig: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                detectionEventsDays?: number | undefined;
+                audioLevelsDays?: number | undefined;
+                snapshotsDays?: number | undefined;
+                cleanupIntervalMs?: number | undefined;
+            };
+            output: {
+                success: boolean;
+                config?: undefined;
+            } | {
+                success: boolean;
+                config: unknown;
+            };
+            meta: object;
+        }>;
+        forceRetentionCleanup: _trpc_server.TRPCMutationProcedure<{
+            input: void;
+            output: {
+                success: boolean;
+                report?: undefined;
+            } | {
+                success: boolean;
+                report: unknown;
+            };
+            meta: object;
+        }>;
+    }>>;
+    settings: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        getSchema: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                section?: "recording" | "storage" | "addons" | "server" | "auth" | "ffmpeg" | "streaming" | "backup" | "features" | "logging" | "retention" | "detection" | undefined;
+            };
+            output: {
+                section: "recording" | "storage" | "addons" | "server" | "auth" | "ffmpeg" | "streaming" | "backup" | "features" | "logging" | "retention" | "detection";
+                schema: undefined | null;
+                readOnly: boolean;
+                tabs?: undefined;
+                schemas?: undefined;
+            } | {
+                tabs: readonly undefined[];
+                schemas: Record<string, unknown>;
+                section?: undefined;
+                schema?: undefined;
+                readOnly?: undefined;
+            };
+            meta: object;
+        }>;
+        get: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                section: "recording" | "storage" | "addons" | "server" | "auth" | "ffmpeg" | "streaming" | "backup" | "features" | "logging" | "retention" | "detection";
+            };
+            output: {
+                section: "recording" | "storage" | "addons" | "server" | "auth" | "ffmpeg" | "streaming" | "backup" | "features" | "logging" | "retention" | "detection";
+                data: Record<string, unknown>;
+            };
+            meta: object;
+        }>;
+        update: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                data: Record<string, unknown>;
+                section: "recording" | "storage" | "addons" | "server" | "auth" | "ffmpeg" | "streaming" | "backup" | "features" | "logging" | "retention" | "detection";
+            };
+            output: {
+                success: boolean;
+                section: "recording" | "storage" | "addons" | "server" | "auth" | "ffmpeg" | "streaming" | "backup" | "features" | "logging" | "retention" | "detection";
+            };
+            meta: object;
+        }>;
+    }>>;
+    providers: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        list: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: readonly undefined[];
+            meta: object;
+        }>;
+        get: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                id: string;
+                type: string;
+                name: string;
+                discoveryMode: "both" | "auto" | "manual";
+                status: undefined;
+                deviceCount: number;
+            };
+            meta: object;
+        }>;
+        start: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        stop: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        restart: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+    }>>;
+    providerConfig: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        addProvider: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                name: string;
+                id: string;
+                type: string;
+                url?: string | undefined;
+                password?: string | undefined;
+                username?: string | undefined;
+                mqtt?: {
+                    brokerUrl: string;
+                    password?: string | undefined;
+                    username?: string | undefined;
+                    topicPrefix?: string | undefined;
+                } | undefined;
+            };
+            output: {
+                success: boolean;
+                provider: {
+                    name: string;
+                    id: string;
+                    type: string;
+                    url?: string | undefined;
+                    password?: string | undefined;
+                    username?: string | undefined;
+                    mqtt?: {
+                        brokerUrl: string;
+                        topicPrefix: string;
+                        password?: string | undefined;
+                        username?: string | undefined;
+                    } | undefined;
+                };
+            };
+            meta: object;
+        }>;
+        updateProvider: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                name: string;
+                id: string;
+                type: string;
+                url?: string | undefined;
+                password?: string | undefined;
+                username?: string | undefined;
+                mqtt?: {
+                    brokerUrl: string;
+                    password?: string | undefined;
+                    username?: string | undefined;
+                    topicPrefix?: string | undefined;
+                } | undefined;
+            };
+            output: {
+                success: boolean;
+                provider: {
+                    name: string;
+                    id: string;
+                    type: string;
+                    url?: string | undefined;
+                    password?: string | undefined;
+                    username?: string | undefined;
+                    mqtt?: {
+                        brokerUrl: string;
+                        topicPrefix: string;
+                        password?: string | undefined;
+                        username?: string | undefined;
+                    } | undefined;
+                };
+            };
+            meta: object;
+        }>;
+        removeProvider: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+                removedId: string;
+            };
+            meta: object;
+        }>;
+        testConnection: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                url: string;
+                type: string;
+                password?: string | undefined;
+                username?: string | undefined;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+    }>>;
+    devices: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        list: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                capability?: string | undefined;
+                type?: string | undefined;
+                providerId?: string | undefined;
+            } | undefined;
+            output: {
+                id: string;
+                name: string;
+                providerId: string;
+                type: DeviceType$2;
+                capabilities: undefined[];
+                state: undefined;
+            }[];
+            meta: object;
+        }>;
+        get: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                id: string;
+                name: string;
+                providerId: string;
+                type: DeviceType$2;
+                capabilities: undefined[];
+                state: undefined;
+                metadata: undefined;
+            };
+            meta: object;
+        }>;
+        getState: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                id: string;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        getCapabilities: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                name: undefined;
+                native: boolean;
+                binding: undefined;
+                resolved: boolean;
+            }[];
+            meta: object;
+        }>;
+    }>>;
+    streaming: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        getStreamUrl: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                streamId: string;
+                format: "mjpeg" | "webrtc" | "hls" | "rtsp";
+            };
+            output: {
+                url: string;
+            };
+            meta: object;
+        }>;
+        whepOffer: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                streamId: string;
+                sdpOffer: string;
+            };
+            output: {
+                sdpAnswer: string;
+            };
+            meta: object;
+        }>;
+    }>>;
+    events: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        query: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                limit?: number | undefined;
+                offset?: number | undefined;
+                since?: number | undefined;
+                until?: number | undefined;
+                types?: string[] | undefined;
+                detectionClasses?: string[] | undefined;
+                clusterSpan?: number | undefined;
+                onlyKeyEvents?: boolean | undefined;
+                includeClip?: boolean | undefined;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        thumbnail: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                eventId: string;
+            };
+            output: string | null;
+            meta: object;
+        }>;
+        snapshot: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                eventId: string;
+            };
+            output: string | null;
+            meta: object;
+        }>;
+        clipUrl: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                eventId: string;
+            };
+            output: {
+                url: string;
+            } | null;
+            meta: object;
+        }>;
+    }>>;
+    logs: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        query: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                level?: "error" | "info" | "debug" | "warn" | undefined;
+                limit?: number | undefined;
+                scope?: string[] | undefined;
+                since?: number | undefined;
+                until?: number | undefined;
+            };
+            output: undefined[];
+            meta: object;
+        }>;
+    }>>;
+    live: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        recentSystemEvents: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                limit?: number | undefined;
+                category?: string | undefined;
+            } | undefined;
+            output: readonly undefined[];
+            meta: object;
+        }>;
+        onEvent: _trpc_server.TRPCSubscriptionProcedure<{
+            input: {
+                category?: string | undefined;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        onDeviceEvent: _trpc_server.TRPCSubscriptionProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+    }>>;
+    processes: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        listProcesses: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: (undefined | {
+                id: string;
+                label: string;
+                state: "running" | "stopped" | "crashed" | "starting";
+                pid?: number;
+                stats?: {
+                    pid: number;
+                    cpu: number;
+                    memory: number;
+                    uptime: number;
+                    restartCount: number;
+                };
+                restartCount: number;
+                mode: "forked" | "in-process";
+            })[];
+            meta: object;
+        }>;
+        getProcess: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                id: string;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        startProcess: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        stopProcess: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        restartProcess: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        listProviderStatus: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: readonly undefined[];
+            meta: object;
+        }>;
+        enableProvider: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        disableProvider: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+    }>>;
+    agents: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        listAgents: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: readonly Record<string, unknown>[];
+            meta: object;
+        }>;
+        getAgent: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                id: string;
+                name: string;
+                state: "online" | "offline" | "degraded";
+                capabilities: string[];
+                lastHeartbeat: number;
+                connectedSince: number;
+                resources: undefined | undefined;
+                activeTaskCount: number;
+                completedTaskCount: number;
+                failedTaskCount: number;
+            };
+            meta: object;
+        }>;
+        removeAgent: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        dispatchTask: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                capability: string;
+                label?: string | undefined;
+                input?: Record<string, unknown> | undefined;
+                timeout?: number | undefined;
+                preferredAgent?: string | undefined;
+                priority?: "low" | "normal" | "high" | undefined;
+                remoteOnly?: boolean | undefined;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        getAgentCapabilities: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: string[];
+            meta: object;
+        }>;
+        listConnected: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                info: undefined;
+                status?: undefined;
+                connectedSince: number;
+            }[];
+            meta: object;
+        }>;
+        getAssignments: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                cameraId?: string | undefined;
+            };
+            output: undefined[];
+            meta: object;
+        }>;
+        setAssignment: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                agentId: string;
+                role: "detector" | "decoder" | "transcoder" | "recorder";
+                cameraId: string;
+                priority: "backup" | "primary" | "overflow";
+                rtspUrl?: string | undefined;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        removeAssignment: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                role: "detector" | "decoder" | "transcoder" | "recorder";
+                cameraId: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        dispatchBenchmark: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                config: {
+                    durationMs: number;
+                    runtime: string;
+                    warmupMs: number;
+                    inputWidth: number;
+                    inputHeight: number;
+                    modelId?: string | undefined;
+                };
+                agentId: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        runRemoteBenchmark: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                agentId: string;
+                runtime: string;
+                durationMs?: number | undefined;
+                modelId?: string | undefined;
+                warmupMs?: number | undefined;
+                inputWidth?: number | undefined;
+                inputHeight?: number | undefined;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        startTestWorker: _trpc_server.TRPCMutationProcedure<{
+            input: void;
+            output: {
+                ok: boolean;
+            };
+            meta: object;
+        }>;
+        stopTestWorker: _trpc_server.TRPCMutationProcedure<{
+            input: void;
+            output: {
+                ok: boolean;
+            };
+            meta: object;
+        }>;
+        isTestWorkerRunning: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                running: boolean;
+            };
+            meta: object;
+        }>;
+    }>>;
+    agent: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        register: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                name: string;
+                id: string;
+                capabilities: string[];
+                platform: string;
+                arch: string;
+                cpuCores: number;
+                memoryMB: number;
+                port?: number | undefined;
+                host?: string | undefined;
+                gpuModel?: string | undefined;
+                pythonRuntimes?: string[] | undefined;
+                installedAddons?: string[] | undefined;
+                taskTypes?: string[] | undefined;
+                httpPort?: number | undefined;
+            };
+            output: {
+                ok: boolean;
+                agentId: string;
+            };
+            meta: object;
+        }>;
+        heartbeat: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                agentId: string;
+                cpuPercent: number;
+                memoryUsedMB: number;
+                subProcesses?: {
+                    name: string;
+                    state: "running" | "stopped" | "crashed";
+                    pid: number;
+                    command: string;
+                    cpuPercent: number;
+                    memoryRss: number;
+                    uptimeSeconds: number;
+                }[] | undefined;
+                activeTasks?: number | undefined;
+            };
+            output: {
+                ok: boolean;
+            };
+            meta: object;
+        }>;
+        onTaskAssignment: _trpc_server.TRPCSubscriptionProcedure<{
+            input: void;
+            output: {
+                taskId: string;
+                taskType: string;
+                payload: unknown;
+            };
+            meta: object;
+        }>;
+        reportTaskResult: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                success: boolean;
+                taskId: string;
+                agentId: string;
+                error?: string | undefined;
+                output?: Record<string, unknown> | undefined;
+                durationMs?: number | undefined;
+            };
+            output: {
+                ok: boolean;
+            };
+            meta: object;
+        }>;
+        processTree: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: string;
+                name: string;
+                pid: number;
+                state: "running";
+                cpuPercent: number;
+                memoryPercent: number;
+                memoryMB: number;
+                isHub: boolean;
+                platform: string;
+                arch: string;
+                host: string;
+                capabilities: string[];
+                installedAddons: string[];
+                pythonRuntimes: string[];
+                connectedSince: number;
+                subProcesses: unknown[];
+            }[];
+            meta: object;
+        }>;
+        installAddon: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                package: string;
+                agentId: string;
+                version?: string | undefined;
+            };
+            output: {
+                ok: boolean;
+            };
+            meta: object;
+        }>;
+    }>>;
+    backup: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        trigger: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                label?: string | undefined;
+                locations?: string[] | undefined;
+            } | undefined;
+            output: undefined;
+            meta: object;
+        }>;
+        list: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: readonly undefined[];
+            meta: object;
+        }>;
+        restore: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                backupId: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        delete: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                backupId: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+    }>>;
+    repl: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        execute: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                code: string;
+                scope: {
+                    type: "system";
+                } | {
+                    deviceId: string;
+                    type: "device";
+                } | {
+                    type: "provider";
+                    providerId: string;
+                } | {
+                    type: "addon";
+                    addonId: string;
+                };
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        completions: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                partial: string;
+                scope: {
+                    type: "system";
+                } | {
+                    deviceId: string;
+                    type: "device";
+                } | {
+                    type: "provider";
+                    providerId: string;
+                } | {
+                    type: "addon";
+                    addonId: string;
+                };
+            };
+            output: string[];
+            meta: object;
+        }>;
+    }>>;
+    knownFaces: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        list: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: string;
+                label: string;
+                group?: string;
+                cropBase64: string;
+                createdAt: number;
+                updatedAt: number;
+                source?: string;
+                metadata?: Readonly<Record<string, unknown>>;
+            }[];
+            meta: object;
+        }>;
+        register: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                label: string;
+                cropBase64: string;
+                group?: string | undefined;
+            };
+            output: never;
+            meta: object;
+        }>;
+        delete: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        update: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+                group?: string | undefined;
+                label?: string | undefined;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        recalculate: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: never;
+            meta: object;
+        }>;
+        match: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                cropBase64: string;
+                threshold?: number | undefined;
+            };
+            output: never;
+            meta: object;
+        }>;
+        batchRegister: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                label: string;
+                cropBase64: string;
+                group?: string | undefined;
+            }[];
+            output: never;
+            meta: object;
+        }>;
+    }>>;
+    session: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        getActiveTracks: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId?: string | undefined;
+            };
+            output: {
+                trackId: string;
+                deviceId: string;
+                className: string;
+                label: string | undefined;
+                firstSeen: number;
+                lastSeen: number;
+                totalFrames: number;
+                state: string;
+                globalId: string | undefined;
+                positions: readonly {
+                    readonly x: number;
+                    readonly y: number;
+                    readonly t: number;
+                }[];
+                hasEmbedding: boolean;
+                hasCrop: boolean;
+            }[];
+            meta: object;
+        }>;
+        getTrackCounts: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: unknown;
+            meta: object;
+        }>;
+        getTrack: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                trackId: string;
+            };
+            output: {
+                positions: {
+                    readonly x: number;
+                    readonly y: number;
+                    readonly t: number;
+                }[];
+                trackId: string;
+                deviceId: string;
+                className: string;
+                label: string | undefined;
+                firstSeen: number;
+                lastSeen: number;
+                totalFrames: number;
+                state: string;
+                globalId: string | undefined;
+                hasEmbedding: boolean;
+                hasCrop: boolean;
+            } | null;
+            meta: object;
+        }>;
+        clearTracks: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                deviceId?: string | undefined;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+    }>>;
+    trackMedia: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        getEventMedia: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                eventId: string;
+            };
+            output: {
+                path: string;
+                type: undefined;
+                source: "buffer" | "storage";
+                base64: string;
+                sizeBytes: number;
+            }[];
+            meta: object;
+        }>;
+        getTrackMedia: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                trackId: string;
+            };
+            output: {
+                path: string;
+                type: undefined;
+                source: "buffer" | "storage";
+                base64: string;
+                sizeBytes: number;
+            }[];
+            meta: object;
+        }>;
+        getDeviceMedia: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                since?: number | undefined;
+                until?: number | undefined;
+            };
+            output: {
+                path: string;
+                type: undefined;
+                source: "buffer" | "storage";
+                base64: string;
+                sizeBytes: number;
+            }[];
+            meta: object;
+        }>;
+        getBufferStatus: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: unknown;
+            meta: object;
+        }>;
+    }>>;
+    trackTrail: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        getTrail: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                trackId: string;
+            };
+            output: unknown;
+            meta: object;
+        }>;
+        getActiveTrails: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: unknown;
+            meta: object;
+        }>;
+        listTrails: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                limit?: number | undefined;
+                since?: number | undefined;
+                until?: number | undefined;
+                className?: string | undefined;
+            };
+            output: unknown;
+            meta: object;
+        }>;
+        setConfig: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                deviceId: string;
+                enabled?: boolean | undefined;
+                snapshotIntervalMs?: number | undefined;
+                maxTrailLength?: number | undefined;
+                saveThumbnails?: boolean | undefined;
+            };
+            output: unknown;
+            meta: object;
+        }>;
+        getConfig: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: unknown;
+            meta: object;
+        }>;
+    }>>;
+    recording: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        enable: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                deviceId: string;
+                policy: {
+                    mode: "motion" | "continuous" | "scheduled" | "composite";
+                    enabled: boolean;
+                    streams: {
+                        mode: "inherit" | "always";
+                        streamId: string;
+                    }[];
+                    preBufferSec?: number | undefined;
+                    postBufferSec?: number | undefined;
+                    scheduleRules?: {
+                        mode: "motion" | "continuous";
+                        days: number[];
+                        startTime: string;
+                        endTime: string;
+                    }[] | undefined;
+                };
+                storageOverrides?: {
+                    dataCategory: "recording:main" | "recording:mid" | "recording:sub" | "thumbnail:scrub" | "thumbnail:event";
+                    storageName: string;
+                    subDirectory: string;
+                    retentionDays?: number | null | undefined;
+                    retentionGb?: number | null | undefined;
+                }[] | undefined;
+                ffmpegOverrides?: {
+                    path?: string | undefined;
+                    hwaccel?: "none" | "vaapi" | "qsv" | "videotoolbox" | "cuda" | "v4l2m2m" | undefined;
+                    threads?: number | undefined;
+                    inputArgs?: string[] | undefined;
+                    outputArgs?: string[] | undefined;
+                    videoCodec?: string | undefined;
+                    audioCodec?: string | undefined;
+                } | undefined;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        disable: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        getConfig: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: unknown;
+            meta: object;
+        }>;
+        updateConfig: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                deviceId: string;
+                policy: {
+                    mode: "motion" | "continuous" | "scheduled" | "composite";
+                    enabled: boolean;
+                    streams: {
+                        mode: "inherit" | "always";
+                        streamId: string;
+                    }[];
+                    preBufferSec?: number | undefined;
+                    postBufferSec?: number | undefined;
+                    scheduleRules?: {
+                        mode: "motion" | "continuous";
+                        days: number[];
+                        startTime: string;
+                        endTime: string;
+                    }[] | undefined;
+                };
+                ffmpegOverrides?: {
+                    path?: string | undefined;
+                    hwaccel?: "none" | "vaapi" | "qsv" | "videotoolbox" | "cuda" | "v4l2m2m" | undefined;
+                    threads?: number | undefined;
+                    inputArgs?: string[] | undefined;
+                    outputArgs?: string[] | undefined;
+                    videoCodec?: string | undefined;
+                    audioCodec?: string | undefined;
+                } | undefined;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        getPlaylist: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                streamId: string;
+                startTime: number;
+                endTime: number;
+                live?: boolean | undefined;
+            };
+            output: unknown;
+            meta: object;
+        }>;
+        getThumbnail: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                timestamp: number;
+                category?: "scrub" | "event" | undefined;
+            };
+            output: unknown;
+            meta: object;
+        }>;
+        getSegments: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                streamId: string;
+                startTime: number;
+                endTime: number;
+            };
+            output: unknown;
+            meta: object;
+        }>;
+        getAvailability: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                startTime: number;
+                endTime: number;
+            };
+            output: unknown;
+            meta: object;
+        }>;
+        estimateStorage: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                motionInput?: {
+                    avgEventsPerDay: number;
+                    avgDurationSec: number;
+                } | undefined;
+            };
+            output: {
+                [key: string]: unknown;
+                totalEstimatedGb: number;
+            };
+            meta: object;
+        }>;
+        estimateGlobalStorage: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                devices: {
+                    deviceId: string;
+                    estimate: {
+                        [key: string]: unknown;
+                        totalEstimatedGb: number;
+                    };
+                }[];
+                totalEstimatedGb: number;
+            };
+            meta: object;
+        }>;
+        getStorageUsage: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                streamId: string;
+            };
+            output: unknown;
+            meta: object;
+        }>;
+        setPolicy: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                deviceId: string;
+                policy: {
+                    mode: "motion" | "continuous" | "scheduled" | "composite";
+                    enabled: boolean;
+                    streams: {
+                        mode: "inherit" | "always";
+                        streamId: string;
+                    }[];
+                    preBufferSec?: number | undefined;
+                    postBufferSec?: number | undefined;
+                    scheduleRules?: {
+                        mode: "motion" | "continuous";
+                        days: number[];
+                        startTime: string;
+                        endTime: string;
+                    }[] | undefined;
+                };
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        getPolicy: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: unknown;
+            meta: object;
+        }>;
+        getPolicyStatus: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: {
+                deviceId: string;
+                policyExists: boolean;
+                enabled: any;
+                mode: any;
+                isRecording: boolean;
+            };
+            meta: object;
+        }>;
+        getMotionStats: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                startTime: number;
+                endTime: number;
+            };
+            output: {
+                avgEventsPerDay: number;
+                avgDurationSec: number;
+                dutyCyclePercent: number;
+                totalEvents: number;
+            };
+            meta: object;
+        }>;
+        getRetentionConfig: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+                dataCategory: "recording:main" | "recording:mid" | "recording:sub" | "thumbnail:scrub" | "thumbnail:event";
+            };
+            output: unknown;
+            meta: object;
+        }>;
+        updateRetentionConfig: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                deviceId: string;
+                retentionDays: number | null;
+                dataCategory: "recording:main" | "recording:mid" | "recording:sub" | "thumbnail:scrub" | "thumbnail:event";
+                storageName: string;
+                subDirectory: string;
+                retentionGb: number | null;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+    }>>;
+    network: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        getDeviceStats: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: undefined | null;
+            meta: object;
+        }>;
+        getAllStats: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: readonly undefined[];
+            meta: object;
+        }>;
+        reportClientStats: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                deviceId: string;
+                rttMs: number;
+                jitterMs: number;
+                estimatedBandwidthKbps: number;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+    }>>;
+    addons: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        list: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                manifest: undefined & {
+                    packageName: string;
+                    packageVersion: string;
+                    removable?: boolean;
+                };
+                hasConfigSchema: boolean;
+                source: "core" | "installed" | "workspace";
+            }[];
+            meta: object;
+        }>;
+        getConfigSchema: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                addonId: string;
+            };
+            output: undefined | null;
+            meta: object;
+        }>;
+        getConfig: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                addonId: string;
+            };
+            output: Record<string, unknown>;
+            meta: object;
+        }>;
+        updateConfig: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                config: Record<string, unknown>;
+                addonId: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        getLogs: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                addonId: string;
+                level?: "error" | "info" | "debug" | "warn" | undefined;
+                limit?: number | undefined;
+            };
+            output: undefined[];
+            meta: object;
+        }>;
+    }>>;
+    bridgePipeline: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        listAddons: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: string;
+                packageName: string;
+                slot: undefined | null;
+            }[];
+            meta: object;
+        }>;
+        getPipeline: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: undefined | null;
+            meta: object;
+        }>;
+        setPipeline: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                config: {
+                    video: any[];
+                    audio?: any;
+                };
+                deviceId: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        validatePipeline: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                video: any[];
+                audio?: any;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        getAddonConfig: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                addonId: string;
+            };
+            output: Record<string, unknown>;
+            meta: object;
+        }>;
+        setAddonConfig: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                config: Record<string, unknown>;
+                addonId: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        processFrame: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: {
+                results: never[];
+                totalMs: number;
+                timings: {};
+                frameTimestamp: number;
+            };
+            meta: object;
+        }>;
+    }>>;
+    bridgeAddons: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        listPackages: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: undefined[];
+            meta: object;
+        }>;
+        listAddons: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: string;
+                packageName: string;
+                slot: undefined | null;
+            }[];
+            meta: object;
+        }>;
+        installPackage: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                packageName: string;
+                version?: string | undefined;
+            };
+            output: {
+                success: boolean;
+                loaded: string[];
+                failed: string[];
+            };
+            meta: object;
+        }>;
+        uninstallPackage: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                packageName: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        reloadPackages: _trpc_server.TRPCMutationProcedure<{
+            input: void;
+            output: {
+                success: boolean;
+                message: string;
+            };
+            meta: object;
+        }>;
+        searchAvailable: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                query?: string | undefined;
+            } | undefined;
+            output: {
+                installed: boolean;
+                installedVersion: string | undefined;
+                name: string;
+                version: string;
+                description: string;
+                keywords: string[];
+                publishedAt: string;
+                author: string;
+            }[];
+            meta: object;
+        }>;
+    }>>;
+    detection: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        orchestratorStatus: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: undefined;
+            meta: object;
+        }>;
+        cameraDetectionStatus: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: undefined | undefined;
+            meta: object;
+        }>;
+        brokerStatus: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: undefined | null;
+            meta: object;
+        }>;
+        listBrokers: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                deviceId: string;
+                status: undefined;
+                stats: undefined;
+            }[];
+            meta: object;
+        }>;
+    }>>;
+    capabilities: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        listCapabilities: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: undefined[];
+            meta: object;
+        }>;
+        getCapability: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                name: string;
+            };
+            output: undefined | null;
+            meta: object;
+        }>;
+        setActiveSingleton: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                capability: string;
+                addonId: string;
+            };
+            output: void;
+            meta: object;
+        }>;
+        setDeviceCapability: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                capability: string;
+                deviceId: string;
+                addonId: string;
+            };
+            output: void;
+            meta: object;
+        }>;
+        clearDeviceCapability: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                capability: string;
+                deviceId: string;
+            };
+            output: void;
+            meta: object;
+        }>;
+        getDeviceCapabilities: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: {
+                [k: string]: string;
+            };
+            meta: object;
+        }>;
+        setDeviceCollectionFilter: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                capability: string;
+                deviceId: string;
+                addonIds: string[];
+            };
+            output: void;
+            meta: object;
+        }>;
+        clearDeviceCollectionFilter: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                capability: string;
+                deviceId: string;
+            };
+            output: void;
+            meta: object;
+        }>;
+    }>>;
+    update: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        listUpdates: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: readonly undefined[];
+            meta: object;
+        }>;
+        updatePackage: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                name: string;
+                version?: string | undefined;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        restartServer: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                confirm: true;
+            };
+            output: {
+                success: boolean;
+                message: string;
+            };
+            meta: object;
+        }>;
+    }>>;
+    addonPages: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        listPages: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: readonly undefined[];
+            meta: object;
+        }>;
+    }>>;
+    benchmark: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        listDetectors: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: string;
+                name: string;
+                packageName: string;
+                hasConfig: boolean;
+            }[];
+            meta: object;
+        }>;
+        getDetectorDetails: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                addonId: string;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        listDetectorsDetailed: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: undefined[];
+            meta: object;
+        }>;
+        systemInfo: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                platform: NodeJS.Platform;
+                arch: string;
+                cpus: number;
+                cpuModel: string;
+                totalMemoryMB: number;
+                freeMemoryMB: number;
+                nodeVersion: string;
+                gpuModel: string | undefined;
+            };
+            meta: object;
+        }>;
+        runBenchmark: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                addonId: string;
+                warmup?: number | undefined;
+                backend?: string | undefined;
+                runtime?: string | undefined;
+                modelId?: string | undefined;
+                inputWidth?: number | undefined;
+                inputHeight?: number | undefined;
+                durationSec?: number | undefined;
+                simulatedCameras?: number | undefined;
+                batchSize?: number | undefined;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        onBenchmarkProgress: _trpc_server.TRPCSubscriptionProcedure<{
+            input: void;
+            output: undefined;
+            meta: object;
+        }>;
+        detectImage: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                addonId: string;
+                imageBase64: string;
+                imageWidth: number;
+                imageHeight: number;
+                confidenceThreshold?: number | undefined;
+            };
+            output: {
+                inferenceMs: number;
+                modelId: any;
+                detections: any;
+            };
+            meta: object;
+        }>;
+        captureSnapshot: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                deviceId: string;
+            };
+            output: {
+                imageBase64: any;
+                width: any;
+                height: any;
+            };
+            meta: object;
+        }>;
+        pipelineMetrics: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                orchestrator: null;
+                cameras: never[];
+            } | {
+                orchestrator: undefined;
+                cameras: ({
+                    deviceId: string;
+                } & undefined)[];
+            };
+            meta: object;
+        }>;
+        onPipelineMetrics: _trpc_server.TRPCSubscriptionProcedure<{
+            input: {
+                deviceId?: string | undefined;
+                intervalMs?: number | undefined;
+            };
+            output: {
+                orchestrator: any;
+                cameras: any[];
+                timestamp: number;
+            };
+            meta: object;
+        }>;
+        listHistory: _trpc_server.TRPCQueryProcedure<{
+            input: {
+                addonId?: string | undefined;
+                agentName?: string | undefined;
+            } | undefined;
+            output: undefined[];
+            meta: object;
+        }>;
+        saveHistory: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                addonId: string;
+                warmup: number;
+                fps: number;
+                runtime: string;
+                totalDetections: number;
+                iterations: number;
+                inputResolution: string;
+                peakMemoryMB: number;
+                dps: number;
+                inferenceAvgMs: number;
+                avgMs: number;
+                p50Ms: number;
+                p95Ms: number;
+                p99Ms: number;
+                minMs: number;
+                maxMs: number;
+                agentName: string;
+                modelName: string;
+                simulatedCameras?: number | undefined;
+                batchSize?: number | undefined;
+                errorCount?: number | undefined;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        deleteHistory: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        clearHistory: _trpc_server.TRPCMutationProcedure<{
+            input: void;
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+        listAgents: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: any;
+                name: any;
+                status: string;
+                type: string;
+                capabilities: any;
+                platform: any;
+                arch: any;
+                cpuCores: any;
+                memoryMB: any;
+                gpuModel: any;
+                runtimes: {
+                    value: string;
+                    label: string;
+                }[];
+                backends: {
+                    value: string;
+                    label: string;
+                }[];
+                installedAddons: any;
+            }[];
+            meta: object;
+        }>;
+        runRemoteBenchmark: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                agentId: string;
+                warmup?: number | undefined;
+                runtime?: string | undefined;
+                inputWidth?: number | undefined;
+                inputHeight?: number | undefined;
+                iterations?: number | undefined;
+            };
+            output: {
+                agentId: string;
+                runtime: any;
+                iterations: any;
+                fps: any;
+                avgMs: any;
+                p50Ms: any;
+                p95Ms: any;
+                p99Ms: any;
+                minMs: any;
+                maxMs: any;
+                peakMemoryMB: any;
+            };
+            meta: object;
+        }>;
+        runLatencyTest: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                addonId: string;
+                iterations?: number | undefined;
+            };
+            output: {
+                addonId: string;
+                error: string;
+                iterations: number;
+                results: never[];
+                avgMs?: undefined;
+                minMs?: undefined;
+                maxMs?: undefined;
+                fps?: undefined;
+            } | {
+                addonId: string;
+                iterations: number;
+                avgMs: number;
+                minMs: number;
+                maxMs: number;
+                fps: number;
+                results: {
+                    iteration: number;
+                    durationMs: number;
+                }[];
+                error?: undefined;
+            };
+            meta: object;
+        }>;
+    }>>;
+    pipeline: _trpc_server.TRPCBuiltRouter<{
+        ctx: {
+            user: {
+                id: string;
+                username: string;
+                role: string;
+            } | null;
+        };
+        meta: object;
+        errorShape: _trpc_server.TRPCDefaultErrorShape;
+        transformer: true;
+    }, _trpc_server.TRPCDecorateCreateRouterOptions<{
+        getSchema: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: undefined;
+            meta: object;
+        }>;
+        listTemplates: _trpc_server.TRPCQueryProcedure<{
+            input: void;
+            output: undefined[];
+            meta: object;
+        }>;
+        saveTemplate: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                name: string;
+                steps?: any;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        updateTemplate: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+                name?: string | undefined;
+                steps?: any;
+            };
+            output: undefined;
+            meta: object;
+        }>;
+        deleteTemplate: _trpc_server.TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                success: boolean;
+            };
+            meta: object;
+        }>;
+    }>>;
+}>>;
+/** @deprecated Use AppRouter instead */
+type AddonApi = AppRouter;
+
+/**
+ * All location types that storage providers can serve.
+ * Each type maps to a logical category of files.
+ * A storage provider declares which location types it supports.
+ */
+type StorageLocationType = 'recordings-high' | 'recordings-low' | 'recordings-clips' | 'event-images' | 'models' | 'addons-data' | 'cache' | 'logs';
+/** All location types as an array (for iteration) */
+declare const STORAGE_LOCATION_TYPES: readonly StorageLocationType[];
+/** Default subdirectory names for filesystem storage */
+declare const DEFAULT_LOCATION_SUBDIRS: Readonly<Record<StorageLocationType, string>>;
+/**
+ * A storage provider serves file-based storage for one or more location types.
+ * Multiple providers can coexist (local filesystem, NAS, S3, etc.).
+ * Each addon/system setting selects which provider to use per location type.
+ */
+interface IStorageProvider {
+    /** Unique provider ID (e.g., 'local', 'nas-synology', 's3-aws') */
+    readonly id: string;
+    /** Human-readable name (e.g., 'Local Filesystem', 'Synology NAS') */
+    readonly name: string;
+    /** Which location types this provider serves */
+    readonly supportedLocations: readonly StorageLocationType[];
+    /** Resolve an absolute path/URL for a file within a location */
+    resolve(location: StorageLocationType, relativePath: string): string;
+    /** Write file data */
+    write(location: StorageLocationType, relativePath: string, data: Buffer | NodeJS.ReadableStream): Promise<void>;
+    /** Read file data */
+    read(location: StorageLocationType, relativePath: string): Promise<Buffer>;
+    /** Check if a file exists */
+    exists(location: StorageLocationType, relativePath: string): Promise<boolean>;
+    /** List files/directories under a prefix within a location */
+    list(location: StorageLocationType, prefix?: string): Promise<readonly string[]>;
+    /** Delete a file */
+    delete(location: StorageLocationType, relativePath: string): Promise<void>;
+    /** Get available space in bytes, null if unknown (e.g., S3) */
+    getAvailableSpace(location: StorageLocationType): Promise<number | null>;
+    /** Lifecycle */
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+/**
+ * All named collections that the settings backend manages.
+ * Each collection maps to a logical table/bucket in the backend.
+ */
+type SettingsCollection = 'system-settings' | 'addon-settings' | 'provider-settings' | 'device-settings' | 'detection-events' | 'audio-levels' | 'track-trails' | 'recording-segments' | 'recording-thumbnails' | 'recording-policies' | 'recording-storage-config' | 'recording-cleanup-queue' | 'known-faces';
+/**
+ * Settings backend — persistent key-value and document storage.
+ * Default implementation: SQLite. Can be replaced by Postgres, etc.
+ */
+interface ISettingsBackend {
+    /** Get a single value by key from a collection */
+    get(collection: SettingsCollection, key: string): Promise<unknown>;
+    /** Set a value by key in a collection (upsert) */
+    set(collection: SettingsCollection, key: string, value: unknown): Promise<void>;
+    /** Get all entries matching an optional filter */
+    query(collection: SettingsCollection, filter?: QueryFilter): Promise<readonly SettingsRecord[]>;
+    /** Insert a new record */
+    insert(collection: SettingsCollection, record: SettingsRecord): Promise<void>;
+    /** Update an existing record by ID */
+    update(collection: SettingsCollection, id: string, data: Record<string, unknown>): Promise<void>;
+    /** Delete a record by key/ID */
+    delete(collection: SettingsCollection, key: string): Promise<void>;
+    /** Count entries in a collection */
+    count(collection: SettingsCollection, filter?: QueryFilter): Promise<number>;
+    /** Check if a collection is empty (used for first-boot detection) */
+    isEmpty(collection: SettingsCollection): Promise<boolean>;
+    /** Lifecycle */
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+interface SettingsRecord {
+    readonly id: string;
+    readonly data: Record<string, unknown>;
+}
+interface QueryFilter {
+    where?: Record<string, unknown>;
+    whereIn?: Record<string, unknown[]>;
+    whereBetween?: Record<string, [unknown, unknown]>;
+    orderBy?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Embeddings backend — vector storage with approximate nearest neighbor search.
+ * Used for CLIP frame search, face recognition, plate matching.
+ * Default implementation: HNSW (usearch/hnswlib). Can be replaced by Qdrant, etc.
+ */
+interface IEmbeddingsBackend {
+    /** Create or open a named vector index */
+    openIndex(name: string, dimensions: number): Promise<IVectorIndex>;
+    /** List all index names */
+    listIndexes(): Promise<readonly string[]>;
+    /** Delete an index and its data */
+    deleteIndex(name: string): Promise<void>;
+    /** Lifecycle */
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+interface IVectorIndex {
+    /** Index name */
+    readonly name: string;
+    /** Vector dimensions */
+    readonly dimensions: number;
+    /** Insert a vector with ID and optional metadata */
+    insert(id: string, vector: Float32Array, metadata?: Record<string, unknown>): Promise<void>;
+    /** Batch insert for performance */
+    insertBatch(items: readonly VectorEntry[]): Promise<void>;
+    /** Search for nearest neighbors */
+    search(query: Float32Array, topK: number, filter?: EmbeddingFilter): Promise<readonly VectorSearchResult[]>;
+    /** Delete by ID */
+    delete(id: string): Promise<void>;
+    /** Count entries in the index */
+    count(): Promise<number>;
+    /** Flush pending writes to disk */
+    flush(): Promise<void>;
+}
+interface VectorEntry {
+    readonly id: string;
+    readonly vector: Float32Array;
+    readonly metadata?: Record<string, unknown>;
+}
+interface VectorSearchResult {
+    readonly id: string;
+    /** Similarity score (0-1, higher is more similar) */
+    readonly score: number;
+    readonly metadata?: Record<string, unknown>;
+}
+interface EmbeddingFilter {
+    /** Filter by metadata key-value before vector search */
+    readonly where?: Record<string, unknown>;
+    /** Filter by timestamp range */
+    readonly timestampAfter?: number;
+    readonly timestampBefore?: number;
+    /** Filter by device */
+    readonly deviceId?: string;
+}
+/** @deprecated Use StorageLocationType instead */
+type StorageLocationName = StorageLocationType | 'data' | 'media' | 'recordings' | 'config' | 'events' | 'addon';
+/** @deprecated Use IStorageProvider instead */
+interface StorageConfig {
+    locations: Record<string, string>;
+}
+/** @deprecated Use SettingsRecord instead */
+interface StorageRecord {
+    collection: string;
+    id: string;
+    data: Record<string, unknown>;
+}
+/** @deprecated Use ISettingsBackend instead */
+interface IStructuredStorage {
+    query(collection: string, filter?: QueryFilter): Promise<readonly StorageRecord[]>;
+    insert(record: StorageRecord): Promise<StorageRecord>;
+    update(collection: string, id: string, data: Record<string, unknown>): Promise<StorageRecord>;
+    delete(collection: string, id: string): Promise<void>;
+    count(collection: string, filter?: QueryFilter): Promise<number>;
+}
+/** @deprecated Use IStorageProvider.read/write instead */
+interface IFileStorage {
+    readFile(path: string): Promise<Buffer>;
+    writeFile(path: string, data: Buffer): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    listFiles(prefix?: string): Promise<readonly string[]>;
+    getFileUrl(path: string): Promise<string>;
+    exists(path: string): Promise<boolean>;
+}
+/** @deprecated Use IStorageProvider instead */
+interface IStorageLocation {
+    structured?: IStructuredStorage;
+    files?: IFileStorage;
+}
+
 /**
  * Configuration UI Schema -- declarative form definition for any element.
  *
@@ -534,7 +3485,7 @@ interface ConfigSection {
     columns?: 1 | 2 | 3 | 4;
     fields: ConfigField[];
 }
-type ConfigField = ConfigTextField | ConfigNumberField | ConfigBooleanField | ConfigSelectField | ConfigMultiSelectField | ConfigColorField | ConfigPasswordField | ConfigTextAreaField | ConfigSliderField | ConfigTagsField | ConfigGroupField | ConfigSeparatorField | ConfigInfoField | ConfigModelSelectorField;
+type ConfigField = ConfigTextField | ConfigNumberField | ConfigBooleanField | ConfigSelectField | ConfigMultiSelectField | ConfigColorField | ConfigPasswordField | ConfigTextAreaField | ConfigSliderField | ConfigTagsField | ConfigGroupField | ConfigSeparatorField | ConfigInfoField | ConfigModelSelectorField | ConfigStorageLocationField;
 interface ConfigFieldBase {
     key: string;
     label: string;
@@ -653,6 +3604,14 @@ interface ConfigModelSelectorField extends ConfigFieldBase {
     requiredMetadata?: readonly (keyof CustomModelMetadata)[];
     outputFormatHint?: ModelOutputFormat;
 }
+
+interface ConfigStorageLocationField extends ConfigFieldBase {
+    type: 'storage-location';
+    /** Which location type this field selects a provider for */
+    locationType: StorageLocationType;
+    /** Show available space indicator next to each provider option */
+    showAvailableSpace?: boolean;
+}
 interface IConfigurable {
     getConfigSchema(): ConfigUISchema;
     getConfig(): Record<string, unknown>;
@@ -787,53 +3746,6 @@ interface IEventBus {
     getRecent(filter?: EventFilter, limit?: number): readonly SystemEvent[];
 }
 
-type StorageLocationName = 'data' | 'media' | 'recordings' | 'models' | 'cache' | 'logs' | 'config' | 'events' | 'addon';
-interface StorageConfig {
-    locations: Record<StorageLocationName, string>;
-}
-interface QueryFilter {
-    where?: Record<string, unknown>;
-    whereIn?: Record<string, unknown[]>;
-    whereBetween?: Record<string, [unknown, unknown]>;
-    orderBy?: {
-        field: string;
-        direction: 'asc' | 'desc';
-    };
-    limit?: number;
-    offset?: number;
-}
-interface StorageRecord {
-    collection: string;
-    id: string;
-    data: Record<string, unknown>;
-}
-interface IStructuredStorage {
-    query(collection: string, filter?: QueryFilter): Promise<readonly StorageRecord[]>;
-    insert(record: StorageRecord): Promise<StorageRecord>;
-    update(collection: string, id: string, data: Record<string, unknown>): Promise<StorageRecord>;
-    delete(collection: string, id: string): Promise<void>;
-    count(collection: string, filter?: QueryFilter): Promise<number>;
-}
-interface IFileStorage {
-    readFile(path: string): Promise<Buffer>;
-    writeFile(path: string, data: Buffer): Promise<void>;
-    deleteFile(path: string): Promise<void>;
-    listFiles(prefix?: string): Promise<readonly string[]>;
-    getFileUrl(path: string): Promise<string>;
-    exists(path: string): Promise<boolean>;
-}
-interface IStorageLocation {
-    structured?: IStructuredStorage;
-    files?: IFileStorage;
-}
-interface IStorageProvider {
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    getLocation(name: StorageLocationName): IStorageLocation;
-    export(locationName: StorageLocationName): Promise<Buffer>;
-    import(locationName: StorageLocationName, data: Buffer): Promise<void>;
-}
-
 interface ICameraAnalyticsProvider {
     getLiveState(deviceId: string): CameraLiveState | null;
     getTracks(deviceId: string, filter?: TrackFilter): TrackedObjectSummary[];
@@ -846,7 +3758,8 @@ interface ICameraAnalyticsProvider {
 interface IAnalysisAddon extends ICamstackAddon, ICameraAnalyticsProvider {
     processFrame(deviceId: string, frame: FrameInput): Promise<DetectionEvent[]>;
     setCameraPipeline(deviceId: string, config: PipelineConfig): void;
-    setCameraZones(deviceId: string, zones: ZoneDefinition[]): void;
+    setCameraZones(deviceId: string, zones: readonly CameraZone[]): void;
+    setCameraMotionConfig(deviceId: string, source: MotionSource): void;
     setKnownFaces(faces: KnownFace[]): void;
     setKnownPlates(plates: KnownPlate[]): void;
     onLiveStateChange(deviceId: string, callback: (state: CameraLiveState) => void): () => void;
@@ -1596,30 +4509,108 @@ interface IKnownFaces {
         readonly group?: string;
     }>, clipRecognizer: ClipRecognizer): Promise<unknown>;
 }
-/**
- * Composite interface exposed via CapabilityRegistry as the
- * 'analysis-data-persistence' singleton. Each sub-service is wired
- * individually to the corresponding NestJS wrapper service.
- */
-interface IAnalysisDataPersistence {
-    readonly eventPersistence: IEventPersistence;
-    readonly knownFaces: IKnownFaces;
-    readonly sessionTracker: ISessionTracker;
-    readonly retention: IRetention;
-    readonly trackTrail: ITrackTrail;
+/**
+ * Composite interface exposed via CapabilityRegistry as the
+ * 'analysis-data-persistence' singleton. Each sub-service is wired
+ * individually to the corresponding NestJS wrapper service.
+ */
+interface IAnalysisDataPersistence {
+    readonly eventPersistence: IEventPersistence;
+    readonly knownFaces: IKnownFaces;
+    readonly sessionTracker: ISessionTracker;
+    readonly retention: IRetention;
+    readonly trackTrail: ITrackTrail;
+}
+interface TestConnectionResult {
+    readonly success: boolean;
+    readonly version?: string;
+    readonly cameraCount?: number;
+    readonly error?: string;
+}
+/**
+ * Generic interface for testing provider connections.
+ * Each provider addon can expose a connection tester.
+ */
+interface IProviderConnectionTester {
+    testConnection(): Promise<TestConnectionResult>;
+}
+
+interface EmbeddingMetadata {
+    readonly timestamp: number;
+    readonly className: string;
+    readonly deviceId: string;
+    readonly zoneId?: string;
+    readonly labelsData?: readonly LabelData[];
+}
+interface SceneStateResult {
+    readonly previousState: string;
+    readonly currentState: string;
+    readonly confidence: number;
+}
+interface ISceneIntelligence {
+    embed(deviceId: string, crop: Buffer, metadata: EmbeddingMetadata): Promise<string>;
+    search(query: string, topK: number, filter?: EmbeddingFilter): Promise<VectorSearchResult[]>;
+    searchByImage(image: Buffer, topK: number, filter?: EmbeddingFilter): Promise<VectorSearchResult[]>;
+    evaluateSceneState(deviceId: string, crop: Buffer): Promise<SceneStateResult | null>;
+}
+
+interface NotificationRule {
+    readonly id: string;
+    readonly name: string;
+    readonly enabled: boolean;
+    readonly eventTypes: readonly string[];
+    readonly conditions: {
+        readonly deviceIds?: readonly string[];
+        readonly classNames?: readonly string[];
+        readonly zoneIds?: readonly string[];
+        readonly minConfidence?: number;
+        readonly source?: 'pipeline' | 'onboard' | 'any';
+        readonly schedule?: {
+            readonly days: readonly number[];
+            readonly startHour: number;
+            readonly endHour: number;
+        };
+        readonly cooldownSeconds?: number;
+        readonly minDwellSeconds?: number;
+    };
+    readonly outputs: readonly string[];
+    readonly template?: {
+        readonly title: string;
+        readonly body: string;
+        readonly imageMode: 'crop' | 'annotated' | 'full' | 'none';
+    };
+    readonly priority: 'low' | 'normal' | 'high' | 'critical';
+}
+interface NotificationTestResult {
+    readonly ruleId: string;
+    readonly eventId: string;
+    readonly timestamp: number;
+    readonly wouldFire: boolean;
+    readonly reason?: string;
+}
+interface NotificationHistoryFilter {
+    readonly ruleId?: string;
+    readonly deviceId?: string;
+    readonly from?: number;
+    readonly to?: number;
+    readonly limit?: number;
 }
-interface TestConnectionResult {
+interface NotificationHistoryEntry {
+    readonly id: string;
+    readonly ruleId: string;
+    readonly ruleName: string;
+    readonly eventId: string;
+    readonly timestamp: number;
+    readonly outputs: readonly string[];
     readonly success: boolean;
-    readonly version?: string;
-    readonly cameraCount?: number;
     readonly error?: string;
 }
-/**
- * Generic interface for testing provider connections.
- * Each provider addon can expose a connection tester.
- */
-interface IProviderConnectionTester {
-    testConnection(): Promise<TestConnectionResult>;
+interface IAdvancedNotifier {
+    getRules(): readonly NotificationRule[];
+    upsertRule(rule: NotificationRule): void;
+    deleteRule(ruleId: string): void;
+    testRule(ruleId: string, lookbackMinutes: number): Promise<NotificationTestResult[]>;
+    getHistory(filter?: NotificationHistoryFilter): Promise<NotificationHistoryEntry[]>;
 }
 
 /**
@@ -1691,6 +4682,8 @@ interface CapabilityProviderMap {
     'device-provider': unknown;
     'network-access': unknown;
     'streaming-engine': unknown;
+    'scene-intelligence': ISceneIntelligence;
+    'advanced-notifier': IAdvancedNotifier;
     [key: string]: unknown;
 }
 
@@ -1780,6 +4773,116 @@ interface ITaskHandler {
     cancel?(): Promise<void>;
 }
 
+/** Messages sent from main process to worker */
+type MainToWorkerMessage = {
+    type: 'INIT';
+    addonId: string;
+    addonDir: string;
+    config: Record<string, unknown>;
+    storagePaths: Record<string, string>;
+    /** Private data directory for this addon */
+    dataDir: string;
+    /** Legacy location paths (deprecated — use storageProvider proxy instead) */
+    locationPaths: Record<string, string>;
+} | {
+    type: 'CONFIG_CHANGE';
+    config: Record<string, unknown>;
+} | {
+    type: 'CAPABILITY_RESPONSE';
+    requestId: string;
+    result: unknown;
+    error?: string;
+} | {
+    type: 'SHUTDOWN';
+} | {
+    type: 'PING';
+};
+/** Messages sent from worker to main process */
+type WorkerToMainMessage = {
+    type: 'READY';
+    capabilities: ReadonlyArray<{
+        name: string;
+        mode: 'singleton' | 'collection';
+    }>;
+} | {
+    type: 'CAPABILITY_REGISTER';
+    name: string;
+    mode: 'singleton' | 'collection';
+} | {
+    type: 'CAPABILITY_CALL';
+    requestId: string;
+    capability: string;
+    method: string;
+    args: readonly unknown[];
+} | {
+    type: 'LOG';
+    level: string;
+    message: string;
+    context?: Record<string, unknown>;
+} | {
+    type: 'EVENT';
+    category: string;
+    data: Record<string, unknown>;
+} | {
+    type: 'STATS';
+    cpu: number;
+    memory: number;
+    uptime: number;
+} | {
+    type: 'PONG';
+} | {
+    type: 'ERROR';
+    message: string;
+    stack?: string;
+} | {
+    type: 'SUB_PROCESS_SPAWNED';
+    pid: number;
+    name: string;
+    command: string;
+} | {
+    type: 'SUB_PROCESS_EXITED';
+    pid: number;
+    code: number | null;
+} | {
+    type: 'TASK_HANDLER_REGISTER';
+    taskType: string;
+    description: string;
+    security?: 'safe' | 'dangerous';
+};
+/** Worker process state */
+type WorkerState = 'starting' | 'running' | 'stopping' | 'stopped' | 'crashed';
+/** Worker process info exposed to main process */
+interface WorkerInfo {
+    readonly addonId: string;
+    readonly pid: number;
+    readonly state: WorkerState;
+    readonly cpuPercent: number;
+    readonly memoryRss: number;
+    readonly uptimeSeconds: number;
+    readonly restartCount: number;
+    readonly subProcesses: readonly SubProcessInfo[];
+}
+/** Sub-process info */
+interface SubProcessInfo {
+    readonly pid: number;
+    readonly name: string;
+    readonly command: string;
+    readonly state: 'running' | 'stopped' | 'crashed';
+    readonly cpuPercent: number;
+    readonly memoryRss: number;
+    readonly uptimeSeconds: number;
+}
+/** Worker process stats (distinct from the existing ProcessStats in process.ts) */
+interface WorkerProcessStats {
+    readonly pid: number;
+    readonly cpuPercent: number;
+    readonly memoryRss: number;
+    readonly heapUsed?: number;
+    readonly uptimeSeconds: number;
+    readonly restartCount: number;
+    readonly state: WorkerState;
+}
+
 /** Storage interface for addon file operations */
 interface IAddonFileStorage {
     readFile(path: string): Promise<Buffer>;
@@ -1819,6 +4922,17 @@ interface AddonManifest {
     readonly name: string;
     readonly version: string;
     readonly description?: string;
+    /** Relative path to SVG icon asset within the addon package */
+    readonly icon?: string;
+    /** Brand hex color for UI display (e.g., "#3b82f6") */
+    readonly color?: string;
+    /**
+     * Whether multiple instances of this provider can be created.
+     * 'unique' — only one instance allowed (e.g., RTSP, ONVIF)
+     * 'multiple' — user can create N instances (e.g., Frigate, Scrypted)
+     * Default: 'multiple'
+     */
+    readonly instanceMode?: 'unique' | 'multiple';
     readonly packageName?: string;
     readonly capabilities?: readonly (AddonCapability | {
         name: string;
@@ -1832,7 +4946,18 @@ interface AddonManifest {
     readonly supportsCustomModels?: boolean;
     readonly mayRequirePython?: boolean;
     readonly defaultConfig?: Readonly<Record<string, unknown>>;
+    /** Whether this addon performs active inference with models.
+     *  Passive addons (e.g. motion-detection) set this to false
+     *  and are excluded from the inference pipeline schema. Default: true. */
+    readonly passive?: boolean;
+    /**
+     * Label output type — declares what kind of label this addon produces
+     * when used as a classifier/recognizer in the pipeline.
+     * Used to tag LabelData.origin so the UI can render labels appropriately.
+     */
+    readonly labelOutputType?: LabelOrigin;
 }
+/** @deprecated Use IStorageProvider.resolve() instead of raw paths */
 interface AddonLocationPaths {
     readonly data: string;
     readonly media: string;
@@ -1845,12 +4970,49 @@ interface AddonLocationPaths {
  * Minimal model-management API exposed to addons via AddonContext.
  */
 interface IAddonModelManager {
-    /** Download (if necessary) and return the local filesystem path for a model. */
-    downloadModel(id: string): Promise<string>;
+    /** Ensure a model is downloaded. Returns the local file path. */
+    ensure(modelId: string, format?: ModelFormat$1): Promise<string>;
+    /** Ensure extra files for a model are downloaded. Returns paths. */
+    ensureExtraFiles(modelId: string): Promise<readonly string[]>;
     /** Absolute path to the shared models directory. */
     getModelsDir(): string;
-    /** Whether a model file is already present on disk. */
-    isDownloaded(id: string): boolean;
+    /** Check if a model is already downloaded. */
+    isDownloaded(modelId: string, format?: ModelFormat$1): boolean;
+    /** @deprecated Use ensure() instead. Legacy API kept for backward compatibility. */
+    downloadModel(id: string): Promise<string>;
+}
+/** Process management for addon sub-processes (ffmpeg, python, etc.) */
+interface IAddonProcessManager {
+    /** Spawn a child process managed by this addon's worker */
+    spawn(config: SubProcessConfig): Promise<IManagedSubProcess>;
+    /** List all sub-processes spawned by this addon */
+    listProcesses(): readonly SubProcessInfo[];
+    /** Get worker stats (this addon's worker process) */
+    getWorkerStats(): WorkerProcessStats;
+}
+interface SubProcessConfig {
+    readonly name: string;
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly cwd?: string;
+    readonly env?: Readonly<Record<string, string>>;
+    readonly autoRestart?: boolean;
+    readonly maxRestarts?: number;
+}
+interface IManagedSubProcess {
+    readonly pid: number;
+    readonly name: string;
+    getStats(): WorkerProcessStats;
+    write(data: Buffer): void;
+    readonly stdout: AsyncIterable<Buffer>;
+    readonly stderr: AsyncIterable<Buffer>;
+    kill(signal?: NodeJS.Signals): void;
+    wait(): Promise<{
+        code: number | null;
+        signal: string | null;
+    }>;
+    onExit(handler: (code: number | null) => void): void;
+    onError(handler: (error: Error) => void): void;
 }
 /**
  * AddonContext -- injected into every addon at initialize().
@@ -1858,6 +5020,15 @@ interface IAddonModelManager {
  * The context includes both the CamstackContext fields (id, logger, eventBus, storage, config)
  * and addon-specific extras (addonConfig, models, locationPaths, router, network).
  */
+/**
+ * AddonContext -- injected into every addon at initialize().
+ *
+ * The `api` field is typed as `AddonApi` — a generated interface that
+ * mirrors the server's tRPC router namespaces. This gives addons type-safe
+ * access to server procedures without depending on the server package.
+ *
+ * To regenerate after changing routers: npx tsx scripts/generate-api-types.ts
+ */
 interface AddonContext {
     /** Immutable progressive ID */
     readonly id: string;
@@ -1865,27 +5036,45 @@ interface AddonContext {
     readonly logger: IScopedLogger;
     /** System event bus */
     readonly eventBus: IEventBus;
-    /** Scoped storage location */
+    /** Scoped storage location (legacy — use storageProvider instead) */
     readonly storage: IStorageLocation;
     /** Persisted config store */
     readonly config: IElementConfig;
-    /** Bootstrap configuration from server settings (read-only, from config.yaml) */
+    /** Bootstrap configuration from server settings (read-only) */
     readonly addonConfig: Readonly<Record<string, unknown>>;
     /** Model management -- download default models or retrieve cached paths. */
     models?: IAddonModelManager;
-    /** Resolved filesystem paths for all named storage locations. */
+    /** @deprecated Use storageProvider.resolve() instead */
     readonly locationPaths: AddonLocationPaths;
+    /** File storage provider — resolve paths, read/write files per location type */
+    readonly storageProvider?: IStorageProvider;
+    /** Settings backend — query/insert structured data (events, settings, metadata) */
+    readonly settingsBackend?: ISettingsBackend;
+    /** Embeddings backend — vector storage for similarity search */
+    readonly embeddingsBackend?: IEmbeddingsBackend;
+    /**
+     * Private data directory for this addon.
+     * Resolved via storageProvider.resolve('addons-data', '{addonId}/').
+     * The addon owns this directory exclusively.
+     */
+    readonly dataDir: string;
     /** HTTP router for registering addon routes */
     readonly router?: IAddonRouter;
     /** Network access provider */
     readonly network?: INetworkProvider;
-    /** Storage provider */
-    readonly storageProvider?: IStorageProvider;
     /**
      * Register a task handler that can be dispatched by the hub.
      * Only effective in agent mode — in hub mode, handlers are stored but not dispatched.
      */
     registerTaskHandler?(handler: ITaskHandler): void;
+    /** Process management — spawn and monitor sub-processes */
+    readonly process?: IAddonProcessManager;
+    /**
+     * Full tRPC client — same API as the frontend.
+     * Transport is transparent: direct caller (in-process), WSS (worker), or WSS (remote agent).
+     * Use this for all server interactions: storage, events, devices, streaming, etc.
+     */
+    readonly api?: AddonApi;
 }
 interface ICamstackAddon {
     readonly id?: string;
@@ -1910,10 +5099,10 @@ interface AddonPageDeclaration {
     readonly icon: string;
     /** Route path (e.g., '/benchmark') */
     readonly path: string;
-    /** Relative path to JS bundle within addon package */
+    /** Relative path to JS bundle within addon package (default export = React component) */
     readonly bundle: string;
-    /** Web component custom element tag name */
-    readonly element: string;
+    /** @deprecated Web component element name — addon pages now export React components */
+    readonly element?: string;
 }
 /** Provider interface for addons that expose UI pages */
 interface IAddonPageProvider {
@@ -1929,6 +5118,20 @@ interface AddonDeclaration {
     readonly id: string;
     readonly entry: string;
     readonly slot: PipelineSlot;
+    /** Relative path to SVG icon asset within the addon package */
+    readonly icon?: string;
+    /** Brand hex color for UI display */
+    readonly color?: string;
+    /** Instance mode: 'unique' or 'multiple'. Default: 'multiple' */
+    readonly instanceMode?: 'unique' | 'multiple';
+    /** @deprecated Use inProcess instead. Legacy opt-in flag for forking. */
+    readonly forkable?: boolean;
+    /**
+     * Force this addon to stay in-process (no forking).
+     * Default: false — all non-infra addons are forked by default.
+     * Use CAMSTACK_FORCE_INPROCESS=true env var for emergency global fallback.
+     */
+    readonly inProcess?: boolean;
     /** Capabilities this addon provides. Declared in package.json camstack.addons[].capabilities */
     readonly capabilities?: readonly CapabilityDeclaration[];
     /** UI pages provided by this addon */
@@ -1961,6 +5164,11 @@ interface IClassifierProvider extends IPipelineSlotProvider {
     classify(input: CropInput): Promise<ClassifierOutput>;
 }
 
+interface IRefinerProvider extends IPipelineSlotProvider {
+    readonly slot: 'refiner';
+    refine(input: CropInput): Promise<RefinerOutput>;
+}
+
 interface IDetectionAddon extends ICamstackAddon, IPipelineSlotProvider {
     getConfigSchema(): ConfigUISchema;
     getClassMap(): ClassMapDefinition;
@@ -1985,6 +5193,161 @@ interface ResolveEngineOptions {
     readonly modelsDir: string;
 }
 
+/** Hardware information detected at boot */
+interface HardwareInfo {
+    readonly platform: 'darwin' | 'linux' | 'win32';
+    readonly arch: 'arm64' | 'x64';
+    readonly cpuModel: string;
+    readonly cpuCores: number;
+    readonly totalRAM_MB: number;
+    readonly availableRAM_MB: number;
+    readonly gpu: GpuInfo | null;
+    readonly npu: NpuInfo | null;
+}
+interface GpuInfo {
+    readonly type: 'nvidia' | 'amd' | 'intel' | 'apple';
+    readonly name: string;
+    readonly memoryMB?: number;
+}
+interface NpuInfo {
+    readonly type: 'apple-ane' | 'intel-npu';
+}
+/** A probed backend with availability and score */
+interface PlatformScore {
+    readonly runtime: 'node' | 'python';
+    readonly backend: string;
+    readonly format: 'onnx' | 'coreml' | 'openvino';
+    readonly score: number;
+    readonly reason: string;
+    readonly available: boolean;
+}
+/** Full platform capabilities — cached once per boot */
+interface PlatformCapabilities {
+    readonly hardware: HardwareInfo;
+    readonly scores: readonly PlatformScore[];
+    readonly bestScore: PlatformScore;
+    readonly pythonPath: string | null;
+}
+/** Model requirement declared by an addon */
+interface ModelRequirement {
+    readonly modelId: string;
+    readonly name: string;
+    /** Minimum RAM needed for inference (model + runtime overhead, in MB) */
+    readonly minRAM_MB: number;
+    /** Relative accuracy score 0-100 */
+    readonly accuracyScore: number;
+    /** Available formats in the model catalog */
+    readonly formats: readonly string[];
+}
+/** Resolved config — the tripletta chosen by the scorer for an addon */
+interface ResolvedInferenceConfig {
+    readonly modelId: string;
+    readonly runtime: 'node' | 'python';
+    readonly backend: string;
+    readonly format: string;
+    readonly reason: string;
+}
+
+/** A hardware backend available for inference (e.g. CPU, CoreML, CUDA) */
+interface BackendInfo {
+    /** Backend identifier — matches engine-resolver backend param */
+    readonly id: string;
+    /** Human-readable label */
+    readonly label: string;
+    /** Whether this backend is available on the current agent/hub */
+    readonly available: boolean;
+    /** Device type for display */
+    readonly device: string;
+}
+/** A Python-specific backend with its associated model format */
+interface PythonBackendInfo extends BackendInfo {
+    /** The model format this backend needs (coreml → .mlpackage, openvino → .xml, etc.) */
+    readonly modelFormat: ModelFormat$1;
+    /** Python module required (e.g. 'coremltools', 'openvino', 'torch') */
+    readonly pythonModule: string;
+}
+/** Node.js runtime — uses onnxruntime-node, always loads .onnx files */
+interface NodeRuntimeInfo {
+    readonly available: true;
+    /** ONNX execution provider backends (cpu, coreml, cuda, tensorrt) */
+    readonly backends: readonly BackendInfo[];
+    /** Node.js always uses ONNX format */
+    readonly modelFormat: 'onnx';
+}
+/** Python runtime — uses subprocess with native model formats */
+interface PythonRuntimeInfo {
+    readonly available: boolean;
+    readonly pythonPath?: string;
+    /** Each Python backend uses a different model format */
+    readonly backends: readonly PythonBackendInfo[];
+}
+/** All runtimes available on an agent/hub */
+interface RuntimeCapabilities {
+    readonly node: NodeRuntimeInfo;
+    readonly python: PythonRuntimeInfo;
+}
+/** Download status of a specific model format */
+interface ModelFormatStatus {
+    readonly url: string;
+    readonly sizeMB: number;
+    readonly downloaded: boolean;
+    readonly filePath?: string;
+}
+/** A model from the catalog with download status per format */
+interface ModelAvailability {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    readonly inputSize: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly formats: Partial<Readonly<Record<ModelFormat$1, ModelFormatStatus>>>;
+}
+/** Detection addon with its available models */
+interface AddonCapabilityInfo {
+    readonly id: string;
+    readonly name: string;
+    readonly models: readonly ModelAvailability[];
+}
+/** Complete inference capabilities for an agent/hub */
+interface InferenceCapabilities {
+    readonly agentId: string;
+    readonly agentName: string;
+    readonly platform: string;
+    readonly arch: string;
+    readonly addons: readonly AddonCapabilityInfo[];
+    readonly runtimes: RuntimeCapabilities;
+    readonly modelsDir: string;
+    /** Platform scores from PlatformScorer — available after boot probe */
+    readonly platformScores?: readonly PlatformScore[];
+}
+/** Configuration to create/retrieve a managed inference engine */
+interface EngineConfig {
+    readonly addonId: string;
+    readonly modelId: string;
+    /** 'node' = onnxruntime-node, 'python' = Python subprocess */
+    readonly runtime: 'node' | 'python';
+    /** Backend within that runtime (e.g. 'cpu', 'coreml', 'cuda') */
+    readonly backend: string;
+}
+/** Progress event emitted during model download */
+interface ModelDownloadProgress {
+    readonly modelId: string;
+    readonly format: ModelFormat$1;
+    readonly downloadedBytes: number;
+    readonly totalBytes: number;
+    readonly percent: number;
+}
+/** Result of a benchmark model download */
+interface BenchmarkDownloadResult {
+    readonly modelId: string;
+    readonly format: ModelFormat$1;
+    readonly filePath: string;
+    readonly sizeMB: number;
+    readonly durationMs: number;
+}
+
 interface IZoneRepository {
     getByCamera(cameraId: string): Promise<ZoneDefinition[]>;
     save(zone: ZoneDefinition): Promise<void>;
@@ -2024,36 +5387,30 @@ interface IPythonEnvironment {
 }
 
 /**
- * Abstract storage backend -- resolves subpaths to absolute filesystem paths.
+ * @deprecated — This file contains legacy storage backend interfaces.
+ * Use the new interfaces from './storage.ts' instead:
+ *   - IStorageProvider (capability: 'storage')
+ *   - ISettingsBackend (capability: 'settings-store')
+ *   - IEmbeddingsBackend (capability: 'embeddings')
  */
+
+/** @deprecated Use IStorageProvider from storage.ts */
 interface IStorageBackend {
-    /** Backend type identifier */
     readonly type: string;
-    /** Base path of this backend */
     readonly basePath: string;
-    /** Resolve a subpath to an absolute path */
     resolve(subpath: string): string;
-    /** Also support location-based resolution */
-    resolve(location: StorageLocationName, ...segments: string[]): string;
-    /** Check if the backend path exists and is writable */
-    isAvailable(location?: StorageLocationName): boolean;
-    /** Ensure base directory exists (mkdir -p equivalent) */
+    resolve(location: StorageLocationType, ...segments: string[]): string;
+    isAvailable(location?: StorageLocationType): boolean;
     initialize(): Promise<void>;
-    /** Get the absolute path for a named storage location */
-    getLocationPath?(location: StorageLocationName): string;
-}
-/** @deprecated Use IStorageProvider from storage.ts instead */
-interface IStorageProviderLegacy {
-    getLocation(name: string): string;
-    setLocationPath?(name: StorageLocationName, absolutePath: string): void;
+    getLocationPath?(location: StorageLocationType): string;
 }
-/** Configuration for a storage location */
+/** @deprecated */
 interface StorageLocationConfig {
     readonly name: string;
     readonly basePath: string;
     readonly backendType?: string;
 }
-/** Default storage location paths, relative to dataPath */
+/** @deprecated Use DEFAULT_LOCATION_SUBDIRS from storage.ts */
 declare const DEFAULT_LOCATION_SUBPATHS: Record<string, string>;
 
 interface IPipelineRunner {
@@ -2076,7 +5433,48 @@ interface IPipelineValidator {
     validate(config: PipelineConfig): ValidationResult;
 }
 
-type DeviceType = 'camera' | 'doorbell' | 'sensor' | 'switch' | 'thermostat' | 'light' | 'generic';
+/**
+ * Addon i18n interface -- allows addons to provide translations
+ * for their UI labels, descriptions, and config schema fields.
+ *
+ * Addons implement IAddonTranslationProvider to supply translations
+ * either as a static map or via a dynamic lookup method.
+ */
+/** A flat key-value map of translation strings for a single locale */
+type TranslationMap = Readonly<Record<string, string>>;
+/** A complete translations bundle keyed by locale code (e.g. 'en', 'it', 'de') */
+type TranslationBundle = Readonly<Record<string, TranslationMap>>;
+/**
+ * Provider interface for addons that supply translations.
+ *
+ * Addons can provide translations in two ways:
+ * 1. A static bundle via `getTranslationBundle()` containing all locales
+ * 2. A per-locale lookup via `getTranslations(locale)` for lazy loading
+ *
+ * At least one method must be implemented. If both are present,
+ * `getTranslations()` takes precedence for the requested locale.
+ */
+interface IAddonTranslationProvider {
+    readonly id: string;
+    /**
+     * Return translations for a specific locale.
+     * Returns undefined if the locale is not supported.
+     */
+    getTranslations?(locale: string): TranslationMap | undefined;
+    /**
+     * Return the full translation bundle containing all supported locales.
+     * Useful when the addon ships all translations statically.
+     */
+    getTranslationBundle?(): TranslationBundle;
+}
+/**
+ * Resolve a translation key against a provider for the given locale.
+ * Falls back to 'en' if the requested locale is not available,
+ * then falls back to the key itself if no translation is found.
+ */
+declare function resolveTranslation(provider: IAddonTranslationProvider, locale: string, key: string): string;
+
+type DeviceType$1 = 'camera' | 'doorbell' | 'sensor' | 'switch' | 'thermostat' | 'light' | 'generic';
 interface DeviceState {
     online: boolean;
     lastSeen?: number;
@@ -2100,7 +5498,7 @@ interface IDevice {
     readonly id: string;
     readonly name: string;
     readonly providerId: string;
-    readonly type: DeviceType;
+    readonly type: DeviceType$1;
     readonly capabilities: DeviceCapabilityName[];
     /** The device's context -- logger, storage, eventBus scoped to this device */
     readonly ctx: CamstackContext;
@@ -2121,7 +5519,7 @@ interface ProviderStatus {
 interface DiscoveredDevice {
     externalId: string;
     name: string;
-    type: DeviceType;
+    type: DeviceType$1;
     capabilities: DeviceCapabilityName[];
     metadata: DeviceMetadata;
 }
@@ -2330,6 +5728,20 @@ interface ISwitch extends IDeviceCapability {
     toggle(): Promise<void>;
 }
 
+/** Native detection events from camera hardware (ONVIF, Frigate, etc.) */
+interface NativeDetectionEvent {
+    readonly cameraId: string;
+    readonly type: 'motion' | 'person' | 'vehicle' | 'animal' | string;
+    readonly confidence?: number;
+    readonly timestamp: number;
+    readonly source: 'onvif' | 'frigate' | 'rtsp-metadata' | string;
+}
+/** Interface for cameras that support native detection */
+interface ICameraNativeDetection {
+    readonly supportsNativeDetection: true;
+    onNativeDetection(handler: (event: NativeDetectionEvent) => void): () => void;
+}
+
 type StreamFormat = 'webrtc' | 'hls' | 'mjpeg' | 'rtsp';
 interface StreamingSource {
     readonly url: string;
@@ -2359,7 +5771,7 @@ interface IStreamingEngine {
     getStreamStatus(streamId: string): StreamStatus | null;
 }
 
-type UserRole = 'super_admin' | 'admin' | 'viewer';
+type UserRole = 'super_admin' | 'admin' | 'viewer' | 'agent';
 interface UserPermissions {
     role: UserRole;
     allowedProviders: string[] | '*';
@@ -2387,11 +5799,12 @@ interface ApiKeyRecord {
     lastUsedAt?: number;
 }
 interface TokenPayload {
-    type?: 'api_key';
+    type?: 'api_key' | 'service';
     keyId?: string;
     userId?: string;
     username?: string;
     role: UserRole;
+    agentId?: string;
     allowedProviders: string[] | '*';
     allowedDevices: Record<string, string[] | '*'>;
     iat?: number;
@@ -3038,6 +6451,198 @@ interface IReplEngine {
     getCompletions(partial: string, context: ReplContext): Promise<string[]>;
 }
 
+/**
+ * API-shared types — types that originated in @camstack/core, @camstack/kernel,
+ * or server internals and are now canonical here so the generated API type file
+ * has zero external dependencies beyond @camstack/types.
+ */
+
+interface BackupManifest {
+    readonly id: string;
+    readonly timestamp: number;
+    readonly label?: string;
+    readonly locations: readonly string[];
+    readonly sizeMB: number;
+    readonly path: string;
+}
+interface ProviderListItem {
+    id: string;
+    type: string;
+    name: string;
+    status: ProviderStatus;
+    started: boolean;
+    lifecycle: ElementStatus;
+}
+interface InstalledPackage {
+    readonly name: string;
+    readonly version: string;
+    readonly dir: string;
+}
+/** A page declaration enriched with its source addon ID */
+interface AddonPageInfo {
+    readonly addonId: string;
+    readonly page: AddonPageDeclaration;
+    readonly bundleUrl: string;
+}
+type BenchmarkPhase = 'init' | 'warmup' | 'running' | 'done';
+interface BenchmarkProgress {
+    readonly addonId: string;
+    readonly phase: BenchmarkPhase;
+    readonly elapsedSec: number;
+    readonly totalSec: number;
+    readonly warmupFrame: number;
+    readonly warmupTotal: number;
+    readonly framesProcessed: number;
+    readonly totalDetections: number;
+    readonly objectsFound: number;
+    readonly errorCount: number;
+    readonly simulatedCameras: number;
+    readonly batchSize: number;
+    readonly currentDps: number;
+    readonly currentFps: number;
+    readonly recentAvgMs: number;
+    readonly inferenceMs: number;
+}
+interface BenchmarkResult {
+    readonly addonId: string;
+    readonly addonName: string;
+    readonly referenceImage: string;
+    readonly runtime: string;
+    readonly iterations: number;
+    readonly durationSec: number;
+    readonly warmup: number;
+    readonly inputResolution: string;
+    readonly dps: number;
+    readonly totalDetections: number;
+    readonly objectsFound: number;
+    readonly avgDetectionsPerFrame: number;
+    readonly inferenceAvgMs: number;
+    readonly inferenceP50Ms: number;
+    readonly inferenceP95Ms: number;
+    readonly inferenceP99Ms: number;
+    readonly fps: number;
+    readonly avgMs: number;
+    readonly p50Ms: number;
+    readonly p95Ms: number;
+    readonly p99Ms: number;
+    readonly minMs: number;
+    readonly maxMs: number;
+    readonly peakMemoryMB: number;
+    readonly errorCount: number;
+    readonly successCount: number;
+    readonly modelId: string;
+    readonly simulatedCameras: number;
+    readonly batchSize: number;
+}
+interface HistoryEntry {
+    readonly id: string;
+    readonly date: string;
+    readonly agentName: string;
+    readonly addonId: string;
+    readonly modelName: string;
+    readonly runtime: string;
+    readonly dps: number;
+    readonly inferenceAvgMs: number;
+    readonly totalDetections: number;
+    readonly fps: number;
+    readonly avgMs: number;
+    readonly p50Ms: number;
+    readonly p95Ms: number;
+    readonly p99Ms: number;
+    readonly minMs: number;
+    readonly maxMs: number;
+    readonly peakMemoryMB: number;
+    readonly iterations: number;
+    readonly warmup: number;
+    readonly inputResolution: string;
+    readonly simulatedCameras?: number;
+    readonly batchSize?: number;
+    readonly errorCount?: number;
+}
+interface PipelineProgressEvent {
+    readonly step: 'loading-engine' | 'inferring' | 'complete';
+    readonly addonId: string;
+    readonly modelId: string;
+    readonly ms?: number;
+    readonly message?: string;
+}
+interface OrchestratorMetrics {
+    readonly activeCameras: number;
+    readonly throttledCameras: number;
+    readonly avgInferenceTimeMs: number;
+    readonly queueDepth: number;
+}
+interface CameraMetrics {
+    readonly priority: CameraPriority;
+    readonly configuredFps: number;
+    readonly actualFps: number;
+    readonly queueDepth: number;
+    readonly avgInferenceTimeMs: number;
+    readonly droppedFrames: number;
+    readonly phase: CameraPhase;
+}
+interface PackageUpdate {
+    readonly name: string;
+    readonly currentVersion: string;
+    readonly latestVersion: string;
+    readonly category: 'addon' | 'core';
+    readonly requiresRestart: boolean;
+}
+interface UpdateResult {
+    readonly success: boolean;
+    readonly version: string;
+    readonly requiresRestart: boolean;
+    readonly error?: string;
+}
+interface DetectorDetails {
+    id: string;
+    name: string;
+    models: Array<{
+        id: string;
+        name: string;
+        inputSize?: {
+            width: number;
+            height: number;
+        };
+    }>;
+    runtimes: Array<{
+        value: string;
+        label: string;
+    }>;
+    backends: Array<{
+        value: string;
+        label: string;
+    }>;
+    defaultConfig: Record<string, unknown> | null;
+}
+
+/**
+ * System settings UI schemas — the single source of truth for all settings sections.
+ *
+ * These are defined in @camstack/types so that:
+ *   - The backend can serve them via API
+ *   - Addons can reference/extend them
+ *   - The frontend fetches them at runtime (no hardcoded duplication)
+ *
+ * Values are stored in the SQL system_settings table, not config.yaml.
+ * Only `server` is read-only (loaded from config.yaml at bootstrap).
+ */
+
+type SystemSettingsSection = 'server' | 'auth' | 'features' | 'storage' | 'logging' | 'addons' | 'recording' | 'streaming' | 'ffmpeg' | 'detection' | 'backup' | 'retention';
+/** Sections where fields are read-only (bootstrap from config.yaml). */
+declare const READ_ONLY_SECTIONS: ReadonlySet<SystemSettingsSection>;
+interface SettingsTabDef {
+    readonly id: SystemSettingsSection;
+    readonly label: string;
+}
+declare const SETTINGS_TABS: readonly SettingsTabDef[];
+declare const SYSTEM_SETTINGS_SCHEMAS: Readonly<Record<SystemSettingsSection, ConfigUISchema>>;
+/**
+ * Get the UI schema for a settings section.
+ * Returns undefined for unknown sections.
+ */
+declare function getSystemSettingsSchema(section: string): ConfigUISchema | undefined;
+
 declare const HF_REPO = "camstack/camstack-models";
 declare const HF_BASE_URL = "https://huggingface.co/camstack/camstack-models/resolve/main";
 
@@ -3050,4 +6655,48 @@ declare const COCO_80_LABELS: readonly LabelDefinition[];
 declare const MACRO_LABELS: readonly LabelDefinition[];
 declare const COCO_TO_MACRO: ClassMapDefinition;
 
-export { type AccessoryInfo, type AccuracyStats, type ActiveDetection, type AddonCapability, type AddonContext, type AddonDeclaration, type AddonFileLocationName, type AddonHttpReply, type AddonHttpRequest, type AddonLocationPaths, type AddonManifest, type AddonPackageManifest, type AddonPageDeclaration, type AddonStorageLocationName, type AddonStorageLocations, type AddonStructuredLocationName, type AgentBenchmarkStatus, type AgentCapability, type AgentEntry, type AgentInfo, type AgentRegistrationInfo, type AgentResources, type AgentRuntimeStatus, type AgentStatus, type AgentTask, type AgentTaskResult, type AgentToHubMessage, type AnalysisContext, type AnalysisEvent, type AnnotatedSnapshotResult, type ApiKeyRecord, type AudioChunk, type AudioChunkCallback, type AudioChunkInput, type AudioClassification, type AudioEvent, type AuthResult, type AuthenticatedUser, BINARY_FRAME_HEADER_SIZE, BINARY_FRAME_TYPE, type BenchmarkConfig, type BenchmarkExecution, type BenchmarkMode, type BenchmarkReport, type BenchmarkSource, type BenchmarkStreamEvent, type BenchmarkTarget, type BenchmarkTargetResult, type BoundingBox, type BrokerStats, type BrokerStatus, COCO_80_LABELS, COCO_TO_MACRO, type CameraAnalysisConfig, type CameraDetectionConfig, type CameraLiveState, type CameraPhase, type CameraPriority, type CameraRoleAssignment, type CamstackContext, type CapabilityBinding, type CapabilityConsumerRegistration, type CapabilityDeclaration, type CapabilityInfo, type CapabilityMode, type CapabilityProviderMap, type ClassMapDefinition, type Classification, type ClassifierOutput, type ClientNetworkStats, type ClipRecognizer, type ConfigBooleanField, type ConfigColorField, type ConfigCondition, type ConfigField, type ConfigFieldBase, type ConfigGroupField, type ConfigInfoField, type ConfigModelSelectorField, type ConfigMultiSelectField, type ConfigNumberField, type ConfigOption, type ConfigPasswordField, type ConfigSection, type ConfigSelectField, type ConfigSeparatorField, type ConfigSliderField, type ConfigTagsField, type ConfigTextAreaField, type ConfigTextField, type ConfigUISchema, type ConnectionMode, type CropInput, type CropperOutput, type CustomModelMetadata, DEFAULT_FEATURES, DEFAULT_LOCATION_SUBPATHS, DEFAULT_RETENTION, DETECTION_TYPES, type DecodeOptions, type DecodedAudioChunk, type DecodedFrame, type DecoderSessionConfig, type DecoderStats, type Detection, type DetectionDevice, type DetectionEvent, type DetectionEventType, type DetectionFrame, type DetectionLine, type DetectionModel, type DetectionResult, type DetectionRuntime, type DetectionType, type DetectionZone, type DetectorOutput, type DeviceCapabilityBinding, type DeviceCapabilityName, type DeviceEvent, type DeviceMetadata, type DeviceNetworkStats, type DeviceState, type DeviceStoredEvent, type DeviceType, type DiscoveredDevice, type DoorbellEvent, type ElementState, type ElementStatus, type EncodedPacket, type EndpointCapabilities, type EventBufferStatus, type EventCluster, type EventFilter, type EventQuery, type EventQueryResult, type EventSnapshot, type EventSource, type ExposedResourceRequest, type ExposedResourceResponse, type ExposedResourceType, type FeatureFlag, type FeatureManifest, type FfmpegConfig, type FrameInput, type FrameSubscriptionOptions, type GlobalIdentity, type GroundTruth, type GroundTruthAnnotation, HF_BASE_URL, HF_REPO, type HeatmapData, type HeatmapOptions, type HttpMethod, type HubToAgentMessage, type IAccessory, type IAddonFileStorage, type IAddonHttpRoute, type IAddonModelManager, type IAddonPageProvider, type IAddonRouteProvider, type IAddonRouter, type IAddonStructuredStorage, type IAdminUI, type IAnalysisAddon, type IAnalysisDataPersistence, type IAnalysisPipeline, type IAnalysisStage, type IAudioClassifier, type IAudioDetector, type IAuthProvider, type ICamera, type ICameraAnalyticsProvider, type ICameraPipeline, type ICamstackAddon, type IClassFilterStage, type IClassifierProvider, type IConfigurable, type ICropperProvider, type IDecoderProvider, type IDecoderSession, type IDetectionAddon, type IDetectorProvider, type IDevice, type IDeviceCapability, type IDeviceProvider, type IDoorbell, type IElementConfig, type IEventBus, type IEventGenerationStage, type IEventPersistence, type IEvents, type IExposedResource, type IFaceDetector, type IFaceRecognizer, type IFileStorage, type IInferenceEngine, type IKnownFaceRepository, type IKnownFaces, type IKnownPlateRepository, type ILifecycleManaged, type ILogDestination, type IModelCatalogProvider, type IMotionSensor, type INetworkAccessProvider, type INetworkEndpoint, type INetworkProvider, type INetworkQualityTracker, type INotificationOutput, type IObjectDetector, type IObjectSnapshotStage, type IPanTiltZoom, type IPipelineConsumer, type IPipelineManager, type IPipelineRunner, type IPipelineSlotProvider, type IPipelineValidator, type IPlateDetector, type IPlateRecognizer, type IProcessManager, type IProviderConnectionTester, type IPythonEnvironment, type IRecognitionStage, type IRecognizer, type IRecording, type IRecordingAddon, type IRecordingCoordinator, type IRecordingDb, type IRemoteAccessProvider, type IReplEngine, type IResourceExposer, type IRestreamer, type IRetention, type IScopedLogger, type ISessionTracker, type ISiren, type IStatusLight, type IStorageBackend, type IStorageLocation, type IStorageProvider, type IStorageProviderLegacy, type IStreamBroker, type IStreamBrokerManager, type IStreamSourceAdapter, type IStreamingEngine, type IStructuredStorage, type ISubDetectionStage, type ISubDetector, type ISwitch, type ITaskHandler, type IToastService, type ITrackTrail, type ITrackerStage, type ITurnProvider, type ITwoWayAudio, type IWebRtcProvider, type IZoneAnalysisStage, type IZoneRepository, type KnownAudioEvent, type KnownFace, type KnownFaceEntry, type KnownPlate, type LabelDefinition, type Landmark, type LatencyStats, type LiveEvent, type LogEntry, type LogFilter, type LogLevel, type LoggerFactory, MACRO_LABELS, type ManagedProcessStatus, type ModelCatalogEntry, type ModelDownloadOptions, type ModelDownloadResult, type ModelFormat$1 as ModelFormat, type ModelFormatEntry, type ModelOutputFormat, type MultiBenchmarkReport, type NetworkAccessStatus, type NetworkAddress, type NormalizedSource, type Notification, type ObjectSnapshotResult, type ObjectState, type PersistableEvent, type PipelineConfig, type PipelineNode, type PipelineOutputFormat, type PipelineOutputStream, type PipelineResult, type PipelineSlot, type PipelineStatus, type PipelineStatusInfo, type ProbeCapability, type ProbeResult, type ProcessConfig, type ProcessStats, type ProviderStatus, type PtzPreset, type PublicAddress, type PythonEnvReady, type PythonProbeResult, type QueryFilter, RECOGNITION_TYPES, type RecognitionResult, type RecognitionType, type RecordingSegment, type RecordingSegmentInfo, type RegisteredStream, type RemoteAccessStatus, type RemoteBenchmarkConfig, type ReplContext, type ReplResult, type ReplScope, type RequiredStep, type ResolveEngineOptions, type ResourceAuthMode, type ResourceStats, type RestreamerExposedResource, type RetentionConfig, type RetentionReport, type RolePriority, type RouteAccess, type RouteHandler, type RouteRequest, type RouteResponse, SUB_DETECTION_TYPES, type ScopedToken, type ServerModelCatalogEntry, type ModelType as ServerModelType, type ServerTrackedDetection, type SessionTrack, type SourceAdapterStatus, type SourceCapabilities, type SpatialDetection, type StepError, type StepResult, type StorageConfig, type StorageLocationConfig, type StorageLocationName, type StorageRecord, type StreamFormat, type StreamInfo, type StreamNetworkStats, type StreamOption, type StreamSource, type StreamSourceOption, type StreamStatus, type StreamingSource, type SubDetection, type SubDetectionType, type SystemEvent, type SystemInfo, type TaskContext, type TaskDispatchOptions, type TaskHandlerSecurity, type TaskProgress, type TestConnectionResult, type TimeRange, type TimeRangeOptions, type Toast, type TokenPayload, type TokenScope, type TrackCaptureConfig, type TrackDetail, type TrackFilter, type TrackMediaFile, type TrackMediaType, type TrackPosition, type TrackSnapshot, type TrackTrail, type TrackedDetection, type TrackedObjectState, type TrackedObjectSummary, type TrackingInfo, type TurnCredentials, type TurnServer, type Unsubscribe, type UserPermissions, type UserRecord, type UserRole, type ValidationIssue, type ValidationResult, type VideoFrame, type VideoFrameCallback, type ZoneDefinition, type ZoneEvent, type ZoneHistoryPoint, type ZoneLiveState, cosineSimilarity, createAnalysisContext, enrichContext, hfModelUrl };
+/**
+ * Motion detection configuration per camera.
+ * Motion is a pipeline TRIGGER, not a pipeline step.
+ */
+interface CameraMotionConfig {
+    /** 'stream' = frame-diff analysis on decoded frames (default)
+     *  'onboarded' = use camera's native motion signal via IMotionSensor capability
+     *  'smart' = AI-based motion detection */
+    readonly source: 'stream' | 'onboarded' | 'smart';
+    /** Frame-diff settings (only used when source='stream') */
+    readonly threshold?: number;
+    readonly minArea?: number;
+}
+/**
+ * Camera native AI detection configuration.
+ * These events are emitted for recording/notifications, NOT for inference pipeline.
+ * Uses the IObjectDetector device capability to receive detection events.
+ */
+interface CameraNativeDetectionConfig {
+    /** Whether to listen for the camera's native AI events */
+    readonly enabled: boolean;
+    /** Source identifier for attribution */
+    readonly source: string;
+    /** Classes the camera reports natively */
+    readonly classes: readonly string[];
+}
+/**
+ * Combined camera detection capabilities config.
+ */
+interface CameraDetectionCapabilities {
+    readonly motion: CameraMotionConfig;
+    readonly nativeDetection?: CameraNativeDetectionConfig;
+}
+
+declare enum DeviceType {
+    Camera = "camera"
+}
+interface DeviceTypeInfo {
+    readonly type: DeviceType;
+    readonly label: string;
+    readonly icon: string;
+}
+declare const DEVICE_TYPE_INFO: Record<DeviceType, DeviceTypeInfo>;
+
+export { type AccessoryInfo, type AccuracyStats, type ActiveDetection, type AddonCapability, type AddonCapabilityInfo, type AddonContext, type AddonDeclaration, type AddonFileLocationName, type AddonHttpReply, type AddonHttpRequest, type AddonLocationPaths, type AddonManifest, type AddonPackageManifest, type AddonPageDeclaration, type AddonPageInfo, type AddonStorageLocationName, type AddonStorageLocations, type AddonStructuredLocationName, type AgentBenchmarkStatus, type AgentCapability, type AgentEntry, type AgentInfo, type AgentRegistrationInfo, type AgentResources, type AgentRuntimeStatus, type AgentStatus, type AgentTask, type AgentTaskResult, type AgentToHubMessage, type AnalysisContext, type AnalysisEvent, type AnalysisEventType, type AnnotatedSnapshotResult, type ApiKeyRecord, type AppRouter, type AudioChunk, type AudioChunkCallback, type AudioChunkInput, type AudioClassification, type AudioEvent, type AuthResult, type AuthenticatedUser, BINARY_FRAME_HEADER_SIZE, BINARY_FRAME_TYPE, type BackendInfo, type BackupManifest, type BenchmarkConfig, type BenchmarkDownloadResult, type BenchmarkExecution, type BenchmarkMode, type BenchmarkPhase, type BenchmarkProgress, type BenchmarkReport, type BenchmarkResult, type BenchmarkSource, type BenchmarkStreamEvent, type BenchmarkTarget, type BenchmarkTargetResult, type BoundingBox, type BrokerStats, type BrokerStatus, COCO_80_LABELS, COCO_TO_MACRO, type CameraAnalysisConfig, type CameraDetectionCapabilities, type CameraDetectionConfig, type CameraLiveState, type CameraMetrics, type CameraMotionConfig, type CameraNativeDetectionConfig, type CameraPhase, type CameraPriority, type CameraRoleAssignment, type CameraZone, type CameraZoneConfig, type CamstackContext, type CapabilityBinding, type CapabilityConsumerRegistration, type CapabilityDeclaration, type CapabilityInfo, type CapabilityMode, type CapabilityProviderMap, type ClassMapDefinition, type Classification, type ClassifierOutput, type ClientNetworkStats, type ClipRecognizer, type ConfigBooleanField, type ConfigColorField, type ConfigCondition, type ConfigField, type ConfigFieldBase, type ConfigGroupField, type ConfigInfoField, type ConfigModelSelectorField, type ConfigMultiSelectField, type ConfigNumberField, type ConfigOption, type ConfigPasswordField, type ConfigSection, type ConfigSelectField, type ConfigSeparatorField, type ConfigSliderField, type ConfigStorageLocationField, type ConfigTagsField, type ConfigTextAreaField, type ConfigTextField, type ConfigUISchema, type ConnectionMode, type CropInput, type CropperOutput, type CustomModelMetadata, DEFAULT_FEATURES, DEFAULT_LOCATION_SUBDIRS, DEFAULT_LOCATION_SUBPATHS, DEFAULT_RETENTION, DETECTION_TYPES, DEVICE_TYPE_INFO, type DecodeOptions, type DecodedAudioChunk, type DecodedFrame, type DecoderSessionConfig, type DecoderStats, type Detection, type DetectionDevice, type DetectionEvent, type DetectionEventType, type DetectionFrame, type DetectionLine, type DetectionModel, type DetectionResult, type DetectionRuntime, type DetectionType, type DetectionZone, type DetectionZoneMembership, type DetectorDetails, type DetectorOutput, type DeviceCapabilityBinding, type DeviceCapabilityName, type DeviceEvent, type DeviceMetadata, type DeviceNetworkStats, type DeviceState, type DeviceStoredEvent, DeviceType, type DeviceTypeInfo, type DiscoveredDevice, type DoorbellEvent, type ElementState, type ElementStatus, type EmbeddingFilter, type EmbeddingMetadata, type EncodedPacket, type EndpointCapabilities, type EngineConfig, type EventBufferStatus, type EventCluster, type EventFilter, type EventQuery, type EventQueryResult, type EventSnapshot, type EventSource, type ExposedResourceRequest, type ExposedResourceResponse, type ExposedResourceType, type FeatureFlag, type FeatureManifest, type FfmpegConfig, type FrameInput, type FrameSubscriptionOptions, type GlobalIdentity, type GpuInfo, type GroundTruth, type GroundTruthAnnotation, HF_BASE_URL, HF_REPO, type HardwareInfo, type HeatmapData, type HeatmapOptions, type HistoryEntry, type HttpMethod, type HubToAgentMessage, type IAccessory, type IAddonFileStorage, type IAddonHttpRoute, type IAddonModelManager, type IAddonPageProvider, type IAddonProcessManager, type IAddonRouteProvider, type IAddonRouter, type IAddonStructuredStorage, type IAddonTranslationProvider, type IAdminUI, type IAdvancedNotifier, type IAnalysisAddon, type IAnalysisDataPersistence, type IAnalysisPipeline, type IAnalysisStage, type IAudioClassifier, type IAudioDetector, type IAuthProvider, type ICamera, type ICameraAnalyticsProvider, type ICameraNativeDetection, type ICameraPipeline, type ICamstackAddon, type IClassFilterStage, type IClassifierProvider, type IConfigurable, type ICropperProvider, type IDecoderProvider, type IDecoderSession, type IDetectionAddon, type IDetectorProvider, type IDevice, type IDeviceCapability, type IDeviceProvider, type IDoorbell, type IElementConfig, type IEmbeddingsBackend, type IEventBus, type IEventGenerationStage, type IEventPersistence, type IEvents, type IExposedResource, type IFaceDetector, type IFaceRecognizer, type IFileStorage, type IInferenceEngine, type IKnownFaceRepository, type IKnownFaces, type IKnownPlateRepository, type ILifecycleManaged, type ILogDestination, type IManagedSubProcess, type IModelCatalogProvider, type IMotionSensor, type INetworkAccessProvider, type INetworkEndpoint, type INetworkProvider, type INetworkQualityTracker, type INotificationOutput, type IObjectDetector, type IObjectSnapshotStage, type IPanTiltZoom, type IPipelineConsumer, type IPipelineManager, type IPipelineRunner, type IPipelineSlotProvider, type IPipelineValidator, type IPlateDetector, type IPlateRecognizer, type IProcessManager, type IProviderConnectionTester, type IPythonEnvironment, type IRecognitionStage, type IRecognizer, type IRecording, type IRecordingAddon, type IRecordingCoordinator, type IRecordingDb, type IRefinerProvider, type IRemoteAccessProvider, type IReplEngine, type IResourceExposer, type IRestreamer, type IRetention, type ISceneIntelligence, type IScopedLogger, type ISessionTracker, type ISettingsBackend, type ISiren, type IStatusLight, type IStorageBackend, type IStorageLocation, type IStorageProvider, type IStreamBroker, type IStreamBrokerManager, type IStreamSourceAdapter, type IStreamingEngine, type IStructuredStorage, type ISubDetectionStage, type ISubDetector, type ISwitch, type ITaskHandler, type IToastService, type ITrackTrail, type ITrackerStage, type ITurnProvider, type ITwoWayAudio, type IVectorIndex, type IWebRtcProvider, type IZoneAnalysisStage, type IZoneRepository, type InferenceCapabilities, type InstalledPackage, type KnownAudioEvent, type KnownFace, type KnownFaceEntry, type KnownPlate, type LabelData, type LabelDefinition, type LabelOrigin, type Landmark, type LatencyStats, type LiveEvent, type LogEntry, type LogFilter, type LogLevel, type LoggerFactory, MACRO_LABELS, type MainToWorkerMessage, type ManagedProcessStatus, type ModelAvailability, type ModelCatalogEntry, type ModelDownloadOptions, type ModelDownloadProgress, type ModelDownloadResult, type ModelExtraFile, type ModelFormat$1 as ModelFormat, type ModelFormatEntry, type ModelFormatStatus, type ModelOutputFormat, type ModelRequirement, type MotionSource, type MultiBenchmarkReport, type NativeDetectionEvent, type NetworkAccessStatus, type NetworkAddress, type NodeRuntimeInfo, type NormalizedSource, type Notification, type NotificationHistoryEntry, type NotificationHistoryFilter, type NotificationRule, type NotificationTestResult, type NpuInfo, type ObjectSnapshotResult, type ObjectState, type OrchestratorMetrics, type PackageUpdate, type PersistableEvent, type PipelineAddonSchema, type PipelineConfig, type PipelineDefaultStep, type PipelineDetection, type PipelineModelOption, type PipelineNode, type PipelineOutputFormat, type PipelineOutputStream, type PipelineProgressEvent, type PipelineResult, type PipelineRunResult, type PipelineSchema, type PipelineSlot, type PipelineSlotSchema, type PipelineStatus, type PipelineStatusInfo, type PipelineStepTiming, type PipelineTemplate, type PipelineTemplateStep, type PlatformCapabilities, type PlatformScore, type ProbeCapability, type ProbeResult, type ProcessConfig, type ProcessStats, type ProviderListItem, type ProviderStatus, type PtzPreset, type PublicAddress, type PythonBackendInfo, type PythonEnvReady, type PythonProbeResult, type PythonRuntimeInfo, type QueryFilter, READ_ONLY_SECTIONS, RECOGNITION_TYPES, type RecognitionResult, type RecognitionType, type RecordingSegment, type RecordingSegmentInfo, type RefinerOutput, type RegisteredStream, type RemoteAccessStatus, type RemoteBenchmarkConfig, type ReplContext, type ReplResult, type ReplScope, type RequiredStep, type ResolveEngineOptions, type ResolvedInferenceConfig, type ResourceAuthMode, type ResourceStats, type RestreamerExposedResource, type RetentionConfig, type RetentionReport, type RolePriority, type RouteAccess, type RouteHandler, type RouteRequest, type RouteResponse, type RuntimeCapabilities, SETTINGS_TABS, STORAGE_LOCATION_TYPES, SUB_DETECTION_TYPES, SYSTEM_SETTINGS_SCHEMAS, type SceneStateResult, type ScopedToken, type ServerModelCatalogEntry, type ModelType as ServerModelType, type ServerTrackedDetection, type SessionTrack, type SettingsCollection, type SettingsRecord, type SettingsTabDef, type SourceAdapterStatus, type SourceCapabilities, type SpatialDetection, type StepError, type StepResult, type StorageConfig, type StorageLocationConfig, type StorageLocationName, type StorageLocationType, type StorageRecord, type StreamFormat, type StreamInfo, type StreamNetworkStats, type StreamOption, type StreamSource, type StreamSourceOption, type StreamStatus, type StreamingSource, type SubDetection, type SubDetectionType, type SubProcessConfig, type SubProcessInfo, type SystemEvent, type SystemInfo, type SystemSettingsSection, type TaskContext, type TaskDispatchOptions, type TaskHandlerSecurity, type TaskProgress, type TemplateValidationResult, type TestConnectionResult, type TimeRange, type TimeRangeOptions, type Toast, type TokenPayload, type TokenScope, type TrackCaptureConfig, type TrackDetail, type TrackEventType, type TrackFilter, type TrackMediaFile, type TrackMediaType, type TrackPosition, type TrackSnapshot, type TrackTrail, type TrackedDetection, type TrackedObjectState, type TrackedObjectSummary, type TrackingInfo, type TranslationBundle, type TranslationMap, type TurnCredentials, type TurnServer, type Unsubscribe, type UpdateResult, type UserPermissions, type UserRecord, type UserRole, type ValidationIssue, type ValidationResult, type VectorEntry, type VectorSearchResult, type VideoFrame, type VideoFrameCallback, type WorkerInfo, type WorkerProcessStats, type WorkerState, type WorkerToMainMessage, type ZoneDefinition, type ZoneEvent, type ZoneHistoryPoint, type ZoneLiveState, type ZoneMode, cosineSimilarity, createAnalysisContext, enrichContext, getSystemSettingsSchema, hfModelUrl, resolveTranslation };