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",
    /**
     * Addon failed to load (import or initialize). Emitted by the kernel's
     * AddonHealthMonitor only AFTER the boot grace period ends — failures
     * during the first 5 minutes are silently retried without alerting
     * (slow-starting addons must have time to come up). Post-grace, this
     * event is emitted exactly once per failure-streak; AlertCenter
     * consumes it to create a persistent operator-visible alert.
     *
     * Payload: `{ packageName, addonId?, error: { message, stack }, retryCount, nextRetryAt }`.
     */
    AddonLoadFailed = "addon.load-failed",
    /**
     * Addon recovered from a previous failure. Emitted when an addon
     * transitions from `failed` back to `healthy` (typically via the
     * monitor's auto-retry loop, or after manual `addons.retryLoad`).
     * AlertCenter dismisses the corresponding `AddonLoadFailed` alert
     * on this event.
     */
    AddonLoadRecovered = "addon.load-recovered",
    /**
     * Monitor scheduled the next retry for a failed addon. Transient —
     * surfaced to the UI for live-updating the "next retry in Ns"
     * countdown on the Addons page row, NOT persisted as an alert.
     */
    AddonRetryScheduled = "addon.retry-scheduled",
    /**
     * Monitor is attempting to reload a failed addon NOW. UI uses this
     * to show a spinner during the retry attempt. Same transient nature
     * as AddonRetryScheduled.
     */
    AddonRetryAttempting = "addon.retry-attempting",
    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",
    /** Fired by the `local-network` cap when the host's interface set
     *  changes (new IP from DHCP, VPN connect, docker bridge added). */
    LocalNetworkChanged = "network.local.changed",
    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