Enum Severity 

#[repr(u8)]
pub enum Severity {
    Error = 69,
    Warning = 87,
    Critical = 67,
    Blocked = 66,
    Help = 72,
    Success = 83,
    Completed = 75,
    Info = 73,
    Trace = 84,
}

Diagnostic severity level (single-character prefix for 4-part codes)

Each severity gets a single-character prefix: SEVERITY.COMPONENT.PRIMARY.SEQUENCE

Available Severities

Severity	Char	Priority	Meaning
Error	E	8	Operation failed
Blocked	B	7	Execution blocked/waiting
Critical	C	6	Severe issue requiring attention
Warning	W	5	Potential issue
Help	H	4	Helpful suggestion
Success	S	3	Operation succeeded
Completed	K	2	Task/phase completed
Info	I	1	Informational events
Trace	T	0	Execution traces

Variants

Error = 69

Error (E) - Operation failed

Warning = 87

Warning (W) - Potential issue or caveat

Critical = 67

Critical (C) - Severe issue requiring attention

Blocked = 66

Blocked (B) - Execution blocked/waiting

Help = 72

Help (H) - Helpful suggestion or recommendation

Success = 83

Success (S) - Operation succeeded

Completed = 75

Completed (K) - Task or phase completed

Info = 73

Info (I) - General informational events

Trace = 84

Trace (T) - Execution traces and instrumentation

Implementations

impl Severity

pub const fn as_char(self) -> char

Get the single-character code (E, W, C, B, S, K, I, T)

pub const fn as_str(self) -> &'static str

Get the full name as a string slice (e.g., “Error”, “Warning”)

pub const fn description(self) -> &'static str

Get a human-readable description of this severity level

pub const fn priority(self) -> u8

Get the priority level (0-8, higher = more severe)

Priority Scale:

• 0-1: Diagnostic (Trace, Info)
• 2-3: Positive (Completed, Success)
• 4: Suggestions (Help)
• 5-6: Issues (Warning, Critical)
• 7-8: Blocking (Blocked, Error)

pub const fn is_blocking(self) -> bool

Check if this severity blocks execution

Returns true only for Error and Blocked. Critical is a severe warning but does NOT block.

pub const fn is_positive(self) -> bool

Check if this is a positive outcome (Success/Completed)

pub const fn is_negative(self) -> bool

Check if this is a negative outcome (Error/Warning/Critical/Blocked)

pub const fn is_neutral(self) -> bool

Check if this is neutral (Info/Trace)

pub const fn hex_color(self) -> &'static str

Get hex color for HTML/CSS display

Returns a CSS-compatible hex color code for web UIs.

Color Scheme

• Error: #c0392b (dark red)
• Blocked: #e74c3c (red)
• Critical: #e67e22 (orange)
• Warning: #f39c12 (yellow/orange)
• Help: #27ae60 (green)
• Success: #2ecc71 (bright green)
• Completed: #16a085 (teal)
• Info: #3498db (blue)
• Trace: #95a5a6 (gray)

pub const fn hex_bg_color(self) -> &'static str

Get background color for HTML/CSS badges

Returns a light background color suitable for badges/chips.

Trait Implementations

impl Clone for Severity

fn clone(&self) -> Severity

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Severity

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Severity

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Severity

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Severity

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Severity

fn eq(&self, other: &Severity) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Severity

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Severity

impl Eq for Severity

impl StructuralPartialEq for Severity