---
source: src/test_helpers.rs
expression: "&generated_code"
---
//! Generated types from OpenAPI specification
//!
//! This file contains all the generated types for the API.
//! Do not edit manually - regenerate using the appropriate script.
#![allow(clippy::large_enum_variant)]
#![allow(clippy::format_in_format_args)]
#![allow(clippy::let_unit_value)]
#![allow(unreachable_patterns)]
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ToolsRequest {
pub tools: Vec<ToolsRequestToolsItemUnion>,
}
#[derive(Debug, Clone)]
pub enum ToolsRequestToolsItemUnion {
TextTool(TextTool),
CodeTool(CodeTool),
}
impl serde::Serialize for ToolsRequestToolsItemUnion {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
match self {
Self::TextTool(payload) => {
let mut value = serde_json::to_value(payload)
.map_err(serde::ser::Error::custom)?;
let object = value
.as_object_mut()
.ok_or_else(|| {
serde::ser::Error::custom(
concat!(
"discriminated union variant `", stringify!(TextTool),
"` did not serialize as an object",
),
)
})?;
match object.get("type") {
Some(
serde_json::Value::String(tag),
) if matches!(tag.as_str(), "text") => {}
Some(serde_json::Value::String(tag)) => {
return Err(
serde::ser::Error::custom(
format!(
"discriminator `{}` value `{tag}` is not valid for variant `{}`",
"type", stringify!(TextTool),
),
),
);
}
Some(_) => {
return Err(
serde::ser::Error::custom(
concat!(
"discriminator `", "type",
"` did not serialize as a string",
),
),
);
}
None => {
object
.insert(
"type".to_string(),
serde_json::Value::String("text".to_string()),
);
}
}
value.serialize(serializer)
}
Self::CodeTool(payload) => {
let mut value = serde_json::to_value(payload)
.map_err(serde::ser::Error::custom)?;
let object = value
.as_object_mut()
.ok_or_else(|| {
serde::ser::Error::custom(
concat!(
"discriminated union variant `", stringify!(CodeTool),
"` did not serialize as an object",
),
)
})?;
match object.get("type") {
Some(
serde_json::Value::String(tag),
) if matches!(tag.as_str(), "code") => {}
Some(serde_json::Value::String(tag)) => {
return Err(
serde::ser::Error::custom(
format!(
"discriminator `{}` value `{tag}` is not valid for variant `{}`",
"type", stringify!(CodeTool),
),
),
);
}
Some(_) => {
return Err(
serde::ser::Error::custom(
concat!(
"discriminator `", "type",
"` did not serialize as a string",
),
),
);
}
None => {
object
.insert(
"type".to_string(),
serde_json::Value::String("code".to_string()),
);
}
}
value.serialize(serializer)
}
}
}
}
impl<'de> serde::Deserialize<'de> for ToolsRequestToolsItemUnion {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let value = serde_json::Value::deserialize(deserializer)?;
let discriminator = match value.get("type") {
Some(serde_json::Value::String(discriminator)) => {
Some(discriminator.as_str())
}
Some(_) => {
return Err(
serde::de::Error::custom(
concat!("non-string discriminator `", "type", "`",),
),
);
}
None => None,
};
match discriminator {
Some(discriminator) => {
match discriminator {
"text" => {
let primary_error = match serde_json::from_value::<
TextTool,
>(value.clone()) {
Ok(payload) => return Ok(Self::TextTool(payload)),
Err(error) => error,
};
let mut structural_match: Option<(Self, &'static str)> = None;
if let Ok(payload) = serde_json::from_value::<
CodeTool,
>(value.clone()) {
if let Some((_, first_name)) = &structural_match {
return Err(
serde::de::Error::custom(
format!(
"discriminator `{}` value `{}` did not fit its mapped branch and structurally matched both `{}` and `{}`",
"type", "text", first_name, stringify!(CodeTool),
),
),
);
}
structural_match = Some((
Self::CodeTool(payload),
stringify!(CodeTool),
));
}
match structural_match {
Some((payload, _)) => Ok(payload),
None => Err(serde::de::Error::custom(primary_error)),
}
}
"code" => {
let primary_error = match serde_json::from_value::<
CodeTool,
>(value.clone()) {
Ok(payload) => return Ok(Self::CodeTool(payload)),
Err(error) => error,
};
let mut structural_match: Option<(Self, &'static str)> = None;
if let Ok(payload) = serde_json::from_value::<
TextTool,
>(value.clone()) {
if let Some((_, first_name)) = &structural_match {
return Err(
serde::de::Error::custom(
format!(
"discriminator `{}` value `{}` did not fit its mapped branch and structurally matched both `{}` and `{}`",
"type", "code", first_name, stringify!(TextTool),
),
),
);
}
structural_match = Some((
Self::TextTool(payload),
stringify!(TextTool),
));
}
match structural_match {
Some((payload, _)) => Ok(payload),
None => Err(serde::de::Error::custom(primary_error)),
}
}
other => {
Err(
serde::de::Error::custom(
format!(
"unknown discriminator value `{other}` for `{}`", "type",
),
),
)
}
}
}
None => {
Err(
serde::de::Error::custom(
concat!("missing string discriminator `", "type", "`",),
),
)
}
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TextTool {
pub name: String,
pub r#type: TextToolType,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TextToolType {
#[default]
#[serde(rename = "text")]
Text,
}
impl TextToolType {
pub fn as_str(&self) -> &'static str {
match self {
Self::Text => "text",
}
}
}
impl ::std::fmt::Display for TextToolType {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str(self.as_str())
}
}
impl AsRef<str> for TextToolType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CodeTool {
pub language: String,
pub r#type: CodeToolType,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum CodeToolType {
#[default]
#[serde(rename = "code")]
Code,
}
impl CodeToolType {
pub fn as_str(&self) -> &'static str {
match self {
Self::Code => "code",
}
}
}
impl ::std::fmt::Display for CodeToolType {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str(self.as_str())
}
}
impl AsRef<str> for CodeToolType {
fn as_ref(&self) -> &str {
self.as_str()
}
}