@camstack/types 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,798 @@
+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.js';
+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.js';
+import { ChildProcess } from 'node:child_process';
+
+interface BoundingBox {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+interface Landmark {
+    readonly x: number;
+    readonly y: number;
+    readonly label?: string;
+}
+interface FrameInput {
+    readonly data: Buffer;
+    readonly format: 'jpeg' | 'rgb' | 'yuv420';
+    readonly width: number;
+    readonly height: number;
+    readonly timestamp: number;
+}
+interface AudioChunkInput {
+    readonly data: Float32Array;
+    readonly sampleRate: number;
+    readonly channels: number;
+    readonly timestamp: number;
+}
+
+interface SpatialDetection {
+    readonly class: string;
+    readonly originalClass: string;
+    readonly score: number;
+    readonly bbox: BoundingBox;
+    readonly landmarks?: readonly Landmark[];
+    readonly mask?: Uint8Array;
+    readonly maskWidth?: number;
+    readonly maskHeight?: number;
+}
+interface CropInput {
+    readonly frame: FrameInput;
+    readonly roi: BoundingBox;
+    readonly parentDetection: SpatialDetection;
+}
+interface Classification {
+    readonly class: string;
+    readonly score: number;
+    readonly text?: string;
+    readonly embedding?: Float32Array;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface DetectorOutput {
+    readonly detections: readonly SpatialDetection[];
+    readonly inferenceMs: number;
+    readonly modelId: string;
+}
+interface CropperOutput {
+    readonly crops: readonly SpatialDetection[];
+    readonly inferenceMs: number;
+    readonly modelId: string;
+}
+interface ClassifierOutput {
+    readonly classifications: readonly Classification[];
+    readonly inferenceMs: number;
+    readonly modelId: string;
+}
+
+type ObjectState = 'entering' | 'moving' | 'stationary' | 'leaving' | 'loitering';
+interface TrackedDetection extends SpatialDetection {
+    readonly trackId: string;
+    readonly trackAge: number;
+    readonly velocity?: {
+        readonly dx: number;
+        readonly dy: number;
+    };
+    readonly path: readonly BoundingBox[];
+}
+interface TrackedObjectState {
+    readonly trackId: string;
+    readonly state: ObjectState;
+    readonly stationarySince?: number;
+    readonly enteredAt: number;
+    readonly totalDistancePx: number;
+    readonly dwellTimeMs: number;
+}
+
+type DetectionEventType = 'object.detected' | 'object.classified' | 'object.entering' | 'object.leaving' | 'object.stationary' | 'object.loitering' | 'zone.enter' | 'zone.exit' | 'tripwire.cross' | 'audio.detected';
+interface ZoneEvent {
+    readonly type: 'zone-enter' | 'zone-exit' | 'zone-loiter' | 'tripwire-cross';
+    readonly zoneId: string;
+    readonly zoneName: string;
+    readonly trackId: string;
+    readonly detection: TrackedDetection;
+    readonly direction?: 'in' | 'out' | 'left' | 'right';
+    readonly timestamp: number;
+}
+interface EventSnapshot {
+    readonly thumbnailPath: string;
+    readonly annotatedFramePath: string;
+    readonly debugThumbnails?: Readonly<Record<string, string>>;
+    readonly clipPath?: string;
+    readonly clipDurationSec?: number;
+}
+interface DetectionEvent {
+    readonly id: string;
+    readonly type: DetectionEventType;
+    readonly timestamp: number;
+    readonly deviceId: string;
+    readonly detection: TrackedDetection;
+    readonly classifications: readonly Classification[];
+    readonly objectState: TrackedObjectState;
+    readonly zoneEvents: readonly ZoneEvent[];
+    readonly snapshot?: EventSnapshot;
+    readonly trackPath: readonly BoundingBox[];
+}
+
+type DetectionRuntime = 'onnx' | 'coreml' | 'pytorch' | 'openvino' | 'tflite';
+type DetectionDevice = 'cpu' | 'gpu-cuda' | 'gpu-mps' | 'npu' | 'coral-edgetpu' | 'tensorrt';
+type ProbeCapability = 'fp32' | 'fp16' | 'int8' | 'batch-inference';
+interface ProbeResult {
+    readonly available: boolean;
+    readonly runtime: DetectionRuntime;
+    readonly device: DetectionDevice;
+    readonly capabilities: readonly ProbeCapability[];
+    readonly estimatedMemoryMB?: number;
+}
+interface CameraAnalysisConfig {
+    readonly tracker: {
+        readonly maxAge: number;
+        readonly minHits: number;
+        readonly iouThreshold: number;
+    };
+    readonly stateAnalyzer: {
+        readonly stationaryThresholdSec: number;
+        readonly loiteringThresholdSec: number;
+        readonly velocityThreshold: number;
+    };
+    readonly snapshots: {
+        readonly enabled: boolean;
+        readonly saveThumbnail: boolean;
+        readonly saveAnnotatedFrame: boolean;
+        readonly saveDebugThumbnails: boolean;
+        readonly clipPreSec: number;
+        readonly clipPostSec: number;
+    };
+    readonly events: {
+        readonly minTrackAge: number;
+        readonly cooldownSec: number;
+        readonly enabledTypes: readonly DetectionEventType[];
+    };
+}
+
+interface ZoneDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly cameraId: string;
+    readonly type: 'polygon' | 'tripwire';
+    readonly points: ReadonlyArray<{
+        readonly x: number;
+        readonly y: number;
+    }>;
+    readonly direction?: 'in' | 'out' | 'both';
+    readonly alertOnClasses?: readonly string[];
+    readonly color?: string;
+}
+interface KnownFace {
+    readonly id: string;
+    readonly name: string;
+    readonly label?: string;
+    readonly embeddings: readonly Float32Array[];
+    readonly thumbnailPath?: string;
+    readonly createdAt: number;
+}
+interface KnownPlate {
+    readonly id: string;
+    readonly plateText: string;
+    readonly label?: string;
+    readonly vehicleDescription?: string;
+    readonly createdAt: number;
+}
+interface KnownAudioEvent {
+    readonly id: string;
+    readonly className: string;
+    readonly label: string;
+    readonly notifyAlways: boolean;
+}
+
+type PipelineSlot = 'detector' | 'cropper' | 'classifier';
+interface PipelineNode {
+    readonly step: string;
+    readonly addon: string;
+    readonly configOverride?: Readonly<Record<string, unknown>>;
+    readonly children?: readonly PipelineNode[];
+}
+interface PipelineConfig {
+    readonly video: readonly PipelineNode[];
+    readonly audio?: PipelineNode;
+}
+interface PipelineStatus {
+    readonly addon: string;
+    readonly slot: PipelineSlot;
+    readonly state: 'initializing' | 'ready' | 'running' | 'error';
+    readonly error?: string;
+    readonly lastRunMs?: number;
+}
+interface StepError {
+    readonly code: string;
+    readonly message: string;
+    readonly childrenSkipped: boolean;
+}
+interface StepResult {
+    readonly addon: string;
+    readonly slot: PipelineSlot;
+    readonly output: DetectorOutput | CropperOutput | ClassifierOutput;
+    readonly parentResultId?: string;
+    readonly resultId: string;
+    readonly inferenceMs: number;
+    readonly preprocessMs: number;
+    readonly totalMs: number;
+    readonly error?: StepError;
+}
+interface PipelineResult {
+    readonly results: readonly StepResult[];
+    readonly totalMs: number;
+    readonly timings: Readonly<Record<string, number>>;
+    readonly frameTimestamp: number;
+}
+
+interface TrackedObjectSummary {
+    readonly trackId: string;
+    readonly class: string;
+    readonly originalClass: string;
+    readonly state: ObjectState;
+    readonly bbox: BoundingBox;
+    readonly velocity: {
+        readonly dx: number;
+        readonly dy: number;
+    };
+    readonly dwellTimeMs: number;
+    readonly inZones: readonly string[];
+    readonly identity?: string;
+    readonly plateText?: string;
+    readonly subClass?: string;
+}
+interface ZoneLiveState {
+    readonly zoneId: string;
+    readonly zoneName: string;
+    readonly occupied: boolean;
+    readonly objectCount: number;
+    readonly objectsByClass: Readonly<Record<string, number>>;
+    readonly trackIds: readonly string[];
+    readonly avgDwellTimeMs: number;
+    readonly totalEntrancesToday: number;
+    readonly totalExitsToday: number;
+    readonly loiteringTracks: readonly string[];
+}
+interface CameraLiveState {
+    readonly deviceId: string;
+    readonly lastFrameTimestamp: number;
+    readonly activeObjects: number;
+    readonly movingObjects: number;
+    readonly stationaryObjects: number;
+    readonly objectCounts: Readonly<Record<string, number>>;
+    readonly tracks: readonly TrackedObjectSummary[];
+    readonly zones: readonly ZoneLiveState[];
+    readonly lastEvent?: DetectionEvent;
+    readonly pipelineStatus: readonly PipelineStatus[];
+    readonly avgPipelineMs: number;
+    readonly currentFps: number;
+}
+
+interface TrackFilter {
+    readonly class?: readonly string[];
+    readonly state?: readonly ObjectState[];
+    readonly inZone?: string;
+    readonly minDwellMs?: number;
+}
+interface TimeRangeOptions {
+    readonly from: number;
+    readonly to: number;
+    readonly resolution: 'minute' | '5min' | 'hour';
+}
+interface ZoneHistoryPoint {
+    readonly timestamp: number;
+    readonly objectCount: number;
+    readonly objectsByClass: Readonly<Record<string, number>>;
+    readonly entrances: number;
+    readonly exits: number;
+}
+interface HeatmapOptions {
+    readonly from: number;
+    readonly to: number;
+    readonly class?: string;
+    readonly resolution: number;
+}
+interface HeatmapData {
+    readonly width: number;
+    readonly height: number;
+    readonly gridSize: number;
+    readonly cells: Float32Array;
+    readonly maxCount: number;
+}
+interface TrackDetail {
+    readonly trackId: string;
+    readonly class: string;
+    readonly originalClass: string;
+    readonly state: ObjectState;
+    readonly firstSeen: number;
+    readonly lastSeen: number;
+    readonly totalDwellMs: number;
+    readonly path: ReadonlyArray<{
+        readonly timestamp: number;
+        readonly bbox: BoundingBox;
+        readonly velocity: {
+            readonly dx: number;
+            readonly dy: number;
+        };
+    }>;
+    readonly identity?: {
+        readonly name: string;
+        readonly confidence: number;
+        readonly matchedAt: number;
+    };
+    readonly plateText?: {
+        readonly text: string;
+        readonly confidence: number;
+        readonly readAt: number;
+    };
+    readonly subClass?: {
+        readonly class: string;
+        readonly confidence: number;
+    };
+    readonly zoneTransitions: ReadonlyArray<{
+        readonly zoneId: string;
+        readonly zoneName: string;
+        readonly entered: number;
+        readonly exited?: number;
+        readonly dwellMs: number;
+    }>;
+    readonly bestSnapshot?: EventSnapshot;
+    readonly events: readonly DetectionEvent[];
+}
+
+type BenchmarkMode = 'single-addon' | 'full-pipeline' | 'compare-runtimes' | 'compare-models';
+type BenchmarkSource = {
+    readonly type: 'reference';
+    readonly images: 'all' | readonly string[];
+} | {
+    readonly type: 'camera';
+    readonly deviceId: string;
+    readonly durationSec: number;
+};
+type BenchmarkExecution = {
+    readonly type: 'local';
+} | {
+    readonly type: 'agent';
+    readonly agentId: string;
+} | {
+    readonly type: 'multi-agent';
+    readonly agentIds: readonly string[];
+} | {
+    readonly type: 'all-agents';
+};
+interface BenchmarkTarget {
+    readonly label: string;
+    readonly addonId: string;
+    readonly config: Readonly<Record<string, unknown>>;
+}
+interface BenchmarkConfig {
+    readonly mode: BenchmarkMode;
+    readonly source: BenchmarkSource;
+    readonly execution: BenchmarkExecution;
+    readonly iterations?: number;
+    readonly warmup?: number;
+    readonly targets: readonly BenchmarkTarget[];
+}
+interface LatencyStats {
+    readonly mean: number;
+    readonly median: number;
+    readonly p95: number;
+    readonly p99: number;
+    readonly min: number;
+    readonly max: number;
+}
+interface ResourceStats {
+    readonly peakMemoryMB: number;
+    readonly avgCpuPercent: number;
+    readonly avgGpuPercent?: number;
+}
+interface AccuracyStats {
+    readonly mAP50?: number;
+    readonly precision?: number;
+    readonly recall?: number;
+}
+interface SystemInfo {
+    readonly os: string;
+    readonly arch: string;
+    readonly cpuModel: string;
+    readonly cpuCores: number;
+    readonly totalMemoryMB: number;
+    readonly gpuModel?: string;
+    readonly pythonVersion?: string;
+    readonly nodeVersion: string;
+}
+interface BenchmarkTargetResult {
+    readonly label: string;
+    readonly addonId: string;
+    readonly config: Readonly<Record<string, unknown>>;
+    readonly latency: LatencyStats;
+    readonly fps: number;
+    readonly accuracy?: AccuracyStats;
+    readonly resources: ResourceStats;
+    readonly stepBreakdown?: Readonly<Record<string, {
+        readonly meanMs: number;
+        readonly percentOfTotal: number;
+    }>>;
+}
+type AgentBenchmarkStatus = 'completed' | 'partial' | 'failed' | 'disconnected';
+interface MultiBenchmarkReport {
+    readonly timestamp: string;
+    readonly source: BenchmarkSource;
+    readonly agents: ReadonlyArray<{
+        readonly agentId: string;
+        readonly status: AgentBenchmarkStatus;
+        readonly systemInfo: SystemInfo;
+        readonly results: readonly BenchmarkTargetResult[];
+        readonly error?: string;
+        readonly completedIterations?: number;
+    }>;
+    readonly leaderboard: ReadonlyArray<{
+        readonly rank: number;
+        readonly agentId: string;
+        readonly label: string;
+        readonly meanMs: number;
+        readonly fps: number;
+        readonly peakMemoryMB: number;
+        readonly accuracy?: AccuracyStats;
+    }>;
+}
+interface GroundTruthAnnotation {
+    readonly class: string;
+    readonly originalClass?: string;
+    readonly bbox: BoundingBox;
+    readonly children?: readonly GroundTruthAnnotation[];
+    readonly identity?: string;
+    readonly plateText?: string;
+    readonly species?: string;
+    readonly vehicleType?: string;
+}
+interface GroundTruth {
+    readonly image: string;
+    readonly annotations: readonly GroundTruthAnnotation[];
+}
+
+interface ConfigFieldBase {
+    readonly key: string;
+    readonly label: string;
+    readonly description?: string;
+    readonly required?: boolean;
+    readonly dependsOn?: Readonly<Record<string, unknown>>;
+}
+interface ConfigTextField extends ConfigFieldBase {
+    readonly type: 'text';
+    readonly placeholder?: string;
+}
+interface ConfigNumberField extends ConfigFieldBase {
+    readonly type: 'number';
+    readonly min?: number;
+    readonly max?: number;
+    readonly step?: number;
+}
+interface ConfigBooleanField extends ConfigFieldBase {
+    readonly type: 'boolean';
+}
+interface ConfigSelectField extends ConfigFieldBase {
+    readonly type: 'select';
+    readonly options: ReadonlyArray<{
+        readonly value: string;
+        readonly label: string;
+    }>;
+}
+interface ConfigSliderField extends ConfigFieldBase {
+    readonly type: 'slider';
+    readonly min: number;
+    readonly max: number;
+    readonly step: number;
+    readonly default: number;
+}
+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[];
+}
+
+interface RouteRequest {
+    readonly params: Readonly<Record<string, string>>;
+    readonly query: Readonly<Record<string, string | string[]>>;
+    readonly headers: Readonly<Record<string, string | undefined>>;
+    readonly body?: unknown;
+}
+interface RouteResponse {
+    status(code: number): RouteResponse;
+    json(data: unknown): void;
+    send(data: string | Buffer): void;
+    sendFile(path: string): void;
+    header(name: string, value: string): RouteResponse;
+}
+type RouteHandler = (req: RouteRequest, res: RouteResponse) => void | Promise<void>;
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+interface IAddonRouter {
+    /** Public route — no auth required */
+    public(method: HttpMethod, path: string, handler: RouteHandler): void;
+    /** Protected route — requires valid JWT or API key */
+    protected(method: HttpMethod, path: string, handler: RouteHandler): void;
+    /** Admin route — requires admin role */
+    admin(method: HttpMethod, path: string, handler: RouteHandler): void;
+    /** Serve static directory */
+    static(urlPath: string, directory: string, options?: {
+        auth?: boolean;
+    }): void;
+    /** Get the base URL prefix for this addon's routes */
+    getBaseUrl(): string;
+}
+
+interface NetworkAddress {
+    readonly host: string;
+    readonly port: number;
+    readonly protocol: 'http' | 'https';
+}
+interface PublicAddress {
+    readonly url: string;
+    readonly provider: string;
+}
+interface INetworkProvider {
+    getLocalAddress(): NetworkAddress;
+    getPublicAddress(): PublicAddress | null;
+    registerRemoteAccess(provider: IRemoteAccessProvider): void;
+    unregisterRemoteAccess(providerId: string): void;
+    onPublicAddressChange(callback: (address: PublicAddress | null) => void): () => void;
+}
+type RemoteAccessStatus = 'connected' | 'connecting' | 'disconnected' | 'error';
+interface IRemoteAccessProvider {
+    readonly id: string;
+    readonly name: string;
+    getPublicUrl(): string | null;
+    getStatus(): RemoteAccessStatus;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    onStatusChange?(callback: (status: RemoteAccessStatus) => void): () => void;
+}
+interface ITurnProvider {
+    readonly id: string;
+    readonly name: string;
+    getCredentials(): Promise<TurnCredentials>;
+    getServers(): TurnServer[];
+}
+interface TurnCredentials {
+    readonly username: string;
+    readonly credential: string;
+    readonly ttl: number;
+}
+interface TurnServer {
+    readonly urls: string;
+    readonly username?: string;
+    readonly credential?: string;
+}
+
+type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'verbose';
+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;
+    child(scope: string): IScopedLogger;
+}
+interface ILogDestination {
+    readonly id: string;
+    readonly name: string;
+    write(level: LogLevel, scope: string, message: string, meta?: unknown): void;
+}
+
+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;
+}
+
+type StorageLocationName = 'data' | 'media' | 'recordings' | 'models' | 'cache' | 'logs';
+interface IStorageBackend {
+    resolve(location: StorageLocationName, ...segments: string[]): string;
+    isAvailable(location: StorageLocationName): boolean;
+    initialize(): Promise<void>;
+    getLocationPath(location: StorageLocationName): string;
+}
+interface IStorageProvider {
+    getLocation(name: string): string;
+    setLocationPath(name: StorageLocationName, absolutePath: string): void;
+}
+
+interface RequiredStep {
+    readonly slot: PipelineSlot;
+    readonly outputClasses: readonly string[];
+    readonly description: string;
+}
+interface AddonManifest {
+    readonly id: string;
+    readonly name: string;
+    readonly version: string;
+    readonly description: string;
+    readonly packageName: string;
+    readonly slot?: PipelineSlot;
+    readonly inputClasses?: readonly string[];
+    readonly outputClasses?: readonly string[];
+    readonly requiredSteps?: readonly RequiredStep[];
+    readonly supportsCustomModels?: boolean;
+    readonly mayRequirePython?: boolean;
+    readonly defaultConfig?: Readonly<Record<string, unknown>>;
+}
+interface AddonLocationPaths {
+    readonly data: string;
+    readonly media: string;
+    readonly models: string;
+    readonly logs: string;
+    readonly cache: string;
+}
+interface AddonContext {
+    readonly addonConfig: Readonly<Record<string, unknown>>;
+    readonly locationPaths: AddonLocationPaths;
+    readonly router?: IAddonRouter;
+    readonly network?: INetworkProvider;
+    readonly logger?: IScopedLogger;
+    readonly eventBus?: IEventBus;
+    readonly storage?: IStorageProvider;
+}
+interface ICamstackAddon {
+    readonly id: string;
+    readonly manifest: AddonManifest;
+    initialize(context: AddonContext): Promise<void>;
+    shutdown(): Promise<void>;
+    getConfigSchema?(): ConfigUISchema;
+}
+interface AddonDeclaration {
+    readonly id: string;
+    readonly entry: string;
+    readonly slot: PipelineSlot;
+}
+interface AddonPackageManifest {
+    readonly addons: readonly AddonDeclaration[];
+}
+
+interface IPipelineSlotProvider {
+    readonly slot: PipelineSlot;
+    readonly inputClasses: readonly string[] | null;
+    readonly outputClasses: readonly string[];
+    readonly requiredSteps?: readonly RequiredStep[];
+    readonly slotPriority: number;
+}
+
+interface IDetectorProvider extends IPipelineSlotProvider {
+    readonly slot: 'detector';
+    detect(frame: FrameInput): Promise<DetectorOutput>;
+}
+
+interface ICropperProvider extends IPipelineSlotProvider {
+    readonly slot: 'cropper';
+    crop(input: CropInput): Promise<CropperOutput>;
+}
+
+interface IClassifierProvider extends IPipelineSlotProvider {
+    readonly slot: 'classifier';
+    classify(input: CropInput): Promise<ClassifierOutput>;
+}
+
+interface IDetectionAddon extends ICamstackAddon, IPipelineSlotProvider {
+    getConfigSchema(): ConfigUISchema;
+    getClassMap(): ClassMapDefinition;
+    getModelCatalog(): ModelCatalogEntry[];
+    getAvailableModels(): DetectionModel[];
+    getActiveLabels(): readonly LabelDefinition[];
+    probe(): Promise<ProbeResult>;
+}
+
+interface IInferenceEngine {
+    readonly runtime: DetectionRuntime;
+    readonly device: DetectionDevice;
+    run(input: Float32Array, inputShape: readonly number[]): Promise<Float32Array>;
+    /** Run inference and return all named output tensors. Used by multi-output models (e.g. YOLO-seg). */
+    runMultiOutput(input: Float32Array, inputShape: readonly number[]): Promise<Record<string, Float32Array>>;
+    dispose(): Promise<void>;
+}
+interface ResolveEngineOptions {
+    readonly runtime: DetectionRuntime | 'auto';
+    readonly backend: string;
+    readonly modelEntry: ModelCatalogEntry;
+    readonly modelsDir: string;
+}
+
+interface IZoneRepository {
+    getByCamera(cameraId: string): Promise<ZoneDefinition[]>;
+    save(zone: ZoneDefinition): Promise<void>;
+    delete(zoneId: string): Promise<void>;
+}
+interface IKnownFaceRepository {
+    getAll(): Promise<KnownFace[]>;
+    findByEmbedding(embedding: Float32Array, threshold: number): Promise<KnownFace | null>;
+    save(face: KnownFace): Promise<void>;
+    addEmbedding(faceId: string, embedding: Float32Array): Promise<void>;
+    delete(faceId: string): Promise<void>;
+}
+interface IKnownPlateRepository {
+    getAll(): Promise<KnownPlate[]>;
+    findByText(text: string): Promise<KnownPlate | null>;
+    save(plate: KnownPlate): Promise<void>;
+    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;
+    readonly path?: string;
+    readonly installedPackages?: readonly string[];
+}
+interface PythonEnvReady {
+    readonly pythonPath: string;
+    readonly venvPath: string;
+    spawn(script: string, args: readonly string[]): ChildProcess;
+}
+interface IPythonEnvironment {
+    probe(): Promise<PythonProbeResult>;
+    ensure(options: {
+        readonly packages: readonly string[];
+    }): Promise<PythonEnvReady>;
+    spawn(script: string, args: readonly string[]): ChildProcess;
+}
+
+interface IPipelineRunner {
+    run(frame: FrameInput, config?: PipelineConfig): Promise<PipelineResult>;
+    runSingle(addonId: string, input: FrameInput | CropInput, config?: Record<string, unknown>): Promise<StepResult>;
+    getStatus(): PipelineStatus[];
+}
+interface ValidationIssue {
+    readonly step?: string;
+    readonly addon?: string;
+    readonly message: string;
+    readonly severity: 'error' | 'warning';
+}
+interface ValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly ValidationIssue[];
+    readonly warnings: readonly ValidationIssue[];
+}
+interface IPipelineValidator {
+    validate(config: PipelineConfig): ValidationResult;
+}
+
+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 };