@camstack/types 0.1.14 → 0.1.15

package/dist/enums/event-category.d.ts

@@ -0,0 +1,327 @@
+export declare enum EventCategory {
+    SystemBoot = "system.boot",
+    SystemAddonsReady = "system.addons-ready",
+    SystemRestarting = "system.restarting",
+    /**
+     * Readiness transition for a capability provider. Every producer emits
+     * this event on `onInitialize` completion, `onDestroy`, and
+     * `$node.reconnect`; every consumer that needs to gate on a cross-process
+     * cap subscribes via the kernel's readiness module (`awaitReady` /
+     * `onReadyState`) instead of polling. Payload is
+     * `SystemReadyStatePayload` — see event-bus.ts.
+     */
+    SystemReadyState = "system.ready-state",
+    AddonStarted = "addon.started",
+    AddonStopped = "addon.stopped",
+    AddonRestarted = "addon.restarted",
+    AddonUpdated = "addon.updated",
+    AddonInstalled = "addon.installed",
+    AddonUninstalled = "addon.uninstalled",
+    AddonCrashed = "addon.crashed",
+    AddonError = "addon.error",
+    AddonPageReady = "addon.page-ready",
+    AddonWidgetReady = "addon.widget-ready",
+    DeviceRegistered = "device.registered",
+    DeviceUnregistered = "device.unregistered",
+    DeviceEnabled = "device.enabled",
+    DeviceDisabled = "device.disabled",
+    DeviceSettingsUpdated = "device.settings-updated",
+    /**
+     * Emitted when the set of native capability providers bound to a device
+     * changes — e.g. an addon registers a new native cap via
+     * `DeviceContext.registerNativeCap`, or all native bindings for a device
+     * are cleared on removal. Hub consumers re-resolve device-proxy routes
+     * when this fires.
+     */
+    DeviceBindingsChanged = "device.bindings-changed",
+    /**
+     * Emitted when the operator-organisational meta surface changes
+     * (`name` / `location` / `disabled`). Payload: `{deviceId, field,
+     * value}`. Live consumers (UI device list, alert center) react
+     * without polling. Distinct from `DeviceSettingsUpdated` which
+     * fires on hardware-config changes (host/port/credentials/etc).
+     */
+    DeviceMetaChanged = "device.meta-changed",
+    /**
+     * Emitted by DeviceStreamWiringService after a successful
+     * `stream-broker.registerDeviceStreams` call. Payload includes
+     * deviceId — consumers look up the full registered device info via
+     * `brokerManager.getRegisteredDevice(deviceId)`.
+     *
+     * Replaces the legacy `StreamRouterService.onDeviceRegistered` callback.
+     */
+    DeviceStreamsRegistered = "device.streams-registered",
+    IntegrationEnabled = "integration.enabled",
+    IntegrationDisabled = "integration.disabled",
+    IntegrationDeleted = "integration.deleted",
+    ProviderStarted = "provider.started",
+    ProviderStopped = "provider.stopped",
+    ProcessCrashed = "process.crashed",
+    ProcessRestartScheduled = "process.restart_scheduled",
+    ProcessRestarted = "process.restarted",
+    RecordingStarted = "recording.started",
+    RecordingStopped = "recording.stopped",
+    RecordingError = "recording.error",
+    RecordingHealthDegraded = "recording.health.degraded",
+    RecordingStorageCritical = "recording.storage.critical",
+    RecordingSegmentWritten = "recording.segment.written",
+    RecordingPolicyFallback = "recording.policy.fallback",
+    RecordingRetentionCompleted = "recording.retention.completed",
+    DetectionEvent = "detection.event",
+    SessionTrackNew = "session.track.new",
+    SessionTrackExpired = "session.track.expired",
+    BenchmarkProgress = "benchmark.progress",
+    PlatformProbePhase = "platform-probe.phase",
+    PipelineProgress = "pipeline.progress",
+    /** Per-frame execution trace emitted by the pipeline executor for live observability. */
+    PipelineTrace = "pipeline.trace",
+    /**
+     * Raw inference output emitted by `addon-pipeline-runner` after running the
+     * detection pipeline on a frame. Carries the `FrameResult` (with
+     * `detections[]`, `width`/`height`, timing debug) — never the frame
+     * buffer itself. Hub-side consumers (analysis pipeline, class filters,
+     * notifications) subscribe to this and re-emit `detection.result` after
+     * post-processing.
+     */
+    PipelineInferenceResult = "pipeline.inference-result",
+    /**
+     * Camera lifecycle event emitted by `addon-pipeline-orchestrator` when it
+     * assigns or unassigns a camera to/from an agent. Carries no frame data;
+     * pure observability for UI dashboards and metrics consumers.
+     */
+    PipelineCameraAssigned = "pipeline.camera-assigned",
+    PipelineCameraUnassigned = "pipeline.camera-unassigned",
+    /**
+     * Per-camera pipeline config was mutated by the orchestrator
+     * (3-level settings change via `setAgentAddonDefaults` /
+     * `setCameraStepToggle` / `setCameraPipelineForAgent` or a
+     * pipeline-scoped `applyDeviceSettingsPatch`). Orchestrator
+     * subscribes to its own emission to hot-reload the assigned runner
+     * via `attachCamera` so the next frame executes against the new
+     * engine/steps without waiting for a rebalance or the next
+     * `DeviceStreamsRegistered` cycle.
+     */
+    PipelineCameraUpdated = "pipeline.camera-updated",
+    /**
+     * Periodic snapshot of per-node pipeline-runner load
+     * (`RunnerLocalLoad`). Emitted ~1Hz by every runner so UI dashboards
+     * subscribe instead of polling `pipelineRunner.getLocalLoad`.
+     * `nodeId` carried in the payload + on `event.source.nodeId`.
+     */
+    PipelineRunnerLoadSnapshot = "pipeline.runner-load-snapshot",
+    /**
+     * Periodic snapshot of per-camera pipeline metrics (`CameraMetrics`
+     * + `deviceId` + `nodeId`). Emitted ~1Hz by every runner for each
+     * attached camera. UI subscribes to drive overlay phase / fps /
+     * inference time without polling `getCameraMetrics`.
+     */
+    PipelineCameraMetricsSnapshot = "pipeline.camera-metrics-snapshot",
+    /**
+     * Periodic snapshot of stream-broker per-broker statistics (input
+     * fps, decoded fps, bitrate, codec). Emitted ~1Hz by every
+     * stream-broker process for each active broker so the UI can drive
+     * the Stream / Cluster dashboards without polling
+     * `streamBroker.listAllProfileSlots` and friends.
+     */
+    StreamBrokerMetricsSnapshot = "stream-broker.metrics-snapshot",
+    /**
+     * Cap event fired by `stream-broker` when a profile slot enters
+     * "demanded" state — a cam stream has been assigned and at least one
+     * consumer (RTSP restream, decoded subscriber, WebRTC session, …) is
+     * present. Camera-provider addons (Reolink Baichuan push, …)
+     * subscribe to this category to start their underlying transport
+     * lazily. Payload: `{ deviceId, camStreamId, profile }`.
+     */
+    StreamBrokerOnCamStreamDemand = "stream-broker.onCamStreamDemand",
+    /**
+     * Cap event fired by `stream-broker` when the last consumer leaves a
+     * previously-demanded cam stream. Providers tear down their
+     * underlying transport on receipt. Payload: `{ deviceId, camStreamId }`.
+     */
+    StreamBrokerOnCamStreamIdle = "stream-broker.onCamStreamIdle",
+    /**
+     * Cap event fired by `stream-broker` when a broker fails to dial a
+     * managed-loopback source (today: `pull-rfc4571`) and the publisher
+     * needs to refresh the cached URL. Mirrors Scrypted's
+     * `ensureRfcServer` self-heal pattern: the lib's TCP server
+     * idle-tears-down on its own schedule, so a re-publish with a fresh
+     * `host:port` is the only way to keep the broker dialable. Camera
+     * providers (Reolink Baichuan native, …) subscribe and respond by
+     * re-running their publish pipeline.
+     * Payload: `{ deviceId, camStreamId, brokerId }`.
+     */
+    StreamBrokerOnRequestStreamSourceRefresh = "stream-broker.onRequestStreamSourceRefresh",
+    /**
+     * Generic per-device runtime-state change. Fired by `device-manager`
+     * whenever a persisted slice in any cap's `runtimeState` shape
+     * mutates. Payload: `{deviceId, capName, slice}`. Subscribers are
+     * the `deviceState` cap router (cross-process listeners) and the
+     * deviceProxy reactive bindings (`device.state.<capName>.value`).
+     * Cap-specific events (`battery.onStatusChanged`, …) still fire
+     * — they're authoritative for callers that want a typed payload
+     * without filtering on `capName`.
+     */
+    DeviceStateChanged = "device.state-changed",
+    /**
+     * Cap event fired by every device that registers the `battery`
+     * capability. Mirrors the cap definition's `onStatusChanged`. Carries
+     * `{ deviceId, status: BatteryStatus }`. Subscribers (alert center,
+     * snapshot wrapper, UI) react to charge/sleep transitions without
+     * polling `batteryCapability.getStatus`.
+     */
+    BatteryOnStatusChanged = "battery.onStatusChanged",
+    /**
+     * Cap event fired by every device that registers the `doorbell`
+     * capability. Mirrors `doorbellCapability.events.onPressed`. Carries
+     * `{ deviceId, timestamp }`. Operators consuming the UI subscribe
+     * here to render transient ring toasts and a "Recent presses" row
+     * on the device detail page.
+     */
+    DoorbellOnPressed = "doorbell.onPressed",
+    /**
+     * Periodic snapshot of the per-node detection-pipeline engine
+     * registry (loaded engines, models resident, in-use cameras, idle
+     * TTL). Emitted ~0.2Hz (every 5 s) by every detection-pipeline
+     * process. The Engines tab subscribes to drive its inventory view
+     * without polling `pipelineExecutor.listLoadedEngines`.
+     */
+    PipelineEngineMetricsSnapshot = "pipeline.engine-metrics-snapshot",
+    /**
+     * Cluster topology snapshot. Carries the same payload returned by
+     * `nodes.topology` (every reachable node + addons + processes).
+     * Emitted by the hub on any agent / addon lifecycle change
+     * (debounced) plus a periodic safety net. Replaces UI polling on
+     * `nodes.topology` — admin-ui dashboards subscribe to drive the
+     * cluster view directly from the event payload.
+     */
+    ClusterTopologySnapshot = "cluster.topology-snapshot",
+    /**
+     * Periodic per-node system metrics snapshot (CPU / memory / GPU /
+     * disk / network). Emitted ~0.2 Hz by the metrics-provider addon
+     * for each node. Drives the dashboard SystemStatus / ProcessResources
+     * widgets without polling `metricsProvider.getCurrent`.
+     */
+    MetricsNodeResourcesSnapshot = "metrics.node-resources-snapshot",
+    /**
+     * Periodic per-node process-tree snapshot (camstack-related pids
+     * with ghost / managed / root classification). Emitted ~0.2 Hz by
+     * the metrics-provider addon. Drives the Cluster → Processes tab
+     * without polling `metricsProvider.listNodeProcesses`.
+     */
+    MetricsNodeProcessesSnapshot = "metrics.node-processes-snapshot",
+    /**
+     * Capability binding change event emitted by `addon-pipeline-orchestrator`
+     * when a user changes which addon implements a cap on a node. Subscribed
+     * by every kernel process to update its local `preferredProviderRegistry`
+     * so future capability lookups respect the new binding.
+     */
+    /**
+     * A capability binding was changed for a node — addon X now provides
+     * capability `cap` on node `nodeId`. Lives under the generic
+     * `capability.*` namespace because capability bindings are a kernel-
+     * level concept used by many addons, not strictly pipeline-scoped.
+     */
+    CapabilityBindingChanged = "capability.binding-changed",
+    ModelDownloadProgress = "model.download.progress",
+    AgentRegistered = "agent.registered",
+    AgentUnregistered = "agent.unregistered",
+    AgentOnline = "agent.online",
+    AgentOffline = "agent.offline",
+    /** Forked worker process (e.g. hub/pipeline) connected to the broker. */
+    WorkerOnline = "worker.online",
+    /** Forked worker process disconnected from the broker. */
+    WorkerOffline = "worker.offline",
+    AgentTaskDispatched = "agent.task.dispatched",
+    AgentTaskAssigned = "agent.task.assigned",
+    AgentTrpcConnected = "agent.trpc.connected",
+    AgentWsConnected = "agent.ws.connected",
+    AgentWsDisconnected = "agent.ws.disconnected",
+    AgentBackupActivated = "agent.backup.activated",
+    OrchestrationSettingsUpdated = "orchestration.settings-updated",
+    /**
+     * Per-agent hwaccel preference changed (user override set, cleared, or
+     * re-probed). Observability event — decoders pull the current pref at
+     * `createSession`, so running sessions keep their current backend until
+     * they rotate naturally (camera add/remove, stream restart). Future
+     * work can wire a listener in stream-broker that force-rotates live
+     * sessions; for now this event powers logs + admin-UI toast feedback.
+     */
+    PipelineAgentHwaccelChanged = "pipeline.agent-hwaccel-changed",
+    MotionAnalysis = "detection.motion-analysis",
+    /** All raw motion zones from CCL before minArea filter — for UI debug overlay. */
+    MotionZonesRaw = "detection.motion-zones-raw",
+    /**
+     * Per-camera motion phase transition (`watching ↔ active`) emitted
+     * by the runner. Mirrors the `motion.onMotionChanged` cap event
+     * surface — payload `MotionOnMotionChangedPayload` carries
+     * `{deviceId, detected, timestamp, source, regions?}`. Subscribers
+     * include addons that need to react to motion state without
+     * polling the runtime-state mirror.
+     */
+    MotionOnMotionChanged = "motion.on-motion-changed",
+    DetectionResult = "detection.result",
+    DetectionRaw = "detection.raw",
+    DetectionCameraNative = "detection.camera-native",
+    /**
+     * Canonical per-chunk live audio pipeline output. Payload is
+     * `PipelineAudioInferenceResultPayload` carrying a full `AudioResult`
+     * (level + detections + debug). Lives on the pipeline.* namespace
+     * alongside `pipeline.inference-result` (video) for symmetry.
+     */
+    PipelineAudioInferenceResult = "pipeline.audio-inference-result",
+    DetectionPhaseTransition = "detection.phase-transition",
+    ProviderMotion = "provider.motion",
+    ProviderDetection = "provider.detection",
+    EnrichmentEmbeddingStored = "enrichment.embedding.stored",
+    EnrichmentSceneStateChanged = "enrichment.scene.state-changed",
+    EnrichmentActivitySummary = "enrichment.activity.summary",
+    PipelineAnalyticsTrackStarted = "pipeline-analytics.track-started",
+    PipelineAnalyticsTrackEnded = "pipeline-analytics.track-ended",
+    PipelineAnalyticsDetectionEvent = "pipeline-analytics.detection-event",
+    PipelineAnalyticsFrameTracked = "pipeline-analytics.frame-tracked",
+    FrigateLiveEvent = "frigate.live-event",
+    CameraStreamsProfileSlotsChanged = "camera-streams.onProfileSlotsChanged",
+    /**
+     * Stream-broker health watchdog. Per-broker (deviceId/profile) emission.
+     * `stream.offline` fires after STREAM_STALE_TIMEOUT_MS without an encoded
+     * packet on an active broker. `stream.online` fires on first packet
+     * after a stale gap (or on initial first packet). Payload includes
+     * the assigned camStreamId as `profileKey`.
+     */
+    StreamOnline = "stream.online",
+    StreamOffline = "stream.offline",
+    NetworkTunnelStarted = "network.tunnel.started",
+    NetworkTunnelStopped = "network.tunnel.stopped",
+    BackupCompleted = "backup.completed",
+    BackupRestored = "backup.restored",
+    NotificationDispatched = "notification.dispatched",
+    NotificationFailed = "notification.failed",
+    DeviceUpdated = "device.updated",
+    /**
+     * Transport-level connectivity. Emitted by the device driver when
+     * the underlying control socket actually connects / disconnects
+     * (Baichuan TCP, ONVIF probe response, RTSP DESCRIBE, …) — NOT for
+     * power-state transitions on a battery camera. For battery wake /
+     * doze cycles see `DeviceAwake` / `DeviceSleeping`.
+     */
+    DeviceOnline = "device.online",
+    /**
+     * Stream-broker watchdog — emitted when no encoded packet has been
+     * received for STREAM_STALE_TIMEOUT_MS on an active broker (rtsp or
+     * push). Paired with DeviceOnline which fires on first packet after
+     * a stale gap. Payload: DeviceStreamHealthPayload.
+     */
+    DeviceOffline = "device.offline",
+    /**
+     * Battery cam woke up — physical power-state transition reported
+     * by the device firmware. Distinct from `DeviceOnline` so a UI panel
+     * watching power state doesn't flap on every UDP socket reconnect.
+     */
+    DeviceAwake = "device.awake",
+    /**
+     * Battery cam went to sleep. See `DeviceAwake`.
+     */
+    DeviceSleeping = "device.sleeping",
+    RetentionCleanup = "retention.cleanup"
+}
+//# sourceMappingURL=event-category.d.ts.map

package/dist/enums/event-category.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-category.d.ts","sourceRoot":"","sources":["../../src/enums/event-category.ts"],"names":[],"mappings":"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"}

package/dist/enums/event-source-type.d.ts

@@ -0,0 +1,8 @@
+export declare enum EventSourceType {
+    Addon = "addon",
+    Core = "core",
+    Device = "device",
+    Provider = "provider",
+    System = "system"
+}
+//# sourceMappingURL=event-source-type.d.ts.map

package/dist/enums/event-source-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-source-type.d.ts","sourceRoot":"","sources":["../../src/enums/event-source-type.ts"],"names":[],"mappings":"AAAA,oBAAY,eAAe;IACzB,KAAK,UAAU;IACf,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,MAAM,WAAW;CAClB"}

package/dist/enums/index.d.ts

@@ -0,0 +1,3 @@
+export { EventCategory } from './event-category.js';
+export { EventSourceType } from './event-source-type.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/enums/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/enums/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA"}