Enum Resolution 

#[non_exhaustive]
pub enum Resolution {
    Low,
    Medium,
    High,
    UltraHigh,
    Unknown {
        resolution_type: String,
        data: Value,
    },
}

Resolution level for image and video content processing.

Controls the quality vs. token cost trade-off when processing images and videos. Lower resolution uses fewer tokens (lower cost), while higher resolution provides more detail for the model to analyze.

Token Cost Trade-offs

Resolution	Token Cost	Detail Level
Low	Lowest	Basic shapes and colors
Medium	Moderate	Standard detail
High	Higher	Fine details visible
UltraHigh	Highest	Maximum fidelity

Forward Compatibility (Evergreen Philosophy)

This enum is marked #[non_exhaustive], which means:

• Match statements must include a wildcard arm (_ => ...)
• New variants may be added in minor version updates without breaking your code

When the API returns a resolution value that this library doesn’t recognize, it will be captured as Resolution::Unknown rather than causing a deserialization error. This follows the Evergreen spec philosophy of graceful degradation.

Example

use genai_rs::Resolution;

// Use Low for cheap, basic analysis
let low_cost = Resolution::Low;

// Use High for detailed analysis
let detailed = Resolution::High;

// Default is Medium
assert_eq!(Resolution::default(), Resolution::Medium);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Low

Lowest token cost, basic shapes and colors

Medium

Moderate token cost, standard detail (default)

High

Higher token cost, fine details visible

UltraHigh

Highest token cost, maximum fidelity

Unknown

Unknown resolution (for forward compatibility).

This variant captures any unrecognized resolution values from the API, allowing the library to handle new resolutions gracefully.

The resolution_type field contains the unrecognized resolution string, and data contains the JSON value (typically the same string).

Fields

resolution_type: String

The unrecognized resolution string from the API

data: Value

The raw JSON value, preserved for debugging

Implementations

impl Resolution

pub const fn is_unknown(&self) -> bool

Check if this is an unknown resolution.

pub fn unknown_resolution_type(&self) -> Option<&str>

Returns the resolution type name if this is an unknown resolution.

Returns None for known resolutions.

pub fn unknown_data(&self) -> Option<&Value>

Returns the raw JSON data if this is an unknown resolution.

Returns None for known resolutions.

Trait Implementations

impl Clone for Resolution

fn clone(&self) -> Resolution

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Resolution

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

Formats the value using the given formatter.

impl Default for Resolution

fn default() -> Resolution

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Resolution

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Resolution

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

Formats the value using the given formatter.

impl PartialEq for Resolution

fn eq(&self, other: &Resolution) -> 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 Serialize for Resolution

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Resolution

impl StructuralPartialEq for Resolution