Struct Model 

pub struct Model {

    pub additional_speed_tiers: Vec<String>,
    pub availability_nux: Option<ModelAvailabilityNux>,
    pub default_reasoning_effort: ReasoningEffort,
    pub default_service_tier: Option<String>,
    pub description: String,
    pub display_name: String,
    pub hidden: bool,
    pub id: String,
    pub input_modalities: Vec<InputModality>,
    pub is_default: bool,
    pub model: String,
    pub service_tiers: Vec<ModelServiceTier>,
    pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
    pub supports_personality: bool,
    pub upgrade: Option<String>,
    pub upgrade_info: Option<ModelUpgradeInfo>,
}

Model

JSON schema

{
 "type": "object",
 "required": [
   "defaultReasoningEffort",
   "description",
   "displayName",
   "hidden",
   "id",
   "isDefault",
   "model",
   "supportedReasoningEfforts"
 ],
 "properties": {
   "additionalSpeedTiers": {
     "description": "Deprecated: use `serviceTiers` instead.",
     "default": [],
     "type": "array",
     "items": {
       "type": "string"
     }
   },
   "availabilityNux": {
     "anyOf": [
       {
         "$ref": "#/definitions/ModelAvailabilityNux"
       },
       {
         "type": "null"
       }
     ]
   },
   "defaultReasoningEffort": {
     "$ref": "#/definitions/ReasoningEffort"
   },
   "defaultServiceTier": {
     "description": "Catalog default service tier id for this model, when one is configured.",
     "default": null,
     "type": [
       "string",
       "null"
     ]
   },
   "description": {
     "type": "string"
   },
   "displayName": {
     "type": "string"
   },
   "hidden": {
     "type": "boolean"
   },
   "id": {
     "type": "string"
   },
   "inputModalities": {
     "default": [
       "text",
       "image"
     ],
     "type": "array",
     "items": {
       "$ref": "#/definitions/InputModality"
     }
   },
   "isDefault": {
     "type": "boolean"
   },
   "model": {
     "type": "string"
   },
   "serviceTiers": {
     "default": [],
     "type": "array",
     "items": {
       "$ref": "#/definitions/ModelServiceTier"
     }
   },
   "supportedReasoningEfforts": {
     "type": "array",
     "items": {
       "$ref": "#/definitions/ReasoningEffortOption"
     }
   },
   "supportsPersonality": {
     "default": false,
     "type": "boolean"
   },
   "upgrade": {
     "type": [
       "string",
       "null"
     ]
   },
   "upgradeInfo": {
     "anyOf": [
       {
         "$ref": "#/definitions/ModelUpgradeInfo"
       },
       {
         "type": "null"
       }
     ]
   }
 }
}

Fields

additional_speed_tiers: Vec<String>

Deprecated: use serviceTiers instead.

availability_nux: Option<ModelAvailabilityNux>

default_reasoning_effort: ReasoningEffort

default_service_tier: Option<String>

Catalog default service tier id for this model, when one is configured.

description: String

display_name: String

hidden: bool

id: String

input_modalities: Vec<InputModality>

is_default: bool

model: String

service_tiers: Vec<ModelServiceTier>

supported_reasoning_efforts: Vec<ReasoningEffortOption>

supports_personality: bool

upgrade: Option<String>

upgrade_info: Option<ModelUpgradeInfo>

Trait Implementations

impl Clone for Model

fn clone(&self) -> Model

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Model

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Model

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Model

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.