@camstack/types 0.1.0 → 0.1.1

package/dist/index.d.mts

@@ -1,5 +1,3 @@
-import { M as ModelCatalogEntry, a as ModelFormat, C as CustomModelMetadata, b as ModelOutputFormat, c as ClassMapDefinition, D as DetectionModel, L as LabelDefinition } from './index-B9wf2RhV.mjs';
-export { A as ANIMAL_TYPE_MODELS, d as AUDIO_CLASSIFICATION_MODELS, B as BIRD_NABIRDS_MODELS, e as BIRD_SPECIES_MODELS, f as COCO_80_LABELS, g as COCO_TO_MACRO, F as FACE_DETECTION_MODELS, h as FACE_RECOGNITION_MODELS, i as MACRO_LABELS, j as ModelDownloadOptions, k as ModelDownloadResult, l as ModelFormatEntry, O as OBJECT_DETECTION_MODELS, P as PLATE_DETECTION_MODELS, m as PLATE_RECOGNITION_MODELS, S as SEGMENTATION_MODELS } from './index-B9wf2RhV.mjs';
 import { ChildProcess } from 'node:child_process';
 
 interface BoundingBox {
@@ -27,6 +25,18 @@ interface AudioChunkInput {
     readonly timestamp: number;
 }
 
+interface LabelDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly category?: string;
+    readonly description?: string;
+    readonly icon?: string;
+}
+interface ClassMapDefinition {
+    readonly mapping: Readonly<Record<string, string>>;
+    readonly preserveOriginal: boolean;
+}
+
 interface SpatialDetection {
     readonly class: string;
     readonly originalClass: string;
@@ -185,6 +195,60 @@ interface KnownAudioEvent {
     readonly notifyAlways: boolean;
 }
 
+type ModelFormat$1 = 'onnx' | 'coreml' | 'openvino' | 'tflite' | 'pt';
+type ModelOutputFormat = 'yolo' | 'ssd' | 'embedding' | 'classification' | 'ocr';
+interface ModelFormatEntry {
+    readonly url: string;
+    readonly sizeMB: number;
+}
+interface ModelCatalogEntry {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    readonly formats: Partial<Readonly<Record<ModelFormat$1, ModelFormatEntry>>>;
+    readonly inputSize: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly labels: readonly LabelDefinition[];
+    readonly inputLayout?: 'nchw' | 'nhwc';
+    readonly inputNormalization?: 'zero-one' | 'imagenet' | 'none';
+}
+interface DetectionModel {
+    readonly id: string;
+    readonly name: string;
+    readonly labels: readonly string[];
+    readonly inputSize: {
+        readonly width: number;
+        readonly height: number;
+    };
+}
+interface ModelDownloadOptions {
+    readonly url: string;
+    readonly fallbackUrls?: readonly string[];
+    readonly destDir: string;
+    readonly filename?: string;
+    readonly expectedSha256?: string;
+    readonly onProgress?: (downloaded: number, total: number) => void;
+}
+interface ModelDownloadResult {
+    readonly filePath: string;
+    readonly downloadedBytes: number;
+    readonly fromCache: boolean;
+}
+interface CustomModelMetadata {
+    readonly name: string;
+    readonly inputSize: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly labels: readonly LabelDefinition[];
+    readonly classMap?: ClassMapDefinition;
+    readonly inputLayout?: 'nchw' | 'nhwc';
+    readonly inputNormalization?: 'zero-one' | 'imagenet' | 'none';
+    readonly outputFormat: ModelOutputFormat;
+}
+
 type PipelineSlot = 'detector' | 'cropper' | 'classifier';
 interface PipelineNode {
     readonly step: string;
@@ -452,60 +516,147 @@ interface GroundTruth {
     readonly annotations: readonly GroundTruthAnnotation[];
 }
 
+/**
+ * Configuration UI Schema -- declarative form definition for any element.
+ *
+ * Used by addons, providers, and devices to declare their settings UI.
+ * The admin UI renders these schemas as responsive forms.
+ */
+interface ConfigUISchema {
+    sections: ConfigSection[];
+}
+interface ConfigSection {
+    id: string;
+    title: string;
+    description?: string;
+    style?: 'card' | 'accordion';
+    defaultCollapsed?: boolean;
+    columns?: 1 | 2 | 3 | 4;
+    fields: ConfigField[];
+}
+type ConfigField = ConfigTextField | ConfigNumberField | ConfigBooleanField | ConfigSelectField | ConfigMultiSelectField | ConfigColorField | ConfigPasswordField | ConfigTextAreaField | ConfigSliderField | ConfigTagsField | ConfigGroupField | ConfigSeparatorField | ConfigInfoField | ConfigModelSelectorField;
 interface ConfigFieldBase {
-    readonly key: string;
-    readonly label: string;
-    readonly description?: string;
-    readonly required?: boolean;
-    readonly dependsOn?: Readonly<Record<string, unknown>>;
+    key: string;
+    label: string;
+    description?: string;
+    required?: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    span?: 1 | 2 | 3 | 4;
+    showWhen?: ConfigCondition;
+}
+interface ConfigCondition {
+    field: string;
+    equals?: unknown;
+    notEquals?: unknown;
+    in?: unknown[];
+    notIn?: unknown[];
 }
 interface ConfigTextField extends ConfigFieldBase {
-    readonly type: 'text';
-    readonly placeholder?: string;
+    type: 'text';
+    maxLength?: number;
+    pattern?: string;
+    inputType?: 'text' | 'url' | 'email';
 }
 interface ConfigNumberField extends ConfigFieldBase {
-    readonly type: 'number';
-    readonly min?: number;
-    readonly max?: number;
-    readonly step?: number;
+    type: 'number';
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
 }
 interface ConfigBooleanField extends ConfigFieldBase {
-    readonly type: 'boolean';
+    type: 'boolean';
+    style?: 'switch' | 'checkbox';
 }
 interface ConfigSelectField extends ConfigFieldBase {
-    readonly type: 'select';
-    readonly options: ReadonlyArray<{
-        readonly value: string;
-        readonly label: string;
-    }>;
+    type: 'select';
+    options: ConfigOption[];
+    dependsOn?: Record<string, unknown>;
+}
+interface ConfigMultiSelectField extends ConfigFieldBase {
+    type: 'multiselect';
+    options: ConfigOption[];
+    maxItems?: number;
+}
+interface ConfigColorField extends ConfigFieldBase {
+    type: 'color';
+    presets?: string[];
+}
+interface ConfigPasswordField extends ConfigFieldBase {
+    type: 'password';
+    showToggle?: boolean;
+}
+interface ConfigTextAreaField extends ConfigFieldBase {
+    type: 'textarea';
+    rows?: number;
+    maxLength?: number;
 }
 interface ConfigSliderField extends ConfigFieldBase {
-    readonly type: 'slider';
-    readonly min: number;
-    readonly max: number;
-    readonly step: number;
-    readonly default: number;
+    type: 'slider';
+    min: number;
+    max: number;
+    step?: number;
+    showValue?: boolean;
+    unit?: string;
+    default?: number;
+}
+interface ConfigTagsField extends ConfigFieldBase {
+    type: 'tags';
+    suggestions?: string[];
+    maxTags?: number;
+}
+interface ConfigGroupField extends ConfigFieldBase {
+    type: 'group';
+    fields: ConfigField[];
+    style?: 'card' | 'inline' | 'accordion';
+    defaultCollapsed?: boolean;
+}
+/** Visual separator between fields */
+interface ConfigSeparatorField {
+    type: 'separator';
+    key: string;
+}
+/** Read-only informational text */
+interface ConfigInfoField {
+    type: 'info';
+    key: string;
+    label: string;
+    content: string;
+    variant?: 'info' | 'warning' | 'success' | 'danger';
+}
+interface ConfigOption {
+    value: string;
+    label: string;
+    description?: string;
+    icon?: string;
 }
 interface ConfigModelSelectorField extends ConfigFieldBase {
-    readonly type: 'model-selector';
-    readonly catalog: readonly ModelCatalogEntry[];
-    readonly allowCustom: boolean;
-    readonly acceptFormats?: readonly ModelFormat[];
-    readonly allowConversion?: boolean;
-    readonly requiredMetadata: readonly (keyof CustomModelMetadata)[];
-    readonly outputFormatHint?: ModelOutputFormat;
-}
-type ConfigField = ConfigTextField | ConfigNumberField | ConfigBooleanField | ConfigSelectField | ConfigSliderField | ConfigModelSelectorField;
-interface ConfigSection {
-    readonly id: string;
-    readonly title: string;
-    readonly description?: string;
-    readonly style?: 'card' | 'accordion';
-    readonly columns?: 1 | 2 | 3 | 4;
-    readonly fields: readonly ConfigField[];
-}
-interface ConfigUISchema {
-    readonly sections: readonly ConfigSection[];
+    type: 'model-selector';
+    /** Filter models by type */
+    modelType?: string;
+    /** Allow user to enter a custom local path or URL (default: true) */
+    allowCustomPath?: boolean;
+    /** Allow file upload via UI (default: true) */
+    allowUpload?: boolean;
+    /** Accepted file extensions for upload (default: ['.onnx']) */
+    acceptExtensions?: string[];
+    /** URL to model conversion documentation/guide */
+    conversionGuideUrl?: string;
+    /** Brief text explaining what models are compatible */
+    compatibilityNote?: string;
+    /** Legacy: inline catalog entries */
+    catalog?: readonly ModelCatalogEntry[];
+    allowCustom?: boolean;
+    acceptFormats?: readonly ModelFormat$1[];
+    allowConversion?: boolean;
+    requiredMetadata?: readonly (keyof CustomModelMetadata)[];
+    outputFormatHint?: ModelOutputFormat;
+}
+interface IConfigurable {
+    getConfigSchema(): ConfigUISchema;
+    getConfig(): Record<string, unknown>;
+    onConfigChange(config: Record<string, unknown>): Promise<void>;
 }
 
 interface RouteRequest {
@@ -581,41 +732,1083 @@ interface TurnServer {
     readonly credential?: string;
 }
 
-type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'verbose';
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LogEntry {
+    timestamp: Date;
+    level: LogLevel;
+    scope: string[];
+    message: string;
+    meta?: Record<string, unknown>;
+}
+interface LogFilter {
+    scope?: string[];
+    level?: LogLevel;
+    since?: Date;
+    until?: Date;
+    limit?: number;
+}
+interface ILogDestination {
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    write(entry: LogEntry): void;
+    query?(filter: LogFilter): Promise<readonly LogEntry[]>;
+}
 interface IScopedLogger {
-    error(message: string, ...meta: unknown[]): void;
-    warn(message: string, ...meta: unknown[]): void;
-    info(message: string, ...meta: unknown[]): void;
-    debug(message: string, ...meta: unknown[]): void;
-    verbose(message: string, ...meta: unknown[]): void;
+    debug(message: string, meta?: Record<string, unknown>): void;
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
     child(scope: string): IScopedLogger;
 }
-interface ILogDestination {
+/** Factory that creates scoped loggers */
+type LoggerFactory = {
+    createLogger(scope: string): IScopedLogger;
+};
+
+interface EventSource {
+    type: string;
+    id: string;
+}
+interface SystemEvent {
+    id: string;
+    timestamp: Date;
+    source: EventSource;
+    category: string;
+    data: Record<string, unknown>;
+}
+interface EventFilter {
+    source?: EventSource;
+    category?: string;
+    since?: Date;
+}
+interface IEventBus {
+    emit(event: SystemEvent): void;
+    subscribe(filter: EventFilter, handler: (event: SystemEvent) => void): () => void;
+    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[];
+    getZoneState(deviceId: string, zoneId: string): ZoneLiveState | null;
+    getZoneHistory(deviceId: string, zoneId: string, options: TimeRangeOptions): Promise<ZoneHistoryPoint[]>;
+    getHeatmap(deviceId: string, options: HeatmapOptions): Promise<HeatmapData>;
+    getTrackDetail(deviceId: string, trackId: string): TrackDetail | null;
+    getCameraStatus(deviceId: string): PipelineStatus[];
+}
+interface IAnalysisAddon extends ICamstackAddon, ICameraAnalyticsProvider {
+    processFrame(deviceId: string, frame: FrameInput): Promise<DetectionEvent[]>;
+    setCameraPipeline(deviceId: string, config: PipelineConfig): void;
+    setCameraZones(deviceId: string, zones: ZoneDefinition[]): void;
+    setKnownFaces(faces: KnownFace[]): void;
+    setKnownPlates(plates: KnownPlate[]): void;
+    onLiveStateChange(deviceId: string, callback: (state: CameraLiveState) => void): () => void;
+}
+
+/**
+ * Result returned by an auth provider after successful authentication.
+ */
+interface AuthResult {
+    readonly externalId: string;
+    readonly username: string;
+    readonly email?: string;
+    readonly displayName?: string;
+    readonly avatarUrl?: string;
+    readonly groups?: string[];
+    readonly rawProfile?: unknown;
+}
+/**
+ * Pluggable authentication provider.
+ * Each addon can register one or more auth providers (collection capability).
+ */
+interface IAuthProvider {
     readonly id: string;
     readonly name: string;
-    write(level: LogLevel, scope: string, message: string, meta?: unknown): void;
+    readonly icon: string;
+    /** Type of auth flow */
+    readonly flowType: 'credentials' | 'redirect' | 'token';
+    /**
+     * For 'credentials' flow: validate username/password, return user info.
+     */
+    validateCredentials?(username: string, password: string): Promise<AuthResult | null>;
+    /**
+     * For 'redirect' flow (OIDC, OAuth2):
+     * getLoginUrl() returns the URL to redirect the user to.
+     * handleCallback() processes the callback and returns user info.
+     */
+    getLoginUrl?(state: string): string;
+    handleCallback?(params: Record<string, string>): Promise<AuthResult>;
+    /**
+     * For 'token' flow: validate an external token (e.g., from mobile app).
+     */
+    validateToken?(token: string): Promise<AuthResult | null>;
 }
 
-type EventCallback<T = unknown> = (data: T) => void;
-interface IEventBus {
-    on<T = unknown>(event: string, callback: EventCallback<T>): () => void;
-    once<T = unknown>(event: string, callback: EventCallback<T>): () => void;
-    emit<T = unknown>(event: string, data: T): void;
-    removeAllListeners(event?: string): void;
+/**
+ * A notification to be sent through configured output channels.
+ */
+interface Notification {
+    readonly title: string;
+    readonly message: string;
+    readonly severity: 'info' | 'warning' | 'critical';
+    readonly category: string;
+    readonly data?: Record<string, unknown>;
+    readonly imageUrl?: string;
+    readonly deviceId?: string;
+    readonly timestamp: number;
+}
+/**
+ * A toast notification for the admin UI.
+ */
+interface Toast {
+    readonly title: string;
+    readonly message: string;
+    readonly severity: 'info' | 'warning' | 'critical';
+    readonly duration?: number;
+    readonly action?: {
+        readonly label: string;
+        readonly url: string;
+    };
+}
+/**
+ * Service interface for broadcasting toast notifications to connected clients.
+ */
+interface IToastService {
+    broadcast(toast: Toast): void;
+    sendToUser(userId: string, toast: Toast): void;
+}
+/**
+ * Pluggable notification output channel.
+ * Each addon implements a notification channel (Telegram, webhook, email, etc.).
+ */
+interface INotificationOutput {
+    readonly id: string;
+    readonly name: string;
+    readonly icon: string;
+    /** Send a notification */
+    send(notification: Notification): Promise<void>;
+    /** Test the notification channel */
+    sendTest?(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Config schema for the admin UI */
+    getConfigSchema?(): ConfigUISchema;
 }
 
-type StorageLocationName = 'data' | 'media' | 'recordings' | 'models' | 'cache' | 'logs';
-interface IStorageBackend {
-    resolve(location: StorageLocationName, ...segments: string[]): string;
-    isAvailable(location: StorageLocationName): boolean;
+/**
+ * Scope restriction for a scoped token.
+ */
+interface TokenScope {
+    readonly type: 'addon' | 'route-prefix' | 'capability';
+    readonly target: string;
+}
+/**
+ * A per-user API token with restricted scopes.
+ */
+interface ScopedToken {
+    readonly id: string;
+    readonly userId: string;
+    readonly name: string;
+    readonly tokenHash: string;
+    readonly tokenPrefix: string;
+    readonly scopes: TokenScope[];
+    readonly expiresAt?: number;
+    readonly lastUsedAt?: number;
+    readonly createdAt: number;
+}
+
+type RouteAccess = 'public' | 'authenticated' | 'admin';
+/**
+ * Request object passed to addon route handlers.
+ */
+interface AddonHttpRequest {
+    readonly params: Record<string, string>;
+    readonly query: Record<string, string>;
+    readonly body: unknown;
+    readonly headers: Record<string, string>;
+    /** Populated for 'authenticated' and 'admin' routes */
+    readonly user?: {
+        readonly id: string;
+        readonly username: string;
+        readonly role: string;
+    };
+    /** Populated when request uses a scoped token */
+    readonly scopedToken?: {
+        readonly id: string;
+        readonly userId: string;
+        readonly scopes: TokenScope[];
+    };
+}
+/**
+ * Reply object for addon route handlers.
+ */
+interface AddonHttpReply {
+    status(code: number): AddonHttpReply;
+    send(data: unknown): void;
+    redirect(url: string): void;
+    header(name: string, value: string): AddonHttpReply;
+}
+/**
+ * A single HTTP route registered by an addon.
+ */
+interface IAddonHttpRoute {
+    readonly method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    readonly path: string;
+    readonly access: RouteAccess;
+    readonly description?: string;
+    readonly handler: (request: AddonHttpRequest, reply: AddonHttpReply) => Promise<void>;
+}
+/**
+ * Provider interface for addons that expose HTTP endpoints.
+ */
+interface IAddonRouteProvider {
+    readonly id: string;
+    getRoutes(): IAddonHttpRoute[];
+}
+
+/**
+ * Camera Analysis Pipeline -- unified stream processing.
+ */
+interface IStreamSourceAdapter {
+    protocol: string;
+    connect(config: Record<string, unknown>): Promise<NormalizedSource>;
+    disconnect(): Promise<void>;
+    getStatus(): SourceAdapterStatus;
+}
+interface NormalizedSource {
+    type: 'url' | 'pipe';
+    url?: string;
+    pipe?: NodeJS.ReadableStream;
+    capabilities: SourceCapabilities;
+}
+interface SourceCapabilities {
+    hasVideo: boolean;
+    hasAudio: boolean;
+    videoCodec?: 'h264' | 'h265' | 'mjpeg' | 'vp8' | 'vp9' | 'av1';
+    audioCodec?: 'aac' | 'opus' | 'pcm' | 'g711';
+    width?: number;
+    height?: number;
+    fps?: number;
+    sampleRate?: number;
+    audioChannels?: number;
+}
+interface SourceAdapterStatus {
+    connected: boolean;
+    protocol: string;
+    error?: string;
+    bytesReceived?: number;
+    connectedSince?: number;
+}
+interface VideoFrame {
+    data: Buffer;
+    format: 'jpeg' | 'raw-yuv420' | 'raw-rgb' | 'h264-nal';
+    width: number;
+    height: number;
+    pts: number;
+    timestamp: number;
+    keyframe?: boolean;
+}
+interface AudioChunk {
+    data: Buffer;
+    format: 'pcm-s16le' | 'pcm-f32le' | 'aac' | 'opus';
+    sampleRate: number;
+    channels: number;
+    pts: number;
+    timestamp: number;
+    dBFS?: number;
+}
+interface ICameraPipeline {
+    readonly deviceId: string;
+    readonly active: boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    onVideoFrame(callback: VideoFrameCallback, options?: FrameSubscriptionOptions): () => void;
+    getLatestFrame(): VideoFrame | null;
+    onAudioChunk(callback: AudioChunkCallback): () => void;
+    getAudioLevel(): number;
+    getOutputStream(format: PipelineOutputFormat): PipelineOutputStream | null;
+    getAvailableOutputs(): PipelineOutputFormat[];
+    getStatus(): PipelineStatusInfo;
+}
+type VideoFrameCallback = (frame: VideoFrame) => void;
+type AudioChunkCallback = (chunk: AudioChunk) => void;
+interface FrameSubscriptionOptions {
+    maxFps?: number;
+    format?: 'jpeg' | 'raw-yuv420' | 'raw-rgb';
+    maxWidth?: number;
+    maxHeight?: number;
+    keyframeOnly?: boolean;
+}
+type PipelineOutputFormat = 'webrtc' | 'hls' | 'mjpeg' | 'rtsp' | 'raw-h264';
+interface PipelineOutputStream {
+    format: PipelineOutputFormat;
+    url?: string;
+    createOffer?(): Promise<string>;
+    handleAnswer?(sdp: string): Promise<void>;
+    pipe?: NodeJS.ReadableStream;
+    consumerCount: number;
+}
+interface PipelineStatusInfo {
+    active: boolean;
+    source: {
+        protocol: string;
+        connected: boolean;
+        capabilities: SourceCapabilities;
+    } | null;
+    decode: {
+        fps: number;
+        droppedFrames: number;
+        totalFrames: number;
+    };
+    videoConsumers: number;
+    audioConsumers: number;
+    outputs: Array<{
+        format: PipelineOutputFormat;
+        consumers: number;
+        active: boolean;
+    }>;
+    uptime: number;
+}
+interface IPipelineManager {
+    getPipeline(deviceId: string): ICameraPipeline | null;
+    createPipeline(deviceId: string, source: NormalizedSource): ICameraPipeline;
+    destroyPipeline(deviceId: string): Promise<void>;
+    listPipelines(): Array<{
+        deviceId: string;
+        status: PipelineStatusInfo;
+    }>;
+}
+interface IPipelineConsumer {
+    id: string;
+    name: string;
+    videoRequirements?: FrameSubscriptionOptions;
+    needsAudio: boolean;
+    attachToPipeline(pipeline: ICameraPipeline, deviceId: string): void;
+    detachFromPipeline(deviceId: string): void;
+}
+
+interface IDeviceCapability {
+    kind: DeviceCapabilityName;
+}
+type DeviceCapabilityName = 'camera' | 'panTiltZoom' | 'motionSensor' | 'objectDetector' | 'audioDetector' | 'twoWayAudio' | 'doorbell' | 'events' | 'recording' | 'accessory' | 'statusLight' | 'siren' | 'switch';
+interface CapabilityBinding {
+    source: 'native' | 'addon' | 'disabled';
+    addonId?: string;
+    config?: Record<string, unknown>;
+}
+interface DeviceCapabilityBinding {
+    deviceId: string;
+    bindings: Partial<Record<DeviceCapabilityName, CapabilityBinding>>;
+}
+
+/** A single detection result from a frame */
+interface Detection {
+    className: string;
+    score: number;
+    boundingBox?: [number, number, number, number];
+    id?: string;
+    label?: string;
+    labelScore?: number;
+    zones?: string[];
+    previousZones?: string[];
+}
+/** Payload emitted by onDetections -- a full frame of detections */
+interface DetectionFrame {
+    detections: Detection[];
+    frameWidth: number;
+    frameHeight: number;
+    timestamp: number;
+}
+/** An actively tracked object in the scene */
+interface ActiveDetection extends Detection {
+    state: 'moving' | 'stationary';
+    durationMs: number;
+    velocity?: {
+        dx: number;
+        dy: number;
+    };
+}
+/** A closed polygon zone on the camera scene */
+interface DetectionZone {
+    id: string;
+    name: string;
+    polygon: Array<[number, number]>;
+    mode: 'observe' | 'restrict';
+}
+/** A line on the scene for crossing rules */
+interface DetectionLine {
+    id: string;
+    name: string;
+    points: [[number, number], [number, number]];
+    direction: 'left-to-right' | 'right-to-left' | 'both';
+}
+interface IObjectDetector extends IDeviceCapability {
+    kind: 'objectDetector';
+    getLabels(): string[];
+    onDetections(callback: (frame: DetectionFrame) => void): () => void;
+    getZones(): Promise<DetectionZone[]>;
+    addZone(zone: DetectionZone): Promise<void>;
+    removeZone(zoneId: string): Promise<void>;
+    updateZone(zoneId: string, zone: Partial<Omit<DetectionZone, 'id'>>): Promise<void>;
+    getLines(): Promise<DetectionLine[]>;
+    addLine(line: DetectionLine): Promise<void>;
+    removeLine(lineId: string): Promise<void>;
+    getActiveDetections(): ActiveDetection[];
+    getZoneDetections(zoneId: string): ActiveDetection[];
+    getStationaryDetections(): ActiveDetection[];
+    getMovingDetections(): ActiveDetection[];
+}
+
+/**
+ * Detection Analysis Pipeline -- processes raw detections through
+ * configurable stages to produce tracked, enriched, actionable events.
+ */
+
+declare const DETECTION_TYPES: readonly ["person", "vehicle", "animal", "package"];
+type DetectionType = typeof DETECTION_TYPES[number];
+declare const SUB_DETECTION_TYPES: readonly ["face", "plate"];
+type SubDetectionType = typeof SUB_DETECTION_TYPES[number];
+declare const RECOGNITION_TYPES: readonly ["face", "plate", "clip", "custom"];
+type RecognitionType = typeof RECOGNITION_TYPES[number];
+interface AnalysisContext {
+    readonly deviceId: string;
+    readonly frame: VideoFrame;
+    readonly timestamp: number;
+    readonly rawDetections: readonly Detection[];
+    readonly trackedDetections: readonly ServerTrackedDetection[];
+    readonly events: readonly AnalysisEvent[];
+    readonly metadata: Readonly<Record<string, unknown>>;
+}
+interface ServerTrackedDetection {
+    readonly trackId: string;
+    readonly detection: Detection;
+    readonly crop?: Buffer;
+    readonly tracking: TrackingInfo;
+    readonly subDetections: readonly SubDetection[];
+    readonly recognitions: readonly RecognitionResult[];
+    readonly zones: readonly string[];
+    readonly previousZones: readonly string[];
+}
+interface TrackingInfo {
+    readonly age: number;
+    readonly state: 'moving' | 'stationary' | 'new' | 'lost';
+    readonly stationaryDuration: number;
+    readonly velocity: {
+        readonly dx: number;
+        readonly dy: number;
+    };
+    readonly positionHistory: ReadonlyArray<{
+        readonly x: number;
+        readonly y: number;
+        readonly t: number;
+    }>;
+}
+interface SubDetection {
+    readonly detectionType: SubDetectionType;
+    readonly boundingBox: readonly [number, number, number, number];
+    readonly score: number;
+    readonly crop?: Buffer;
+}
+interface RecognitionResult {
+    readonly recognitionType: RecognitionType;
+    readonly label: string;
+    readonly score: number;
+    readonly embedding?: readonly number[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface AnalysisEvent {
+    readonly category: string;
+    readonly severity: 'info' | 'warning' | 'alert';
+    readonly detection: ServerTrackedDetection;
+    readonly description: string;
+    readonly data: Readonly<Record<string, unknown>>;
+}
+interface IAnalysisStage {
+    readonly id: string;
+    readonly name: string;
+    readonly priority: number;
+    enabled: boolean;
+    process(ctx: AnalysisContext): Promise<AnalysisContext>;
+}
+interface ISubDetector {
+    readonly detectionType: SubDetectionType;
+    readonly targetClasses: readonly string[];
+    detect(crop: Buffer, cropWidth: number, cropHeight: number): Promise<SubDetection[]>;
+}
+interface IFaceDetector extends ISubDetector {
+    readonly detectionType: 'face';
+}
+interface IPlateDetector extends ISubDetector {
+    readonly detectionType: 'plate';
+}
+interface IRecognizer {
+    readonly recognitionType: RecognitionType;
+    recognize(crop: Buffer, width: number, height: number): Promise<RecognitionResult | null>;
+}
+interface IFaceRecognizer extends IRecognizer {
+    getEmbedding(crop: Buffer): Promise<Float32Array>;
+    registerKnown(label: string, embedding: Float32Array): void;
+}
+interface IPlateRecognizer extends IRecognizer {
+    readonly recognitionType: 'plate';
+}
+interface IAudioClassifier {
+    readonly ready: boolean;
     initialize(): Promise<void>;
-    getLocationPath(location: StorageLocationName): string;
+    classify(audioSamples: Float32Array, sampleRate: number, topN?: number): Promise<readonly AudioClassification[]>;
+    release(): Promise<void>;
 }
-interface IStorageProvider {
-    getLocation(name: string): string;
-    setLocationPath(name: StorageLocationName, absolutePath: string): void;
+interface AudioClassification {
+    readonly classIndex: number;
+    readonly className: string;
+    readonly score: number;
+    readonly isSurveillanceRelevant: boolean;
+}
+interface IClassFilterStage extends IAnalysisStage {
+    readonly id: 'class-filter';
+    setConfig(deviceId: string, config: Record<string, unknown>): void;
+    getConfig(deviceId: string): Record<string, unknown>;
+}
+interface ITrackerStage extends IAnalysisStage {
+    readonly id: 'tracker';
+    setConfig(deviceId: string, config: Record<string, unknown>): void;
+    getConfig(deviceId: string): Record<string, unknown>;
+    resetDevice(deviceId: string): void;
+}
+interface ISubDetectionStage extends IAnalysisStage {
+    readonly id: 'sub-detection';
+    registerDetector(detector: ISubDetector): void;
+}
+interface IRecognitionStage extends IAnalysisStage {
+    readonly id: 'recognition';
+    registerRecognizer(recognizer: IRecognizer): void;
+}
+interface IZoneAnalysisStage extends IAnalysisStage {
+    readonly id: 'zone-analysis';
+    setConfig(deviceId: string, config: Record<string, unknown>): void;
+}
+interface IEventGenerationStage extends IAnalysisStage {
+    readonly id: 'event-generation';
+    setConfig(deviceId: string, config: Record<string, unknown>): void;
+}
+interface IObjectSnapshotStage extends IAnalysisStage {
+    readonly id: 'object-snapshot';
+    setConfig(deviceId: string, config: Record<string, unknown>): void;
+}
+interface IAnalysisPipeline {
+    addStage(stage: IAnalysisStage): void;
+    removeStage(stageId: string): void;
+    getStages(): readonly IAnalysisStage[];
+    analyze(deviceId: string, frame: VideoFrame, rawDetections: Detection[]): Promise<AnalysisContext>;
+}
+declare function createAnalysisContext(deviceId: string, frame: VideoFrame, rawDetections: Detection[]): AnalysisContext;
+declare function enrichContext(ctx: AnalysisContext, updates: Partial<Pick<AnalysisContext, 'trackedDetections' | 'events' | 'metadata'>>): AnalysisContext;
+
+interface ObjectSnapshotResult {
+    readonly trackId: string;
+    readonly thumbnail?: Buffer;
+    readonly fullCrop?: Buffer;
+}
+interface AnnotatedSnapshotResult {
+    readonly thumbnail: Buffer;
+    readonly full: Buffer;
+}
+interface PersistableEvent {
+    readonly id: string;
+    readonly timestamp: number;
+    readonly deviceId: string;
+    readonly category: string;
+    readonly className: string;
+    readonly score: number;
+    readonly trackId: string;
+    readonly severity: string;
+    readonly description: string;
+    readonly data: Record<string, unknown>;
+    readonly mediaFiles: readonly string[];
+}
+interface EventBufferStatus {
+    readonly eventCount: number;
+    readonly mediaCount: number;
+    readonly mediaSizeMB: number;
+}
+type TrackMediaType = 'crop-thumb' | 'crop-full' | 'debug-annotated-thumb' | 'debug-annotated-full' | 'original' | 'original-thumb' | 'inline-crop' | 'unknown';
+interface TrackMediaFile {
+    readonly path: string;
+    readonly type: TrackMediaType;
+    readonly data: Buffer;
+    readonly source: 'buffer' | 'storage';
+}
+interface TrackCaptureConfig {
+    readonly enabled: boolean;
+    readonly snapshotIntervalMs: number;
+    readonly maxTrailLength: number;
+    readonly saveThumbnails: boolean;
+    readonly thumbnailSize: {
+        readonly width: number;
+        readonly height: number;
+    };
+}
+interface TrackPosition {
+    readonly x: number;
+    readonly y: number;
+    readonly timestamp: number;
+    readonly bbox: readonly [number, number, number, number];
+}
+interface TrackSnapshot {
+    readonly timestamp: number;
+    readonly position: TrackPosition;
+    readonly thumbnailPath: string;
+}
+interface TrackTrail {
+    readonly trackId: string;
+    readonly deviceId: string;
+    readonly className: string;
+    readonly label?: string;
+    readonly firstSeen: number;
+    readonly lastSeen: number;
+    readonly positions: readonly TrackPosition[];
+    readonly snapshots: readonly TrackSnapshot[];
+    readonly totalDistance: number;
+    readonly zonesVisited: readonly string[];
+    readonly active: boolean;
+}
+interface RetentionConfig {
+    readonly cleanupIntervalMs: number;
+    readonly detectionEventsDays: number;
+    readonly audioLevelsDays: number;
+    /** @deprecated — snapshots are tied to events, use detectionEventsDays */
+    readonly snapshotsDays: number;
+    readonly deviceOverrides?: Readonly<Record<string, Partial<Pick<RetentionConfig, 'detectionEventsDays' | 'audioLevelsDays' | 'snapshotsDays'>>>>;
+}
+declare const DEFAULT_RETENTION: RetentionConfig;
+interface RetentionReport {
+    readonly deletedEvents: number;
+    readonly deletedAudioRecords: number;
+    readonly deletedSnapshots: number;
+}
+interface SessionTrack {
+    readonly trackId: string;
+    readonly deviceId: string;
+    readonly className: string;
+    readonly label?: string;
+    readonly firstSeen: number;
+    readonly lastSeen: number;
+    readonly totalFrames: number;
+    readonly lastDetection: ServerTrackedDetection;
+    readonly state: string;
+    readonly positions: ReadonlyArray<{
+        readonly x: number;
+        readonly y: number;
+        readonly t: number;
+    }>;
+    readonly embedding?: Float32Array;
+    readonly globalId?: string;
+    readonly bestCrop?: Buffer;
+}
+interface GlobalIdentity {
+    readonly globalId: string;
+    readonly embedding: Float32Array;
+    readonly label?: string;
+    readonly firstSeen: number;
+    readonly lastSeen: number;
+    readonly deviceIds: ReadonlyArray<string>;
+}
+interface ClipRecognizer {
+    getEmbedding(imageBuffer: Buffer): Promise<Float32Array>;
+}
+interface KnownFaceEntry {
+    readonly id: string;
+    readonly label: string;
+    readonly group?: string;
+    readonly embedding: readonly number[];
+    readonly cropBase64: string;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly source?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Interface for the recording addon — the server uses this instead of
+ * importing PipelineAddon directly from addon-pipeline.
+ */
+interface IRecordingAddon {
+    getCoordinator(): IRecordingCoordinator;
+    getRecordingDb(): IRecordingDb;
+}
+/**
+ * Minimal coordinator interface for the server's recording router.
+ */
+interface IRecordingCoordinator {
+    enableRecording(deviceId: string, options: {
+        policy: unknown;
+        ffmpegOverrides?: unknown;
+    }): Promise<void>;
+    disableRecording(deviceId: string): Promise<void>;
+    isRecording(deviceId: string): boolean;
+    readonly playlistGenerator: {
+        generate(deviceId: string, streamId: string, startTime: number, endTime: number, options?: {
+            live?: boolean;
+        }): unknown;
+    };
+    readonly storageEstimator: {
+        estimateForDevice(deviceId: string, motionInput?: {
+            avgEventsPerDay: number;
+            avgDurationSec: number;
+        }): {
+            totalEstimatedGb: number;
+            [key: string]: unknown;
+        };
+    };
+}
+/**
+ * Minimal recording database interface for the server's recording router.
+ */
+interface IRecordingDb {
+    upsertStorageConfig(config: {
+        deviceId: string;
+        dataCategory: string;
+        storageName: string;
+        subDirectory: string;
+        retentionDays: number | null;
+        retentionGb: number | null;
+    }): void;
+    getPolicy(deviceId: string): unknown;
+    getEnabledPolicies(): Array<{
+        deviceId: string;
+        [key: string]: unknown;
+    }>;
+    querySegments(deviceId: string, streamId: string, startTime: number, endTime: number): unknown;
+    getAvailability(deviceId: string, startTime: number, endTime: number): unknown;
+    getStorageUsage(deviceId: string, streamId: string): unknown;
+    upsertPolicy(policy: unknown): void;
+    findNearestThumbnail(deviceId: string, timestamp: number, category: string): unknown;
+    getMotionStats(deviceId: string, startTime: number, endTime: number): {
+        avgEventsPerDay: number;
+        avgDurationSec: number;
+        dutyCyclePercent: number;
+        totalEvents: number;
+    };
+    resolveStorageConfig(deviceId: string, dataCategory: string): unknown;
+}
+interface IEventPersistence {
+    start(): void;
+    stop(): void;
+    saveDetectionCrops(eventId: string, crops: readonly ObjectSnapshotResult[]): void;
+    saveAnnotatedFrame(eventId: string, result: AnnotatedSnapshotResult): void;
+    saveOriginalFrame(eventId: string, frame: VideoFrame): Promise<void>;
+    getEventMedia(eventId: string): Promise<unknown>;
+    getTrackMedia(trackId: string): Promise<unknown>;
+    getDeviceMedia(deviceId: string, since?: number, until?: number): Promise<unknown>;
+    getBufferStatus(): unknown;
+    flush(): Promise<void>;
+}
+interface ITrackTrail {
+    setConfig(deviceId: string, config: Partial<TrackCaptureConfig>): void;
+    getConfig(deviceId: string): unknown;
+    recordFrame(ctx: unknown): Promise<void>;
+    getActiveTrail(trackId: string): unknown;
+    getActiveTrails(deviceId: string): unknown;
+    getPersistedTrail(trackId: string): Promise<unknown>;
+    getTrail(trackId: string): Promise<unknown>;
+    listTrails(deviceId: string, options?: {
+        since?: number;
+        until?: number;
+        limit?: number;
+        className?: string;
+    }): Promise<unknown>;
+}
+interface IRetention {
+    start(): void;
+    stop(): void;
+    runCleanup(): Promise<unknown>;
+    setConfig(update: Partial<RetentionConfig>): void;
+    getConfig(): unknown;
+    forceCleanup(): Promise<unknown>;
+}
+interface ISessionTracker {
+    updateFromAnalysis(deviceId: string, ctx: unknown): void;
+    getActiveTracks(deviceId: string): unknown;
+    getAllActiveTracks(): unknown;
+    getTrack(deviceId: string, trackId: string): unknown;
+    getTrackCounts(): unknown;
+    clearDevice(deviceId: string): void;
+    clearAll(): void;
+    getGlobalPool(): unknown;
+}
+interface IKnownFaces {
+    register(entry: KnownFaceEntry): Promise<void>;
+    listAll(): Promise<unknown>;
+    delete(id: string): Promise<void>;
+    update(id: string, updates: Partial<Pick<KnownFaceEntry, 'label' | 'group'>>): Promise<void>;
+    recalculateEmbedding(id: string, clipRecognizer: ClipRecognizer): Promise<void>;
+    findMatch(embedding: Float32Array, threshold: number): Promise<unknown>;
+    batchRegister(entries: ReadonlyArray<{
+        readonly label: string;
+        readonly cropBase64: string;
+        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;
+}
+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>;
+}
+
+/**
+ * Whether a capability allows one active provider (singleton) or many (collection).
+ */
+type CapabilityMode = 'singleton' | 'collection';
+/**
+ * Declared in addon package.json manifests under camstack.addons[].capabilities.
+ */
+interface CapabilityDeclaration {
+    /** Capability name (e.g. 'storage', 'decoder', 'analysis-pipeline') */
+    readonly name: string;
+    /** singleton: one active at a time. collection: all active in parallel. */
+    readonly mode: CapabilityMode;
+    /** Optional dependencies — addon won't initialize until these capabilities are available */
+    readonly dependsOn?: readonly string[];
+}
+/**
+ * Registration object for a service that consumes a capability.
+ * The registry calls the appropriate callback when providers are added/removed/replaced.
+ */
+interface CapabilityConsumerRegistration<T = unknown> {
+    /** Which capability this consumer needs */
+    readonly capability: string;
+    /** Called when a singleton provider is set or replaced. Async for teardown of previous. */
+    onSet?(provider: T): void | Promise<void>;
+    /** Called when a collection provider is added */
+    onAdded?(provider: T): void | Promise<void>;
+    /** Called when a collection provider is removed (addon disabled) */
+    onRemoved?(provider: T): void | Promise<void>;
+}
+/**
+ * Introspection data for a registered capability.
+ */
+interface CapabilityInfo {
+    readonly name: string;
+    readonly mode: CapabilityMode;
+    /** All addon IDs that provide this capability */
+    readonly providers: readonly string[];
+    /** For singleton: the active addon ID (null if none) */
+    readonly activeProvider: string | null;
+}
+/**
+ * Maps capability names to their provider interfaces.
+ * Extensible via TypeScript declaration merging:
+ *
+ * ```typescript
+ * declare module '@camstack/types' {
+ *   interface CapabilityProviderMap {
+ *     'my-custom-capability': IMyProvider
+ *   }
+ * }
+ * ```
+ */
+interface CapabilityProviderMap {
+    'storage': IStorageProvider;
+    'log-destination': ILogDestination;
+    'analysis-pipeline': IAnalysisAddon;
+    'restreamer': unknown;
+    'webrtc': unknown;
+    'stream-broker': unknown;
+    'addon-pages': IAddonPageProvider;
+    'admin-ui': IAdminUI;
+    'auth-provider': IAuthProvider;
+    'notification-output': INotificationOutput;
+    'addon-routes': IAddonRouteProvider;
+    'recording-engine': unknown;
+    'analysis-data-persistence': IAnalysisDataPersistence;
+    'device-provider': unknown;
+    'network-access': unknown;
+    'streaming-engine': unknown;
+    [key: string]: unknown;
+}
+
+/**
+ * CamstackContext -- injected into every provider, device, and addon.
+ *
+ * Each element receives a context scoped to its identity:
+ * - logger is pre-scoped: (Frigate)[FrontDoor] for a device, (Frigate) for a provider
+ * - storage is namespaced: all reads/writes are relative to this element's ID
+ * - eventBus is shared (system-wide) but the source is pre-filled
+ * - config provides read/write access to this element's persisted configuration
+ *
+ * The `id` is an immutable progressive identifier assigned at creation time.
+ * It never changes even if the element is renamed.
+ */
+interface CamstackContext {
+    /** Immutable progressive ID of this element (e.g., 'provider:frigate-1', 'device:frigate-1/front-door') */
+    readonly id: string;
+    /** Pre-scoped logger -- logs automatically include this element's scope chain */
+    readonly logger: IScopedLogger;
+    /** Event bus -- shared system-wide, use for emitting and subscribing to events */
+    readonly eventBus: IEventBus;
+    /** Storage scoped to this element -- all paths are relative to this element's namespace */
+    readonly storage: IStorageLocation;
+    /** Persisted configuration for this element -- read/write/subscribe to changes */
+    readonly config: IElementConfig;
+}
+/**
+ * Scoped configuration store for an element.
+ * Values are persisted in the element's storage namespace.
+ */
+interface IElementConfig {
+    /** Get the full config object */
+    getAll(): Record<string, unknown>;
+    /** Get a single value by dot-path (e.g., 'mqtt.brokerUrl') */
+    get<T = unknown>(key: string): T | undefined;
+    /** Set a single value */
+    set(key: string, value: unknown): Promise<void>;
+    /** Set the entire config object (merge or replace) */
+    setAll(config: Record<string, unknown>): Promise<void>;
+    /** Subscribe to config changes -- callback receives the new full config */
+    onChange(callback: (config: Record<string, unknown>) => void): () => void;
+}
+
+/**
+ * Progress update sent from a task handler back to the hub.
+ */
+interface TaskProgress {
+    readonly percent?: number;
+    readonly message?: string;
+    readonly data?: unknown;
+}
+/**
+ * Context provided to a task handler when executing a task.
+ */
+interface TaskContext {
+    /** ID of the agent executing this task */
+    readonly taskId: string;
+    /** ID of the agent executing this task */
+    readonly agentId: string;
+    /** Pre-scoped logger for the task */
+    readonly logger: IScopedLogger;
+    /** Send progress updates back to hub */
+    reportProgress(progress: TaskProgress): void;
+    /** Check if the task has been cancelled */
+    isCancelled(): boolean;
+}
+/**
+ * Security level for a task handler. Dangerous tasks (e.g., terminal.exec)
+ * require explicit admin approval per agent.
+ */
+type TaskHandlerSecurity = 'safe' | 'dangerous';
+/**
+ * Pluggable task handler interface. Any addon can register task handlers
+ * that the hub can dispatch to agents.
+ */
+interface ITaskHandler {
+    /** Unique task type identifier (e.g., 'pipeline.decode', 'system.info') */
+    readonly taskType: string;
+    /** Human-readable description */
+    readonly description: string;
+    /** Security level — dangerous tasks need explicit admin approval */
+    readonly security?: TaskHandlerSecurity;
+    /** Execute the task and return a result */
+    handle(payload: unknown, context: TaskContext): Promise<unknown>;
+    /** Optional cleanup when a running task is cancelled */
+    cancel?(): Promise<void>;
 }
 
+/** Storage interface for addon file operations */
+interface IAddonFileStorage {
+    readFile(path: string): Promise<Buffer>;
+    writeFile(path: string, data: Buffer): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    listFiles(prefix?: string): Promise<readonly string[]>;
+    exists(path: string): Promise<boolean>;
+}
+/** Storage interface for addon structured data (DB) */
+interface IAddonStructuredStorage {
+    query(collection: string, filter?: Record<string, unknown>): Promise<readonly unknown[]>;
+    insert(collection: string, data: Record<string, unknown>): Promise<void>;
+    update(collection: string, id: string, data: Record<string, unknown>): Promise<void>;
+    delete(collection: string, id: string): Promise<void>;
+}
+/** Named file storage locations available to addons */
+type AddonFileLocationName = 'data' | 'media' | 'recordings' | 'models' | 'cache' | 'logs';
+/** Named structured storage locations available to addons */
+type AddonStructuredLocationName = 'data' | 'events' | 'config';
+/** Combined storage location name (union of file and structured) */
+type AddonStorageLocationName = AddonFileLocationName | AddonStructuredLocationName;
+/** Storage access for addons -- replaces raw AddonLocationPaths */
+interface AddonStorageLocations {
+    /** Get file storage for a named location */
+    getFiles(location: AddonFileLocationName): IAddonFileStorage;
+    /** Get structured storage (DB) for a named location */
+    getStructured(location: AddonStructuredLocationName): IAddonStructuredStorage;
+}
+type AddonCapability = 'storage' | 'backup' | 'log-destination' | 'device-exporter' | 'network-access' | 'turn-provider' | 'webrtc-provider' | 'remote-access' | 'recording-engine' | 'notification-output' | 'streaming-engine' | 'pipeline-consumer' | 'detection-engine' | 'object-detector' | 'motion-analyzer' | 'sub-detector' | 'face-detector' | 'plate-detector' | 'recognizer' | 'face-recognizer' | 'plate-recognizer' | 'audio-classifier' | 'device-provider' | 'stream-broker' | 'analysis-data-persistence' | 'analysis-pipeline';
 interface RequiredStep {
     readonly slot: PipelineSlot;
     readonly outputClasses: readonly string[];
@@ -625,8 +1818,13 @@ interface AddonManifest {
     readonly id: string;
     readonly name: string;
     readonly version: string;
-    readonly description: string;
-    readonly packageName: string;
+    readonly description?: string;
+    readonly packageName?: string;
+    readonly capabilities?: readonly (AddonCapability | {
+        name: string;
+        mode: string;
+    })[];
+    readonly requiredFeatures?: readonly string[];
     readonly slot?: PipelineSlot;
     readonly inputClasses?: readonly string[];
     readonly outputClasses?: readonly string[];
@@ -638,30 +1836,103 @@ interface AddonManifest {
 interface AddonLocationPaths {
     readonly data: string;
     readonly media: string;
+    readonly recordings: string;
     readonly models: string;
     readonly logs: string;
     readonly cache: string;
 }
+/**
+ * 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>;
+    /** Absolute path to the shared models directory. */
+    getModelsDir(): string;
+    /** Whether a model file is already present on disk. */
+    isDownloaded(id: string): boolean;
+}
+/**
+ * AddonContext -- injected into every addon at initialize().
+ *
+ * The context includes both the CamstackContext fields (id, logger, eventBus, storage, config)
+ * and addon-specific extras (addonConfig, models, locationPaths, router, network).
+ */
 interface AddonContext {
+    /** Immutable progressive ID */
+    readonly id: string;
+    /** Pre-scoped logger */
+    readonly logger: IScopedLogger;
+    /** System event bus */
+    readonly eventBus: IEventBus;
+    /** Scoped storage location */
+    readonly storage: IStorageLocation;
+    /** Persisted config store */
+    readonly config: IElementConfig;
+    /** Bootstrap configuration from server settings (read-only, from config.yaml) */
     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. */
     readonly locationPaths: AddonLocationPaths;
+    /** HTTP router for registering addon routes */
     readonly router?: IAddonRouter;
+    /** Network access provider */
     readonly network?: INetworkProvider;
-    readonly logger?: IScopedLogger;
-    readonly eventBus?: IEventBus;
-    readonly storage?: IStorageProvider;
+    /** 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;
 }
 interface ICamstackAddon {
-    readonly id: string;
+    readonly id?: string;
     readonly manifest: AddonManifest;
     initialize(context: AddonContext): Promise<void>;
     shutdown(): Promise<void>;
     getConfigSchema?(): ConfigUISchema;
+    /**
+     * Return the provider instance for a declared capability.
+     * Called by CapabilityRegistry after initialize() succeeds.
+     * Returns null if this addon does not provide the requested capability.
+     */
+    getCapabilityProvider?<K extends keyof CapabilityProviderMap>(name: K): CapabilityProviderMap[K] | null;
+}
+/** Declaration of a UI page provided by an addon */
+interface AddonPageDeclaration {
+    /** Unique page ID (scoped to addon) */
+    readonly id: string;
+    /** Display label for sidebar */
+    readonly label: string;
+    /** Lucide icon name for sidebar */
+    readonly icon: string;
+    /** Route path (e.g., '/benchmark') */
+    readonly path: string;
+    /** Relative path to JS bundle within addon package */
+    readonly bundle: string;
+    /** Web component custom element tag name */
+    readonly element: string;
+}
+/** Provider interface for addons that expose UI pages */
+interface IAddonPageProvider {
+    readonly id: string;
+    getPages(): readonly AddonPageDeclaration[];
+}
+/** Provider interface for the admin UI shell (singleton capability) */
+interface IAdminUI {
+    getStaticDir(): string;
+    getVersion(): string;
 }
 interface AddonDeclaration {
     readonly id: string;
     readonly entry: string;
     readonly slot: PipelineSlot;
+    /** Capabilities this addon provides. Declared in package.json camstack.addons[].capabilities */
+    readonly capabilities?: readonly CapabilityDeclaration[];
+    /** UI pages provided by this addon */
+    readonly pages?: readonly AddonPageDeclaration[];
 }
 interface AddonPackageManifest {
     readonly addons: readonly AddonDeclaration[];
@@ -733,24 +2004,6 @@ interface IKnownPlateRepository {
     delete(plateId: string): Promise<void>;
 }
 
-interface ICameraAnalyticsProvider {
-    getLiveState(deviceId: string): CameraLiveState | null;
-    getTracks(deviceId: string, filter?: TrackFilter): TrackedObjectSummary[];
-    getZoneState(deviceId: string, zoneId: string): ZoneLiveState | null;
-    getZoneHistory(deviceId: string, zoneId: string, options: TimeRangeOptions): Promise<ZoneHistoryPoint[]>;
-    getHeatmap(deviceId: string, options: HeatmapOptions): Promise<HeatmapData>;
-    getTrackDetail(deviceId: string, trackId: string): TrackDetail | null;
-    getCameraStatus(deviceId: string): PipelineStatus[];
-}
-interface IAnalysisAddon extends ICamstackAddon, ICameraAnalyticsProvider {
-    processFrame(deviceId: string, frame: FrameInput): Promise<DetectionEvent[]>;
-    setCameraPipeline(deviceId: string, config: PipelineConfig): void;
-    setCameraZones(deviceId: string, zones: ZoneDefinition[]): void;
-    setKnownFaces(faces: KnownFace[]): void;
-    setKnownPlates(plates: KnownPlate[]): void;
-    onLiveStateChange(deviceId: string, callback: (state: CameraLiveState) => void): () => void;
-}
-
 interface PythonProbeResult {
     readonly available: boolean;
     readonly version?: string;
@@ -770,6 +2023,39 @@ interface IPythonEnvironment {
     spawn(script: string, args: readonly string[]): ChildProcess;
 }
 
+/**
+ * Abstract storage backend -- resolves subpaths to absolute filesystem paths.
+ */
+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) */
+    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;
+}
+/** Configuration for a storage location */
+interface StorageLocationConfig {
+    readonly name: string;
+    readonly basePath: string;
+    readonly backendType?: string;
+}
+/** Default storage location paths, relative to dataPath */
+declare const DEFAULT_LOCATION_SUBPATHS: Record<string, string>;
+
 interface IPipelineRunner {
     run(frame: FrameInput, config?: PipelineConfig): Promise<PipelineResult>;
     runSingle(addonId: string, input: FrameInput | CropInput, config?: Record<string, unknown>): Promise<StepResult>;
@@ -790,9 +2076,978 @@ interface IPipelineValidator {
     validate(config: PipelineConfig): ValidationResult;
 }
 
+type DeviceType = 'camera' | 'doorbell' | 'sensor' | 'switch' | 'thermostat' | 'light' | 'generic';
+interface DeviceState {
+    online: boolean;
+    lastSeen?: number;
+    error?: string;
+}
+interface DeviceMetadata {
+    manufacturer?: string;
+    model?: string;
+    firmware?: string;
+    hardwareId?: string;
+    ip?: string;
+}
+interface DeviceEvent {
+    deviceId: string;
+    type: string;
+    timestamp: number;
+    data: Record<string, unknown>;
+}
+interface IDevice {
+    /** Immutable progressive ID */
+    readonly id: string;
+    readonly name: string;
+    readonly providerId: string;
+    readonly type: DeviceType;
+    readonly capabilities: DeviceCapabilityName[];
+    /** The device's context -- logger, storage, eventBus scoped to this device */
+    readonly ctx: CamstackContext;
+    getCapability<T extends IDeviceCapability>(cap: DeviceCapabilityName): T | null;
+    hasCapability(cap: DeviceCapabilityName): boolean;
+    getState(): DeviceState;
+    getMetadata(): DeviceMetadata;
+    subscribeEvents?(callback: (event: DeviceEvent) => void): () => void;
+    /** Optional: declare configurable settings UI for this device */
+    getConfigSchema?(): ConfigUISchema;
+}
+
+interface ProviderStatus {
+    connected: boolean;
+    error?: string;
+    deviceCount: number;
+}
+interface DiscoveredDevice {
+    externalId: string;
+    name: string;
+    type: DeviceType;
+    capabilities: DeviceCapabilityName[];
+    metadata: DeviceMetadata;
+}
+interface LiveEvent {
+    type: string;
+    camera: string;
+    timestamp: number;
+    data: Record<string, unknown>;
+}
+interface IDeviceProvider {
+    /** Immutable progressive ID */
+    readonly id: string;
+    readonly type: string;
+    readonly name: string;
+    readonly discoveryMode: 'auto' | 'manual' | 'both';
+    /** The provider's context -- logger, storage, eventBus scoped to this provider */
+    readonly ctx: CamstackContext;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): ProviderStatus;
+    discoverDevices(): Promise<DiscoveredDevice[]>;
+    getDeviceConfigSchema?(): unknown;
+    createDevice?(config: Record<string, unknown>): Promise<IDevice>;
+    adoptDevice?(externalId: string, config?: Record<string, unknown>): Promise<IDevice>;
+    getDevices(): IDevice[];
+    subscribeLiveEvents(callback: (event: LiveEvent) => void): () => void;
+    /** Optional: declare configurable settings UI for this provider */
+    getConfigSchema?(): ConfigUISchema;
+}
+
+interface StreamOption {
+    id: string;
+    label: string;
+    protocol: 'rtsp' | 'http' | 'webrtc';
+    quality: 'main' | 'mid' | 'sub' | 'mobile';
+    url?: string;
+}
+type ConnectionMode = 'always-on' | 'on-demand';
+interface ICamera extends IDeviceCapability {
+    kind: 'camera';
+    getSnapshot(options?: {
+        width?: number;
+        height?: number;
+    }): Promise<Buffer>;
+    getStreamOptions(): Promise<StreamOption[]>;
+    getStreamUrl(option: StreamOption): Promise<string>;
+    onStreamRequested?(streamId: string): Promise<void>;
+    getConnectionMode(): ConnectionMode;
+    setConnectionMode(mode: ConnectionMode): Promise<void>;
+}
+
+interface PtzPreset {
+    id: string;
+    name: string;
+}
+interface IPanTiltZoom extends IDeviceCapability {
+    kind: 'panTiltZoom';
+    move(command: {
+        pan?: number;
+        tilt?: number;
+        zoom?: number;
+        speed?: number;
+    }): Promise<void>;
+    continuousMove(command: {
+        pan?: number;
+        tilt?: number;
+        zoom?: number;
+    }): Promise<void>;
+    stop(): Promise<void>;
+    getPresets(): Promise<PtzPreset[]>;
+    goToPreset(presetId: string): Promise<void>;
+    goHome(): Promise<void>;
+    getPosition(): Promise<{
+        pan: number;
+        tilt: number;
+        zoom: number;
+    }>;
+}
+
+interface IMotionSensor extends IDeviceCapability {
+    kind: 'motionSensor';
+    isMotionDetected(): boolean;
+    subscribe(callback: (active: boolean) => void): () => void;
+}
+
+interface AudioEvent {
+    timestamp: number;
+    metric: string;
+    value?: number;
+}
+interface IAudioDetector extends IDeviceCapability {
+    kind: 'audioDetector';
+    getAudioLevel(): number;
+    subscribe(callback: (event: AudioEvent) => void): () => void;
+}
+
+interface ITwoWayAudio extends IDeviceCapability {
+    kind: 'twoWayAudio';
+    startMicrophone(stream: unknown): Promise<void>;
+    stopMicrophone(): Promise<void>;
+    isMicrophoneActive(): boolean;
+}
+
+interface DoorbellEvent {
+    timestamp: number;
+    deviceId: string;
+}
+interface IDoorbell extends IDeviceCapability {
+    kind: 'doorbell';
+    onRing(callback: (event: DoorbellEvent) => void): () => void;
+}
+
+/** A stored event from a device */
+interface DeviceStoredEvent {
+    id: string;
+    type: string;
+    timestamp: number;
+    endTimestamp?: number;
+    label?: string;
+    score?: number;
+    hasClip?: boolean;
+    hasSnapshot?: boolean;
+    thumbnailUrl?: string;
+    data?: Record<string, unknown>;
+}
+/** Query filter for events */
+interface EventQuery {
+    since?: number;
+    until?: number;
+    types?: string[];
+    detectionClasses?: string[];
+    clusterSpan?: number;
+    onlyKeyEvents?: boolean;
+    includeClip?: boolean;
+    limit?: number;
+    offset?: number;
+}
+/** Query result */
+interface EventQueryResult {
+    events: DeviceStoredEvent[];
+    total: number;
+}
+/** A cluster of nearby events */
+interface EventCluster {
+    representative: DeviceStoredEvent;
+    events: DeviceStoredEvent[];
+    startMs: number;
+    endMs: number;
+    classes: string[];
+}
+interface IEvents extends IDeviceCapability {
+    kind: 'events';
+    getEvents(query: EventQuery): Promise<EventQueryResult>;
+    getEventThumbnail(eventId: string): Promise<Buffer | null>;
+    getEventSnapshot(eventId: string): Promise<Buffer | null>;
+    getEventClipUrl(eventId: string): Promise<string | null>;
+}
+
+interface TimeRange {
+    since: number;
+    until: number;
+}
+interface RecordingSegment {
+    id: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+}
+interface IRecording extends IDeviceCapability {
+    kind: 'recording';
+    getSegments(range: TimeRange): Promise<RecordingSegment[]>;
+    getPlaybackUrl(startTime: number, endTime: number): Promise<string>;
+    getThumbnailAt(timestampMs: number): Promise<Buffer | null>;
+}
+
+interface AccessoryInfo {
+    id: string;
+    name: string;
+    type: string;
+    state?: Record<string, unknown>;
+}
+interface IAccessory extends IDeviceCapability {
+    kind: 'accessory';
+    getAccessories(): Promise<AccessoryInfo[]>;
+    executeCommand(accessoryId: string, command: string, params?: Record<string, unknown>): Promise<void>;
+    getAccessoryState(accessoryId: string): Promise<Record<string, unknown>>;
+}
+
+interface IStatusLight extends IDeviceCapability {
+    kind: 'statusLight';
+    isOn(): boolean;
+    setOn(on: boolean): Promise<void>;
+}
+
+interface ISiren extends IDeviceCapability {
+    kind: 'siren';
+    isActive(): boolean;
+    activate(durationMs?: number): Promise<void>;
+    deactivate(): Promise<void>;
+}
+
+interface ISwitch extends IDeviceCapability {
+    kind: 'switch';
+    isOn(): boolean;
+    setOn(on: boolean): Promise<void>;
+    toggle(): Promise<void>;
+}
+
+type StreamFormat = 'webrtc' | 'hls' | 'mjpeg' | 'rtsp';
+interface StreamingSource {
+    readonly url: string;
+    readonly protocol: 'rtsp' | 'http' | 'rtmp';
+    readonly deviceId: string;
+    readonly providerId: string;
+    readonly label?: string;
+}
+interface StreamInfo {
+    readonly streamId: string;
+    readonly source: StreamingSource;
+    readonly formats: StreamFormat[];
+}
+interface StreamStatus {
+    readonly active: boolean;
+    readonly viewers: number;
+    readonly startedAt?: number;
+}
+interface IStreamingEngine {
+    initialize(config: Record<string, unknown>): Promise<void>;
+    shutdown(): Promise<void>;
+    registerStream(streamId: string, source: StreamingSource): Promise<void>;
+    unregisterStream(streamId: string): Promise<void>;
+    getStreamUrl(streamId: string, format: StreamFormat): string | null;
+    proxyWhepOffer(streamId: string, sdpOffer: string): Promise<string>;
+    listStreams(): StreamInfo[];
+    getStreamStatus(streamId: string): StreamStatus | null;
+}
+
+type UserRole = 'super_admin' | 'admin' | 'viewer';
+interface UserPermissions {
+    role: UserRole;
+    allowedProviders: string[] | '*';
+    allowedDevices: Record<string, string[] | '*'>;
+}
+interface UserRecord {
+    id: string;
+    username: string;
+    passwordHash: string;
+    role: UserRole;
+    allowedProviders: string[] | '*';
+    allowedDevices: Record<string, string[] | '*'>;
+    createdAt: number;
+    updatedAt: number;
+}
+interface ApiKeyRecord {
+    id: string;
+    label: string;
+    role: UserRole;
+    allowedProviders: string[] | '*';
+    allowedDevices: Record<string, string[] | '*'>;
+    tokenHash: string;
+    tokenPrefix: string;
+    createdAt: number;
+    lastUsedAt?: number;
+}
+interface TokenPayload {
+    type?: 'api_key';
+    keyId?: string;
+    userId?: string;
+    username?: string;
+    role: UserRole;
+    allowedProviders: string[] | '*';
+    allowedDevices: Record<string, string[] | '*'>;
+    iat?: number;
+    exp?: number;
+}
+interface AuthenticatedUser {
+    id: string;
+    username: string;
+    role: UserRole;
+    permissions: UserPermissions;
+    isApiKey: boolean;
+}
+
+type ElementState = 'stopped' | 'starting' | 'running' | 'stopping' | 'error' | 'disabled';
+interface ElementStatus {
+    state: ElementState;
+    error?: string;
+    startedAt?: number;
+    stoppedAt?: number;
+    restartCount: number;
+    uptime: number;
+}
+interface ILifecycleManaged {
+    readonly id: string;
+    getStatus(): ElementStatus;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    restart(): Promise<void>;
+    enable(): Promise<void>;
+    disable(): Promise<void>;
+}
+
+/**
+ * Server-side network access interfaces.
+ * These cover tunnel/VPN/endpoint management, NOT the addon-facing INetworkProvider.
+ */
+interface INetworkEndpoint {
+    id: string;
+    type: 'lan' | 'mdns' | 'domain' | 'tunnel' | 'vpn' | 'custom';
+    provider: string;
+    url: string;
+    internal: boolean;
+    capabilities: EndpointCapabilities;
+    priority: number;
+    status: 'online' | 'offline' | 'unknown';
+    metadata?: Record<string, unknown>;
+}
+interface EndpointCapabilities {
+    supportsWebRTC: boolean;
+    supportsWebSocket: boolean;
+    supportsSSE: boolean;
+    maxBandwidthMbps?: number;
+}
+interface INetworkAccessProvider {
+    id: string;
+    type: string;
+    start(): Promise<INetworkEndpoint>;
+    stop(): Promise<void>;
+    getEndpoint(): INetworkEndpoint | null;
+    getStatus(): NetworkAccessStatus;
+}
+interface NetworkAccessStatus {
+    connected: boolean;
+    publicUrl?: string;
+    error?: string;
+    connectedSince?: number;
+}
+interface IExposedResource {
+    id: string;
+    providerId: string;
+    deviceId?: string;
+    type: ExposedResourceType;
+    path: string;
+    auth: ResourceAuthMode;
+    description: string;
+    contentType?: string;
+    enabled: boolean;
+}
+type ExposedResourceType = 'snapshot' | 'stream' | 'webhook' | 'api' | 'media' | 'custom';
+type ResourceAuthMode = {
+    mode: 'public';
+} | {
+    mode: 'token';
+    token: string;
+} | {
+    mode: 'api-key';
+} | {
+    mode: 'jwt';
+} | {
+    mode: 'ip-whitelist';
+    ips: string[];
+};
+interface IResourceExposer {
+    getExposedResources(): IExposedResource[];
+    handleResourceRequest(resourceId: string, request: ExposedResourceRequest): Promise<ExposedResourceResponse>;
+}
+interface ExposedResourceRequest {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    path: string;
+    headers: Record<string, string>;
+    query: Record<string, string>;
+    body?: Buffer | string;
+    remoteIp: string;
+}
+interface ExposedResourceResponse {
+    status: number;
+    headers?: Record<string, string>;
+    body?: Buffer | string | NodeJS.ReadableStream;
+}
+
+interface ProcessStats {
+    pid: number;
+    cpu: number;
+    memory: number;
+    uptime: number;
+    restartCount: number;
+}
+interface ProcessConfig {
+    id: string;
+    label: string;
+    command?: string;
+    modulePath?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    autoRestart: boolean;
+    maxRestarts?: number;
+    healthCheck?: {
+        intervalMs: number;
+        timeoutMs: number;
+        failureThreshold: number;
+    };
+}
+interface ManagedProcessStatus {
+    id: string;
+    label: string;
+    state: ElementState;
+    pid?: number;
+    stats?: ProcessStats;
+    lastCrashAt?: number;
+    lastCrashError?: string;
+    restartCount: number;
+    nextRestartAt?: number;
+}
+/** Minimal interface for ProcessManagerService used by addons */
+interface IProcessManager {
+    register(config: ProcessConfig): unknown;
+    start(id: string): Promise<void>;
+    stop(id: string): Promise<void>;
+}
+
+interface FeatureManifest {
+    streaming: boolean;
+    notifications: boolean;
+    objectDetection: boolean;
+    remoteAccess: boolean;
+    agentCluster: boolean;
+    smartHome: boolean;
+    recordings: boolean;
+    backup: boolean;
+    repl: boolean;
+}
+type FeatureFlag = keyof FeatureManifest;
+declare const DEFAULT_FEATURES: FeatureManifest;
+
+interface AgentInfo {
+    readonly id: string;
+    readonly name: string;
+    readonly capabilities: readonly string[];
+    readonly host: string;
+    readonly port: number;
+    readonly resources?: AgentResources;
+}
+interface AgentResources {
+    readonly cpuCores?: number;
+    readonly memoryMB?: number;
+    readonly gpuAvailable?: boolean;
+    readonly gpuModel?: string;
+}
+interface AgentStatus {
+    readonly id: string;
+    readonly name: string;
+    readonly state: 'online' | 'offline' | 'degraded';
+    readonly capabilities: readonly string[];
+    readonly lastHeartbeat: number;
+    readonly connectedSince?: number;
+    readonly resources?: AgentResources;
+    readonly activeTaskCount: number;
+    readonly completedTaskCount: number;
+    readonly failedTaskCount: number;
+}
+interface AgentTask {
+    readonly id: string;
+    readonly capability: string;
+    readonly input: Record<string, unknown>;
+    readonly timeout: number;
+    readonly priority: 'low' | 'normal' | 'high';
+    readonly label?: string;
+}
+interface AgentTaskResult {
+    readonly taskId: string;
+    readonly agentId: string;
+    readonly status: 'success' | 'error' | 'timeout';
+    readonly output?: Record<string, unknown>;
+    readonly error?: string;
+    readonly durationMs: number;
+}
+interface TaskDispatchOptions {
+    readonly preferredAgent?: string;
+    readonly capability: string;
+    readonly remoteOnly?: boolean;
+}
+interface AgentEntry {
+    readonly info: AgentInfo;
+    state: 'online' | 'offline' | 'degraded';
+    connectedSince: number;
+    lastHeartbeat: number;
+    activeTaskCount: number;
+    completedTaskCount: number;
+    failedTaskCount: number;
+}
+
+type AgentCapability = 'decoder' | 'transcoder' | 'detector' | 'recorder';
+type RolePriority = 'primary' | 'backup' | 'overflow';
+interface CameraRoleAssignment {
+    cameraId: string;
+    role: AgentCapability;
+    agentId: string;
+    priority: RolePriority;
+    rtspUrl?: string;
+    detectionConfig?: {
+        modelId: string;
+        runtime: string;
+        confidence: number;
+        fps: number;
+        classes?: string[];
+    };
+}
+type HubToAgentMessage = {
+    type: 'assign';
+    assignment: CameraRoleAssignment;
+} | {
+    type: 'unassign';
+    cameraId: string;
+    role: AgentCapability;
+} | {
+    type: 'recording.start';
+    cameraId: string;
+    rtspUrl: string;
+} | {
+    type: 'recording.stop';
+    cameraId: string;
+} | {
+    type: 'benchmark.run';
+    config: RemoteBenchmarkConfig;
+} | {
+    type: 'config.update';
+    addonId: string;
+    config: Record<string, unknown>;
+} | {
+    type: 'task.execute';
+    taskId: string;
+    taskType: string;
+    payload: unknown;
+} | {
+    type: 'task.cancel';
+    taskId: string;
+} | {
+    type: 'addon.install';
+    package: string;
+    version?: string;
+} | {
+    type: 'addon.uninstall';
+    package: string;
+} | {
+    type: 'addon.update';
+    package: string;
+    version?: string;
+} | {
+    type: 'addon.restart';
+} | {
+    type: 'ping';
+};
+type AgentToHubMessage = {
+    type: 'register';
+    info: AgentRegistrationInfo;
+} | {
+    type: 'heartbeat';
+    status: AgentRuntimeStatus;
+} | {
+    type: 'detection.result';
+    cameraId: string;
+    detections: DetectionResult[];
+    timestamp: number;
+    inferenceMs: number;
+} | {
+    type: 'recording.segment';
+    cameraId: string;
+    segment: RecordingSegmentInfo;
+} | {
+    type: 'recording.status';
+    cameraId: string;
+    recording: boolean;
+} | {
+    type: 'benchmark.progress';
+    event: BenchmarkStreamEvent;
+} | {
+    type: 'benchmark.result';
+    report: BenchmarkReport;
+} | {
+    type: 'task.result';
+    taskId: string;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+} | {
+    type: 'task.progress';
+    taskId: string;
+    progress: TaskProgress;
+} | {
+    type: 'addon.install-result';
+    package: string;
+    success: boolean;
+    version?: string;
+    error?: string;
+} | {
+    type: 'addon.uninstall-result';
+    package: string;
+    success: boolean;
+    error?: string;
+} | {
+    type: 'addon.update-result';
+    package: string;
+    success: boolean;
+    version?: string;
+    error?: string;
+} | {
+    type: 'log';
+    level: string;
+    scope: string;
+    message: string;
+} | {
+    type: 'pong';
+};
+declare const BINARY_FRAME_HEADER_SIZE = 29;
+declare const BINARY_FRAME_TYPE = 1;
+interface AgentRegistrationInfo {
+    id: string;
+    name: string;
+    capabilities: AgentCapability[];
+    host: string;
+    port: number;
+    platform: string;
+    arch: string;
+    cpuCores: number;
+    memoryMB: number;
+    gpuModel?: string;
+    pythonRuntimes: string[];
+    httpPort: number;
+    /** Task types this agent can handle (e.g., 'pipeline.decode', 'system.info') */
+    taskTypes?: string[];
+    /** Installed addons on this agent */
+    installedAddons?: string[];
+}
+interface AgentRuntimeStatus {
+    activeCameras: number;
+    cpuPercent: number;
+    memoryPercent: number;
+    fps: Record<string, number>;
+    errors: string[];
+}
+interface DetectionResult {
+    className: string;
+    score: number;
+    bbox: [number, number, number, number];
+}
+interface RecordingSegmentInfo {
+    id: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    sizeBytes: number;
+    path: string;
+    format: 'mp4' | 'ts';
+}
+interface RemoteBenchmarkConfig {
+    runtime: string;
+    modelId?: string;
+    durationMs: number;
+    warmupMs: number;
+    inputWidth: number;
+    inputHeight: number;
+}
+interface BenchmarkStreamEvent {
+    phase: 'warmup' | 'running';
+    iteration: number;
+    inferenceMs: number;
+}
+interface BenchmarkReport {
+    runtime: string;
+    modelId?: string;
+    iterations: number;
+    meanMs: number;
+    p50Ms: number;
+    p95Ms: number;
+    p99Ms: number;
+    minMs: number;
+    maxMs: number;
+}
+
+type Unsubscribe = () => void;
+interface StreamSource {
+    readonly type: string;
+    readonly url: string;
+    readonly videoCodec?: string;
+    readonly audioCodec?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface StreamSourceOption {
+    readonly id: string;
+    readonly label: string;
+    readonly source: StreamSource;
+    readonly resolution?: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly primary?: boolean;
+}
+interface EncodedPacket {
+    readonly type: 'video' | 'audio';
+    readonly data: Buffer;
+    readonly pts: number;
+    readonly dts: number;
+    readonly keyframe: boolean;
+    readonly codec: string;
+}
+interface DecodedFrame {
+    readonly data: Buffer;
+    readonly width: number;
+    readonly height: number;
+    readonly format: 'jpeg' | 'rgb' | 'yuv420';
+    readonly timestamp: number;
+}
+interface DecodedAudioChunk {
+    readonly data: Buffer;
+    readonly sampleRate: number;
+    readonly channels: number;
+    readonly timestamp: number;
+}
+interface DecodeOptions {
+    readonly maxFps?: number;
+    readonly format?: 'jpeg' | 'rgb' | 'yuv420';
+    readonly scale?: number;
+}
+type BrokerStatus = 'idle' | 'connecting' | 'streaming' | 'error' | 'stopped';
+interface BrokerStats {
+    readonly status: BrokerStatus;
+    readonly inputFps: number;
+    readonly decodeFps: number;
+    readonly encodedSubscribers: number;
+    readonly decodedSubscribers: number;
+    readonly uptimeMs: number;
+}
+interface IStreamBroker {
+    readonly deviceId: string;
+    readonly status: BrokerStatus;
+    start(source: StreamSource): Promise<void>;
+    stop(): Promise<void>;
+    onEncodedData(callback: (packet: EncodedPacket) => void): Unsubscribe;
+    onDecodedFrame(callback: (frame: DecodedFrame) => void, options?: DecodeOptions): Unsubscribe;
+    onDecodedAudioChunk(callback: (chunk: DecodedAudioChunk) => void): Unsubscribe;
+    getStats(): BrokerStats;
+    getLocalStreamUrl(): string;
+}
+/**
+ * Manager for stream brokers — the server interacts with this interface,
+ * while the concrete implementation lives in the addon-pipeline package.
+ */
+interface IStreamBrokerManager {
+    createBroker(brokerId: string, source: StreamSource): Promise<IStreamBroker>;
+    getBroker(brokerId: string): IStreamBroker | undefined;
+    destroyBroker(brokerId: string): Promise<void>;
+    destroyBrokersForDevice(deviceId: string): Promise<void>;
+    listBrokers(): readonly IStreamBroker[];
+    destroyAll(): Promise<void>;
+    setRestreamers(restreamers: readonly unknown[]): void;
+    getRestreamers(): readonly unknown[];
+}
+type CameraPriority = 'always-on' | 'default';
+type CameraPhase = 'watching' | 'active';
+interface CameraDetectionConfig {
+    readonly enabled: boolean;
+    readonly priority: CameraPriority;
+    readonly pipeline: PipelineConfig;
+    readonly motionStreamId: string;
+    readonly detectionStreamId: string;
+    readonly motionFps: number;
+    readonly detectionFps: number;
+    readonly motionCooldownMs: number;
+    readonly audioStreamId?: string;
+}
+
+interface RegisteredStream {
+    readonly streamId: string;
+    readonly label: string;
+    readonly codec: string;
+    readonly type: 'video' | 'audio';
+    readonly sourceUrl?: string;
+}
+interface RestreamerExposedResource {
+    readonly type: string;
+    readonly format: string;
+    readonly value: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface IRestreamer {
+    readonly id: string;
+    readonly name: string;
+    registerDevice(deviceId: string, streams: readonly RegisteredStream[]): Promise<void>;
+    pushPacket(streamId: string, packet: EncodedPacket): void;
+    unregisterDevice(deviceId: string): Promise<void>;
+    getExposedResources(deviceId: string): readonly RestreamerExposedResource[];
+    proxyWhepOffer?(streamId: string, sdpOffer: string): Promise<string>;
+}
+
+interface DecoderSessionConfig {
+    readonly codec: string;
+    readonly maxFps: number;
+    readonly outputFormat: 'jpeg' | 'rgb' | 'yuv420';
+    readonly scale: number;
+}
+interface DecoderStats {
+    readonly inputFps: number;
+    readonly outputFps: number;
+    readonly avgDecodeTimeMs: number;
+    readonly droppedFrames: number;
+}
+interface IDecoderSession {
+    pushPacket(packet: EncodedPacket): void;
+    onFrame(callback: (frame: DecodedFrame) => void): Unsubscribe;
+    updateConfig(config: Partial<DecoderSessionConfig>): void;
+    destroy(): Promise<void>;
+    getStats(): DecoderStats;
+}
+interface IDecoderProvider {
+    readonly id: string;
+    readonly name: string;
+    supportsCodec(codec: string): boolean;
+    createSession(config: DecoderSessionConfig): IDecoderSession;
+}
+
+interface FfmpegConfig {
+    readonly path: string;
+    readonly hwaccel?: 'vaapi' | 'qsv' | 'videotoolbox' | 'cuda' | 'v4l2m2m' | 'none';
+    readonly inputArgs?: readonly string[];
+    readonly outputArgs?: readonly string[];
+    readonly videoCodec?: string;
+    readonly audioCodec?: string;
+    readonly threads?: number;
+}
+
+type ModelType = 'detection' | 'face-detection' | 'face-recognition' | 'plate-detection' | 'ocr' | 'embedding' | 'audio-classification' | 'custom';
+type ModelFormat = 'onnx' | 'tflite' | 'coreml' | 'openvino';
+interface ServerModelCatalogEntry {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    readonly type: ModelType;
+    readonly format: ModelFormat;
+    readonly available: boolean;
+    readonly downloadUrl?: string;
+    readonly fallbackDownloadUrls?: readonly string[];
+    readonly sizeMB?: number;
+    readonly exportHint?: string;
+    readonly inputSize: {
+        readonly width: number;
+        readonly height: number;
+        readonly channels?: number;
+    };
+    readonly labels?: readonly string[];
+}
+interface IModelCatalogProvider {
+    readonly pluginId: string;
+    getModelCatalog(): ServerModelCatalogEntry[];
+}
+
+interface StreamNetworkStats {
+    readonly nominalBitrateKbps: number;
+    readonly observedBitrateKbps: number;
+    readonly peakBitrateKbps: number;
+    readonly packetLossPercent: number;
+    readonly lastUpdated: number;
+}
+interface ClientNetworkStats {
+    readonly rttMs: number;
+    readonly jitterMs: number;
+    readonly estimatedBandwidthKbps: number;
+    readonly lastUpdated: number;
+}
+interface DeviceNetworkStats {
+    readonly deviceId: string;
+    readonly streams: Readonly<Record<string, StreamNetworkStats>>;
+    readonly client?: ClientNetworkStats;
+}
+interface INetworkQualityTracker {
+    reportStreamStats(deviceId: string, streamId: string, bitrateKbps: number, packetLoss?: number): void;
+    reportClientStats(deviceId: string, stats: Omit<ClientNetworkStats, 'lastUpdated'>): void;
+    getDeviceStats(deviceId: string): DeviceNetworkStats | null;
+    getAllStats(): readonly DeviceNetworkStats[];
+}
+
+interface IWebRtcProvider {
+    readonly id: string;
+    readonly name: string;
+    handleOffer(streamId: string, sdpOffer: string): Promise<string>;
+    supportsStream(streamId: string): boolean;
+    registerStream(streamId: string, codec: string): Promise<void>;
+    pushPacket(streamId: string, packet: EncodedPacket): void;
+    unregisterStream(streamId: string): Promise<void>;
+}
+
+interface ReplContext {
+    scope: ReplScope;
+    variables: Record<string, unknown>;
+}
+type ReplScope = {
+    type: 'system';
+} | {
+    type: 'provider';
+    providerId: string;
+} | {
+    type: 'device';
+    deviceId: string;
+} | {
+    type: 'addon';
+    addonId: string;
+};
+interface ReplResult {
+    output: string;
+    type: 'value' | 'error' | 'void';
+    duration: number;
+}
+interface IReplEngine {
+    execute(code: string, context: ReplContext): Promise<ReplResult>;
+    getCompletions(partial: string, context: ReplContext): Promise<string[]>;
+}
+
 declare const HF_REPO = "camstack/camstack-models";
 declare const HF_BASE_URL = "https://huggingface.co/camstack/camstack-models/resolve/main";
 
 declare function hfModelUrl(repo: string, path: string): string;
 
-export { type AccuracyStats, type AddonContext, type AddonDeclaration, type AddonLocationPaths, type AddonManifest, type AddonPackageManifest, type AgentBenchmarkStatus, type AudioChunkInput, type BenchmarkConfig, type BenchmarkExecution, type BenchmarkMode, type BenchmarkSource, type BenchmarkTarget, type BenchmarkTargetResult, type BoundingBox, type CameraAnalysisConfig, type CameraLiveState, ClassMapDefinition, type Classification, type ClassifierOutput, type ConfigBooleanField, type ConfigField, type ConfigFieldBase, type ConfigModelSelectorField, type ConfigNumberField, type ConfigSection, type ConfigSelectField, type ConfigSliderField, type ConfigTextField, type ConfigUISchema, type CropInput, type CropperOutput, CustomModelMetadata, type DetectionDevice, type DetectionEvent, type DetectionEventType, DetectionModel, type DetectionRuntime, type DetectorOutput, type EventCallback, type EventSnapshot, type FrameInput, type GroundTruth, type GroundTruthAnnotation, HF_BASE_URL, HF_REPO, type HeatmapData, type HeatmapOptions, type HttpMethod, type IAddonRouter, type IAnalysisAddon, type ICameraAnalyticsProvider, type ICamstackAddon, type IClassifierProvider, type ICropperProvider, type IDetectionAddon, type IDetectorProvider, type IEventBus, type IInferenceEngine, type IKnownFaceRepository, type IKnownPlateRepository, type ILogDestination, type INetworkProvider, type IPipelineRunner, type IPipelineSlotProvider, type IPipelineValidator, type IPythonEnvironment, type IRemoteAccessProvider, type IScopedLogger, type IStorageBackend, type IStorageProvider, type ITurnProvider, type IZoneRepository, type KnownAudioEvent, type KnownFace, type KnownPlate, LabelDefinition, type Landmark, type LatencyStats, type LogLevel, ModelCatalogEntry, ModelFormat, ModelOutputFormat, type MultiBenchmarkReport, type NetworkAddress, type ObjectState, type PipelineConfig, type PipelineNode, type PipelineResult, type PipelineSlot, type PipelineStatus, type ProbeCapability, type ProbeResult, type PublicAddress, type PythonEnvReady, type PythonProbeResult, type RemoteAccessStatus, type RequiredStep, type ResolveEngineOptions, type ResourceStats, type RouteHandler, type RouteRequest, type RouteResponse, type SpatialDetection, type StepError, type StepResult, type StorageLocationName, type SystemInfo, type TimeRangeOptions, type TrackDetail, type TrackFilter, type TrackedDetection, type TrackedObjectState, type TrackedObjectSummary, type TurnCredentials, type TurnServer, type ValidationIssue, type ValidationResult, type ZoneDefinition, type ZoneEvent, type ZoneHistoryPoint, type ZoneLiveState, hfModelUrl };
+/** Cosine similarity between two embedding vectors */
+declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+
+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 };