phytrace_sdk/models/

enums.rs

//! Enumeration types for the PhyTrace UDM.
//!
//! All enums are serialized using snake_case naming convention.

use serde::{Deserialize, Serialize};

// =============================================================================
// Event Classification
// =============================================================================

/// Classification of UDM events.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum EventType {
    // Telemetry events
    /// Periodic telemetry snapshot
    #[default]
    TelemetryPeriodic,
    /// Telemetry triggered by significant change
    TelemetryOnChange,
    /// Full system snapshot
    TelemetrySnapshot,

    // State transition events
    /// Robot state changed
    StateTransition,
    /// Operational mode changed
    ModeChange,

    // Task events
    /// Task started
    TaskStarted,
    /// Task completed successfully
    TaskCompleted,
    /// Task failed
    TaskFailed,
    /// Task cancelled
    TaskCancelled,

    // Navigation events
    /// Navigation goal reached
    GoalReached,
    /// Path blocked, replanning
    PathBlocked,
    /// Rerouting in progress
    Rerouting,

    // Safety events
    /// Safety violation detected
    SafetyViolation,
    /// Emergency stop activated
    EmergencyStop,

    // System events
    /// System startup
    SystemStartup,
    /// System shutdown
    SystemShutdown,
    /// Error occurred
    Error,

    // Custom events
    /// Custom event type (use extensions for details)
    Custom,
}

// =============================================================================
// Source Classification
// =============================================================================

/// Classification of the telemetry source.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum SourceType {
    // Mobile robots
    /// Autonomous Mobile Robot
    #[default]
    Amr,
    /// Automated Guided Vehicle
    Agv,
    /// Autonomous Forklift
    AutonomousForklift,
    /// Delivery Robot
    DeliveryRobot,
    /// Cleaning Robot
    CleaningRobot,
    /// Inspection Robot
    InspectionRobot,
    /// Security Robot
    SecurityRobot,

    // Manipulators
    /// Industrial Robot Arm
    IndustrialArm,
    /// Collaborative Robot (Cobot)
    Cobot,
    /// Mobile Manipulator
    MobileManipulator,

    // Vehicles
    /// Autonomous Vehicle
    AutonomousVehicle,
    /// Electric Vehicle
    ElectricVehicle,
    /// Drone / UAV
    Drone,

    // Other
    /// Humanoid Robot
    Humanoid,
    /// Quadruped Robot
    Quadruped,
    /// Human (for tracking humans in simulation/HRI scenarios)
    Human,
    /// Custom Platform
    Custom,
    /// Simulation Instance
    Simulation,
}

// =============================================================================
// Operational Enums
// =============================================================================

/// Operational mode of the robot.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum OperationalMode {
    /// Fully autonomous operation
    #[default]
    Autonomous,
    /// Manual control (teleoperation)
    Manual,
    /// Semi-autonomous with human oversight
    SemiAutonomous,
    /// Remote teleoperation
    Teleoperated,
    /// Learning/training mode
    Learning,
    /// Maintenance mode
    Maintenance,
    /// Emergency mode
    Emergency,
    /// Idle/standby
    Idle,
}

/// Current operational state of the robot.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum OperationalState {
    /// Powered off
    Off,
    /// Booting up
    Booting,
    /// Ready and waiting
    #[default]
    Ready,
    /// Executing a task
    ExecutingTask,
    /// Navigating to destination
    Navigating,
    /// Performing manipulation
    Manipulating,
    /// Charging
    Charging,
    /// Paused
    Paused,
    /// In error state
    Error,
    /// Emergency stopped
    EmergencyStopped,
    /// Shutting down
    ShuttingDown,
    /// In recovery mode
    Recovering,
}

/// Error severity levels.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ErrorSeverity {
    /// Informational message
    #[default]
    Info,
    /// Warning - operation can continue
    Warning,
    /// Error - operation may be impacted
    Error,
    /// Critical - immediate attention required
    Critical,
    /// Fatal - system cannot continue
    Fatal,
}

// =============================================================================
// Motion Enums
// =============================================================================

/// Current motion state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum MotionState {
    /// Not moving
    #[default]
    Stationary,
    /// Moving at constant velocity
    Moving,
    /// Accelerating
    Accelerating,
    /// Decelerating
    Decelerating,
    /// Rotating in place
    Rotating,
    /// Reversing
    Reversing,
}

// =============================================================================
// Power Enums
// =============================================================================

/// Battery chemistry type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum BatteryChemistry {
    /// Lithium Iron Phosphate
    #[default]
    LiFePo4,
    /// Lithium Nickel Manganese Cobalt
    Nmc,
    /// Lithium Cobalt Oxide
    LiCoO2,
    /// Lithium Manganese Oxide
    Lmo,
    /// Lead Acid
    LeadAcid,
    /// Nickel Metal Hydride
    NiMh,
    /// Solid State
    SolidState,
    /// Other/Unknown
    Other,
}

/// Charging state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ChargingState {
    /// Not connected to charger
    #[default]
    NotCharging,
    /// Connected, preparing to charge
    Preparing,
    /// Actively charging
    Charging,
    /// Charge complete, still connected
    Complete,
    /// Charging error
    Error,
}

/// Power source type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum PowerSource {
    /// Running on battery
    #[default]
    Battery,
    /// Connected to external power
    External,
    /// Solar powered
    Solar,
    /// Fuel cell
    FuelCell,
    /// Hybrid
    Hybrid,
}

// =============================================================================
// Safety Enums
// =============================================================================

/// Overall safety state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum SafetyState {
    /// Normal operation
    #[default]
    Normal,
    /// Warning - proceed with caution
    Warning,
    /// Protective stop active
    ProtectiveStop,
    /// Emergency stop active
    EmergencyStop,
    /// Safety interlock triggered
    SafetyInterlock,
    /// Reduced speed mode
    ReducedSpeed,
}

/// Emergency stop type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum EStopType {
    /// Software-triggered e-stop
    #[default]
    Software,
    /// Hardware button pressed
    Hardware,
    /// Remote e-stop signal
    Remote,
    /// Automatic safety system
    Automatic,
}

/// Safety zone type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum SafetyZoneType {
    /// Warning zone - reduce speed
    #[default]
    Warning,
    /// Slowdown zone - significantly reduce speed
    Slowdown,
    /// Stop zone - immediate stop required
    Stop,
    /// Restricted zone - entry prohibited
    Restricted,
    /// Collaborative zone - human-robot interaction area
    Collaborative,
}

/// Violation severity.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ViolationSeverity {
    /// Low severity - logged only
    #[default]
    Low,
    /// Medium severity - warning issued
    Medium,
    /// High severity - action required
    High,
    /// Critical - immediate stop
    Critical,
}

/// Types of safety violations.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ViolationType {
    /// Speed limit exceeded
    #[default]
    SpeedExceeded,
    /// Entered restricted zone
    ZoneViolation,
    /// Too close to obstacle
    ProximityViolation,
    /// Collision detected
    CollisionDetected,
    /// Stability issue
    StabilityViolation,
    /// Force/torque limit exceeded
    ForceLimitExceeded,
    /// Communication loss
    CommunicationLoss,
    /// Sensor failure
    SensorFailure,
}

// =============================================================================
// Navigation Enums
// =============================================================================

/// Localization quality.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum LocalizationQuality {
    /// Excellent localization
    Excellent,
    /// Good localization
    #[default]
    Good,
    /// Fair localization
    Fair,
    /// Poor localization
    Poor,
    /// Lost / unknown position
    Lost,
}

/// Path planning state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum PathState {
    /// No path planned
    #[default]
    None,
    /// Path being computed
    Planning,
    /// Valid path available
    Valid,
    /// Executing current path
    Executing,
    /// Path blocked, replanning
    Blocked,
    /// Path completed
    Completed,
    /// Path planning failed
    Failed,
}

/// Obstacle classification.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ObstacleType {
    /// Unknown obstacle
    #[default]
    Unknown,
    /// Static obstacle (wall, furniture)
    Static,
    /// Dynamic obstacle (person, other robot)
    Dynamic,
    /// Human detected
    Human,
    /// Another robot
    Robot,
    /// Vehicle
    Vehicle,
    /// Temporary obstacle
    Temporary,
}

// =============================================================================
// Perception Enums
// =============================================================================

/// Sensor status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum SensorStatus {
    /// Sensor operating normally
    #[default]
    Ok,
    /// Sensor degraded
    Degraded,
    /// Sensor error
    Error,
    /// Sensor offline
    Offline,
    /// Sensor calibrating
    Calibrating,
}

/// GPS fix type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum GpsFixType {
    /// No fix
    #[default]
    NoFix,
    /// 2D fix
    Fix2d,
    /// 3D fix
    Fix3d,
    /// Differential GPS
    Dgps,
    /// RTK float
    RtkFloat,
    /// RTK fixed
    RtkFixed,
}

/// Detection classification confidence.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum DetectionConfidence {
    /// Low confidence
    Low,
    /// Medium confidence
    #[default]
    Medium,
    /// High confidence
    High,
    /// Very high confidence
    VeryHigh,
}

// =============================================================================
// Actuator Enums
// =============================================================================

/// Motor status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum MotorStatus {
    /// Motor OK
    #[default]
    Ok,
    /// Motor overheating
    Overheating,
    /// Motor overcurrent
    Overcurrent,
    /// Motor error
    Error,
    /// Motor disabled
    Disabled,
}

/// Gripper state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum GripperState {
    /// Gripper fully open
    #[default]
    Open,
    /// Gripper fully closed
    Closed,
    /// Gripper partially closed / holding
    Holding,
    /// Gripper moving
    Moving,
    /// Gripper error
    Error,
}

/// Lift position state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum LiftState {
    /// Lift at bottom
    #[default]
    Lowered,
    /// Lift at top
    Raised,
    /// Lift moving
    Moving,
    /// Lift at custom position
    Intermediate,
    /// Lift error
    Error,
}

// =============================================================================
// Communication Enums
// =============================================================================

/// Network connection type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum NetworkType {
    /// WiFi connection
    #[default]
    Wifi,
    /// Ethernet connection
    Ethernet,
    /// Cellular connection
    Cellular,
    /// LoRa connection
    Lora,
    /// Bluetooth
    Bluetooth,
    /// Mesh network
    Mesh,
}

/// Connection status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ConnectionStatus {
    /// Connected
    #[default]
    Connected,
    /// Disconnected
    Disconnected,
    /// Connecting
    Connecting,
    /// Connection error
    Error,
}

/// Cellular generation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum CellularGeneration {
    /// 3G
    #[serde(rename = "3g")]
    Gen3,
    /// 4G LTE
    #[default]
    #[serde(rename = "4g")]
    Gen4,
    /// 5G
    #[serde(rename = "5g")]
    Gen5,
}

// =============================================================================
// Payload Enums
// =============================================================================

/// Load status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum LoadStatus {
    /// No load
    #[default]
    Empty,
    /// Partially loaded
    PartialLoad,
    /// Fully loaded
    FullLoad,
    /// Overloaded (warning)
    Overloaded,
}

// =============================================================================
// Manipulation Enums
// =============================================================================

/// Arm state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ArmState {
    /// Arm at home position
    #[default]
    Home,
    /// Arm moving
    Moving,
    /// Arm at target position
    AtTarget,
    /// Arm performing grasp
    Grasping,
    /// Arm placing object
    Placing,
    /// Arm in collision avoidance
    Avoiding,
    /// Arm error
    Error,
}

/// Grasp phase.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum GraspPhase {
    /// Not grasping
    #[default]
    Idle,
    /// Approaching target
    Approaching,
    /// Pre-grasp positioning
    PreGrasp,
    /// Closing gripper
    Closing,
    /// Grasp secured
    Secured,
    /// Lifting object
    Lifting,
    /// Grasp failed
    Failed,
}

/// Control mode for manipulation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ManipulationControlMode {
    /// Position control
    #[default]
    Position,
    /// Velocity control
    Velocity,
    /// Force/torque control
    Force,
    /// Impedance control
    Impedance,
    /// Hybrid control
    Hybrid,
}

// =============================================================================
// HRI (Human-Robot Interaction) Enums
// =============================================================================

/// Human-robot interaction state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum InteractionState {
    /// No interaction
    #[default]
    None,
    /// Human detected nearby
    HumanDetected,
    /// Awaiting human input
    AwaitingInput,
    /// Active interaction
    Interacting,
    /// Handover in progress
    Handover,
    /// Following human
    Following,
}

/// Handover state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum HandoverState {
    /// No handover
    #[default]
    None,
    /// Offering object to human
    Offering,
    /// Receiving object from human
    Receiving,
    /// Handover complete
    Complete,
    /// Handover failed/aborted
    Aborted,
}

/// Human activity classification.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum HumanActivity {
    /// Unknown activity
    #[default]
    Unknown,
    /// Standing still
    Standing,
    /// Walking
    Walking,
    /// Running
    Running,
    /// Sitting
    Sitting,
    /// Working (e.g., at a station)
    Working,
    /// Gesturing
    Gesturing,
}

// =============================================================================
// Coordination Enums
// =============================================================================

/// Fleet coordination role.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum FleetRole {
    /// Independent operation
    #[default]
    Independent,
    /// Fleet leader
    Leader,
    /// Fleet follower
    Follower,
    /// Swarm member
    SwarmMember,
    /// Coordinator node
    Coordinator,
}

/// Formation type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum FormationType {
    /// No formation
    #[default]
    None,
    /// Line formation
    Line,
    /// Column formation
    Column,
    /// V formation
    Vee,
    /// Diamond formation
    Diamond,
    /// Circular formation
    Circle,
    /// Custom formation
    Custom,
}

/// Traffic management priority.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum TrafficPriority {
    /// Low priority
    Low,
    /// Normal priority
    #[default]
    Normal,
    /// High priority
    High,
    /// Emergency priority
    Emergency,
}

// =============================================================================
// Simulation Enums
// =============================================================================

/// Simulator type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum SimulatorType {
    /// Gazebo simulator
    #[default]
    Gazebo,
    /// NVIDIA Isaac Sim
    IsaacSim,
    /// Unity-based simulator
    Unity,
    /// Unreal Engine simulator
    Unreal,
    /// Webots simulator
    Webots,
    /// Custom Python simulator
    CustomPython,
    /// Other simulator
    Other,
}

/// Simulation fidelity level.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum SimulationFidelity {
    /// Low fidelity (fast, less accurate)
    Low,
    /// Medium fidelity
    #[default]
    Medium,
    /// High fidelity (slow, more accurate)
    High,
    /// Physics-accurate simulation
    PhysicsAccurate,
}

// =============================================================================
// Thermal Enums
// =============================================================================

/// Overall thermal state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ThermalState {
    /// Normal temperature
    #[default]
    Normal,
    /// Elevated temperature (warning)
    Elevated,
    /// High temperature (throttling)
    High,
    /// Critical temperature (shutdown imminent)
    Critical,
    /// Cold (below optimal)
    Cold,
}

/// Cooling system mode.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum CoolingMode {
    /// Passive cooling
    #[default]
    Passive,
    /// Active cooling (fans)
    Active,
    /// Liquid cooling
    Liquid,
    /// Maximum cooling
    Maximum,
}

// =============================================================================
// Audio Enums
// =============================================================================

/// Sound detection classification.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum SoundType {
    /// Unknown sound
    #[default]
    Unknown,
    /// Speech detected
    Speech,
    /// Alarm/siren
    Alarm,
    /// Impact/collision sound
    Impact,
    /// Machine noise
    Machine,
    /// Emergency sound
    Emergency,
}

// =============================================================================
// Environment Interaction Enums
// =============================================================================

/// Door state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum DoorState {
    /// Door open
    Open,
    /// Door closed
    #[default]
    Closed,
    /// Door opening
    Opening,
    /// Door closing
    Closing,
    /// Door locked
    Locked,
    /// Door error
    Error,
}

/// Elevator state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ElevatorState {
    /// Elevator idle
    #[default]
    Idle,
    /// Elevator called
    Called,
    /// Elevator arriving
    Arriving,
    /// Doors open, ready to board
    DoorsOpen,
    /// Robot boarding
    Boarding,
    /// In transit
    InTransit,
    /// Arrived at floor
    Arrived,
}

/// Charging station state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ChargingStationState {
    /// Station available
    #[default]
    Available,
    /// Station occupied
    Occupied,
    /// Station out of service
    OutOfService,
    /// Station reserved
    Reserved,
}

// =============================================================================
// Compliance Enums
// =============================================================================

/// Certification status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum CertificationStatus {
    /// Not certified
    #[default]
    NotCertified,
    /// Certification pending
    Pending,
    /// Certified
    Certified,
    /// Certification expired
    Expired,
}

/// Functional safety level (ISO 13849 / IEC 62443).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum SafetyIntegrityLevel {
    /// No safety requirement
    #[default]
    None,
    /// Performance Level a / SIL 1
    PlA,
    /// Performance Level b
    PlB,
    /// Performance Level c / SIL 2
    PlC,
    /// Performance Level d / SIL 3
    PlD,
    /// Performance Level e / SIL 4
    PlE,
}

// =============================================================================
// AI / ML Enums
// =============================================================================

/// AI model type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ModelType {
    /// Object detection model
    #[default]
    ObjectDetection,
    /// Semantic segmentation
    SemanticSegmentation,
    /// Instance segmentation
    InstanceSegmentation,
    /// Pose estimation
    PoseEstimation,
    /// Depth estimation
    DepthEstimation,
    /// Navigation/planning
    Navigation,
    /// Anomaly detection
    AnomalyDetection,
    /// Speech recognition
    SpeechRecognition,
    /// Natural language understanding
    Nlu,
    /// Custom model
    Custom,
}

/// AI inference device.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum InferenceDevice {
    /// CPU inference
    #[default]
    Cpu,
    /// GPU inference
    Gpu,
    /// NPU/TPU inference
    Npu,
    /// Edge TPU
    EdgeTpu,
    /// FPGA
    Fpga,
}

/// Anomaly severity.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum AnomalySeverity {
    /// Low severity anomaly
    #[default]
    Low,
    /// Medium severity
    Medium,
    /// High severity
    High,
    /// Critical anomaly
    Critical,
}

// =============================================================================
// Maintenance Enums
// =============================================================================

/// Component health status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ComponentHealth {
    /// Component healthy
    #[default]
    Healthy,
    /// Component degraded
    Degraded,
    /// Component needs attention
    NeedsAttention,
    /// Component failed
    Failed,
    /// Component status unknown
    Unknown,
}

/// Maintenance urgency.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum MaintenanceUrgency {
    /// No maintenance needed
    #[default]
    None,
    /// Routine maintenance
    Routine,
    /// Soon - schedule maintenance
    Soon,
    /// Urgent - immediate attention
    Urgent,
    /// Critical - stop operation
    Critical,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_event_type_serialization() {
        let event_type = EventType::TelemetryPeriodic;
        let json = serde_json::to_string(&event_type).unwrap();
        assert_eq!(json, "\"telemetry_periodic\"");

        let deserialized: EventType = serde_json::from_str(&json).unwrap();
        assert_eq!(deserialized, event_type);
    }

    #[test]
    fn test_source_type_serialization() {
        let source_type = SourceType::Amr;
        let json = serde_json::to_string(&source_type).unwrap();
        assert_eq!(json, "\"amr\"");
    }

    #[test]
    fn test_default_values() {
        assert_eq!(EventType::default(), EventType::TelemetryPeriodic);
        assert_eq!(SourceType::default(), SourceType::Amr);
        assert_eq!(OperationalMode::default(), OperationalMode::Autonomous);
        assert_eq!(SafetyState::default(), SafetyState::Normal);
    }
}