versa 1.9.0

/// Error types.
pub mod error {
  /// Error from a TryFrom or FromStr implementation.
  pub struct ConversionError(::std::borrow::Cow<'static, str>);
  impl ::std::error::Error for ConversionError {}
  impl ::std::fmt::Display for ConversionError {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
      ::std::fmt::Display::fmt(&self.0, f)
    }
  }
  impl ::std::fmt::Debug for ConversionError {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
      ::std::fmt::Debug::fmt(&self.0, f)
    }
  }
  impl From<&'static str> for ConversionError {
    fn from(value: &'static str) -> Self {
      Self(value.into())
    }
  }
  impl From<String> for ConversionError {
    fn from(value: String) -> Self {
      Self(value.into())
    }
  }
}
///Address
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Address",
///  "type": "object",
///  "properties": {
///    "city": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "country": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "string",
///          "maxLength": 2,
///          "minLength": 2
///        }
///      ]
///    },
///    "lat": {
///      "oneOf": [
///        {
///          "type": "number",
///          "maximum": 90.0,
///          "minimum": -90.0
///        },
///        {
///          "type": "null"
///        }
///      ]
///    },
///    "lon": {
///      "oneOf": [
///        {
///          "type": "number",
///          "maximum": 180.0,
///          "minimum": -180.0
///        },
///        {
///          "type": "null"
///        }
///      ]
///    },
///    "postal_code": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "region": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "string",
///          "pattern": "^[a-zA-Z0-9]{1,3}$"
///        }
///      ]
///    },
///    "street_address": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "tz": {
///      "type": [
///        "string",
///        "null"
///      ]
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Address {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub city: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub country: Option<AddressCountry>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub lat: Option<f64>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub lon: Option<f64>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub postal_code: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub region: Option<AddressRegion>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub street_address: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub tz: Option<String>,
}
impl From<&Address> for Address {
  fn from(value: &Address) -> Self {
    value.clone()
  }
}
impl Address {
  pub fn builder() -> builder::Address {
    Default::default()
  }
}
///AddressCountry
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "maxLength": 2,
///  "minLength": 2
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AddressCountry(String);
impl ::std::ops::Deref for AddressCountry {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<AddressCountry> for String {
  fn from(value: AddressCountry) -> Self {
    value.0
  }
}
impl From<&AddressCountry> for AddressCountry {
  fn from(value: &AddressCountry) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for AddressCountry {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if value.len() > 2usize {
      return Err("longer than 2 characters".into());
    }
    if value.len() < 2usize {
      return Err("shorter than 2 characters".into());
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for AddressCountry {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for AddressCountry {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for AddressCountry {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for AddressCountry {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///AddressRegion
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "pattern": "^[a-zA-Z0-9]{1,3}$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AddressRegion(String);
impl ::std::ops::Deref for AddressRegion {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<AddressRegion> for String {
  fn from(value: AddressRegion) -> Self {
    value.0
  }
}
impl From<&AddressRegion> for AddressRegion {
  fn from(value: &AddressRegion) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for AddressRegion {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if regress::Regex::new("^[a-zA-Z0-9]{1,3}$")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err("doesn't match pattern \"^[a-zA-Z0-9]{1,3}$\"".into());
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for AddressRegion {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for AddressRegion {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for AddressRegion {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for AddressRegion {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///CarRental
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "CarRental",
///  "type": "object",
///  "required": [
///    "items",
///    "rental_at",
///    "rental_location",
///    "return_at",
///    "return_location"
///  ],
///  "properties": {
///    "confirmation_number": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "drivers": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "array",
///          "items": {
///            "$ref": "#/$defs/person"
///          }
///        }
///      ]
///    },
///    "items": {
///      "type": "array",
///      "items": {
///        "$ref": "#/$defs/item"
///      },
///      "minItems": 1
///    },
///    "metadata": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "array",
///          "items": {
///            "$ref": "#/$defs/metadatum"
///          }
///        }
///      ]
///    },
///    "odometer_reading_in": {
///      "type": [
///        "integer",
///        "null"
///      ]
///    },
///    "odometer_reading_out": {
///      "type": [
///        "integer",
///        "null"
///      ]
///    },
///    "record_locator": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "rental_at": {
///      "type": "integer",
///      "maximum": 4102462800.0,
///      "minimum": 0.0
///    },
///    "rental_location": {
///      "$ref": "#/$defs/place"
///    },
///    "return_at": {
///      "type": "integer",
///      "maximum": 4102462800.0,
///      "minimum": 0.0
///    },
///    "return_location": {
///      "$ref": "#/$defs/place"
///    },
///    "vehicle": {
///      "type": [
///        "object",
///        "null"
///      ],
///      "required": [
///        "description"
///      ],
///      "properties": {
///        "description": {
///          "type": "string"
///        },
///        "image": {
///          "type": [
///            "string",
///            "null"
///          ],
///          "format": "uri"
///        },
///        "license_plate_number": {
///          "type": [
///            "string",
///            "null"
///          ]
///        },
///        "vehicle_class": {
///          "type": [
///            "string",
///            "null"
///          ],
///          "pattern": "^[a-zA-Z]{4}$"
///        }
///      }
///    },
///    "vendor_code": {
///      "type": [
///        "string",
///        "null"
///      ],
///      "pattern": "^[A-Z]{2}$"
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct CarRental {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub confirmation_number: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub drivers: Option<Vec<Person>>,
  pub items: Vec<Item>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub metadata: Option<Vec<Metadatum>>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub odometer_reading_in: Option<i64>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub odometer_reading_out: Option<i64>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub record_locator: Option<String>,
  pub rental_at: i64,
  pub rental_location: Place,
  pub return_at: i64,
  pub return_location: Place,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub vehicle: Option<CarRentalVehicle>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub vendor_code: Option<CarRentalVendorCode>,
}
impl From<&CarRental> for CarRental {
  fn from(value: &CarRental) -> Self {
    value.clone()
  }
}
impl CarRental {
  pub fn builder() -> builder::CarRental {
    Default::default()
  }
}
///CarRentalVehicle
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "object",
///  "required": [
///    "description"
///  ],
///  "properties": {
///    "description": {
///      "type": "string"
///    },
///    "image": {
///      "type": [
///        "string",
///        "null"
///      ],
///      "format": "uri"
///    },
///    "license_plate_number": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "vehicle_class": {
///      "type": [
///        "string",
///        "null"
///      ],
///      "pattern": "^[a-zA-Z]{4}$"
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct CarRentalVehicle {
  pub description: String,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub image: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub license_plate_number: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub vehicle_class: Option<CarRentalVehicleVehicleClass>,
}
impl From<&CarRentalVehicle> for CarRentalVehicle {
  fn from(value: &CarRentalVehicle) -> Self {
    value.clone()
  }
}
impl CarRentalVehicle {
  pub fn builder() -> builder::CarRentalVehicle {
    Default::default()
  }
}
///CarRentalVehicleVehicleClass
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "pattern": "^[a-zA-Z]{4}$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CarRentalVehicleVehicleClass(String);
impl ::std::ops::Deref for CarRentalVehicleVehicleClass {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<CarRentalVehicleVehicleClass> for String {
  fn from(value: CarRentalVehicleVehicleClass) -> Self {
    value.0
  }
}
impl From<&CarRentalVehicleVehicleClass> for CarRentalVehicleVehicleClass {
  fn from(value: &CarRentalVehicleVehicleClass) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for CarRentalVehicleVehicleClass {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if regress::Regex::new("^[a-zA-Z]{4}$")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err("doesn't match pattern \"^[a-zA-Z]{4}$\"".into());
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for CarRentalVehicleVehicleClass {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for CarRentalVehicleVehicleClass {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for CarRentalVehicleVehicleClass {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for CarRentalVehicleVehicleClass {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///CarRentalVendorCode
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "pattern": "^[A-Z]{2}$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CarRentalVendorCode(String);
impl ::std::ops::Deref for CarRentalVendorCode {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<CarRentalVendorCode> for String {
  fn from(value: CarRentalVendorCode) -> Self {
    value.0
  }
}
impl From<&CarRentalVendorCode> for CarRentalVendorCode {
  fn from(value: &CarRentalVendorCode) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for CarRentalVendorCode {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if regress::Regex::new("^[A-Z]{2}$")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err("doesn't match pattern \"^[A-Z]{2}$\"".into());
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for CarRentalVendorCode {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for CarRentalVendorCode {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for CarRentalVendorCode {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for CarRentalVendorCode {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///Customer
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Customer",
///  "type": "object",
///  "required": [
///    "name"
///  ],
///  "properties": {
///    "address": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "$ref": "#/$defs/address"
///        }
///      ]
///    },
///    "booker": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "$ref": "#/$defs/person"
///        }
///      ]
///    },
///    "email": {
///      "type": [
///        "string",
///        "null"
///      ],
///      "format": "email",
///      "maxLength": 254,
///      "minLength": 6
///    },
///    "metadata": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "array",
///          "items": {
///            "$ref": "#/$defs/metadatum"
///          }
///        }
///      ]
///    },
///    "name": {
///      "type": "string"
///    },
///    "phone": {
///      "type": [
///        "string",
///        "null"
///      ],
///      "pattern": "^\\+?[1-9]\\d{1,14}$"
///    },
///    "website": {
///      "type": [
///        "string",
///        "null"
///      ],
///      "format": "hostname"
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Customer {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub address: Option<Address>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub booker: Option<Person>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub email: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub metadata: Option<Vec<Metadatum>>,
  pub name: String,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub phone: Option<CustomerPhone>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub website: Option<String>,
}
impl From<&Customer> for Customer {
  fn from(value: &Customer) -> Self {
    value.clone()
  }
}
impl Customer {
  pub fn builder() -> builder::Customer {
    Default::default()
  }
}
///CustomerPhone
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "pattern": "^\\+?[1-9]\\d{1,14}$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CustomerPhone(String);
impl ::std::ops::Deref for CustomerPhone {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<CustomerPhone> for String {
  fn from(value: CustomerPhone) -> Self {
    value.0
  }
}
impl From<&CustomerPhone> for CustomerPhone {
  fn from(value: &CustomerPhone) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for CustomerPhone {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if regress::Regex::new("^\\+?[1-9]\\d{1,14}$")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err("doesn't match pattern \"^\\+?[1-9]\\d{1,14}$\"".into());
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for CustomerPhone {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for CustomerPhone {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for CustomerPhone {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for CustomerPhone {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///Doc
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Doc",
///  "type": "object",
///  "required": [
///    "body",
///    "title"
///  ],
///  "properties": {
///    "body": {
///      "type": "string"
///    },
///    "title": {
///      "type": "string"
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Doc {
  pub body: String,
  pub title: String,
}
impl From<&Doc> for Doc {
  fn from(value: &Doc) -> Self {
    value.clone()
  }
}
impl Doc {
  pub fn builder() -> builder::Doc {
    Default::default()
  }
}
///Flight
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Flight",
///  "type": "object",
///  "required": [
///    "tickets"
///  ],
///  "properties": {
///    "itinerary_locator": {
///      "type": [
///        "null",
///        "string"
///      ]
///    },
///    "tickets": {
///      "type": "array",
///      "items": {
///        "$ref": "#/$defs/flight_ticket"
///      },
///      "minItems": 1
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Flight {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub itinerary_locator: Option<String>,
  pub tickets: Vec<FlightTicket>,
}
impl From<&Flight> for Flight {
  fn from(value: &Flight) -> Self {
    value.clone()
  }
}
impl Flight {
  pub fn builder() -> builder::Flight {
    Default::default()
  }
}
///FlightSegment
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "FlightSegment",
///  "type": "object",
///  "required": [
///    "arrival_airport_code",
///    "departure_airport_code"
///  ],
///  "properties": {
///    "aircraft_type": {
///      "type": [
///        "null",
///        "string"
///      ],
///      "pattern": "^[a-zA-Z0-9]{2,4}$"
///    },
///    "arrival_airport_code": {
///      "type": "string",
///      "pattern": "^[a-zA-Z]{3}$"
///    },
///    "arrival_at": {
///      "type": [
///        "null",
///        "integer"
///      ],
///      "maximum": 4102462800.0,
///      "minimum": 0.0
///    },
///    "arrival_tz": {
///      "type": [
///        "null",
///        "string"
///      ]
///    },
///    "class_of_service": {
///      "type": [
///        "null",
///        "string"
///      ]
///    },
///    "departure_airport_code": {
///      "type": "string",
///      "pattern": "^[a-zA-Z]{3}$"
///    },
///    "departure_at": {
///      "type": [
///        "null",
///        "integer"
///      ],
///      "maximum": 4102462800.0,
///      "minimum": 0.0
///    },
///    "departure_tz": {
///      "type": [
///        "null",
///        "string"
///      ]
///    },
///    "flight_number": {
///      "type": [
///        "null",
///        "string"
///      ]
///    },
///    "metadata": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "array",
///          "items": {
///            "$ref": "#/$defs/metadatum"
///          }
///        }
///      ]
///    },
///    "seat": {
///      "type": [
///        "null",
///        "string"
///      ]
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct FlightSegment {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub aircraft_type: Option<FlightSegmentAircraftType>,
  pub arrival_airport_code: FlightSegmentArrivalAirportCode,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub arrival_at: Option<i64>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub arrival_tz: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub class_of_service: Option<String>,
  pub departure_airport_code: FlightSegmentDepartureAirportCode,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub departure_at: Option<i64>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub departure_tz: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub flight_number: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub metadata: Option<Vec<Metadatum>>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub seat: Option<String>,
}
impl From<&FlightSegment> for FlightSegment {
  fn from(value: &FlightSegment) -> Self {
    value.clone()
  }
}
impl FlightSegment {
  pub fn builder() -> builder::FlightSegment {
    Default::default()
  }
}
///FlightSegmentAircraftType
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "pattern": "^[a-zA-Z0-9]{2,4}$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FlightSegmentAircraftType(String);
impl ::std::ops::Deref for FlightSegmentAircraftType {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<FlightSegmentAircraftType> for String {
  fn from(value: FlightSegmentAircraftType) -> Self {
    value.0
  }
}
impl From<&FlightSegmentAircraftType> for FlightSegmentAircraftType {
  fn from(value: &FlightSegmentAircraftType) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for FlightSegmentAircraftType {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if regress::Regex::new("^[a-zA-Z0-9]{2,4}$")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err("doesn't match pattern \"^[a-zA-Z0-9]{2,4}$\"".into());
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for FlightSegmentAircraftType {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for FlightSegmentAircraftType {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for FlightSegmentAircraftType {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for FlightSegmentAircraftType {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///FlightSegmentArrivalAirportCode
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "pattern": "^[a-zA-Z]{3}$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FlightSegmentArrivalAirportCode(String);
impl ::std::ops::Deref for FlightSegmentArrivalAirportCode {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<FlightSegmentArrivalAirportCode> for String {
  fn from(value: FlightSegmentArrivalAirportCode) -> Self {
    value.0
  }
}
impl From<&FlightSegmentArrivalAirportCode> for FlightSegmentArrivalAirportCode {
  fn from(value: &FlightSegmentArrivalAirportCode) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for FlightSegmentArrivalAirportCode {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if regress::Regex::new("^[a-zA-Z]{3}$")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err("doesn't match pattern \"^[a-zA-Z]{3}$\"".into());
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for FlightSegmentArrivalAirportCode {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for FlightSegmentArrivalAirportCode {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for FlightSegmentArrivalAirportCode {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for FlightSegmentArrivalAirportCode {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///FlightSegmentDepartureAirportCode
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "pattern": "^[a-zA-Z]{3}$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FlightSegmentDepartureAirportCode(String);
impl ::std::ops::Deref for FlightSegmentDepartureAirportCode {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<FlightSegmentDepartureAirportCode> for String {
  fn from(value: FlightSegmentDepartureAirportCode) -> Self {
    value.0
  }
}
impl From<&FlightSegmentDepartureAirportCode> for FlightSegmentDepartureAirportCode {
  fn from(value: &FlightSegmentDepartureAirportCode) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for FlightSegmentDepartureAirportCode {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if regress::Regex::new("^[a-zA-Z]{3}$")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err("doesn't match pattern \"^[a-zA-Z]{3}$\"".into());
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for FlightSegmentDepartureAirportCode {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for FlightSegmentDepartureAirportCode {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for FlightSegmentDepartureAirportCode {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for FlightSegmentDepartureAirportCode {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///FlightTicket
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "FlightTicket",
///  "type": "object",
///  "required": [
///    "segments"
///  ],
///  "properties": {
///    "number": {
///      "type": [
///        "null",
///        "string"
///      ]
///    },
///    "passenger": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "$ref": "#/$defs/person"
///        }
///      ]
///    },
///    "record_locator": {
///      "type": [
///        "null",
///        "string"
///      ]
///    },
///    "segments": {
///      "type": "array",
///      "items": {
///        "$ref": "#/$defs/flight_segment"
///      },
///      "minItems": 1
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct FlightTicket {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub number: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub passenger: Option<Person>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub record_locator: Option<String>,
  pub segments: Vec<FlightSegment>,
}
impl From<&FlightTicket> for FlightTicket {
  fn from(value: &FlightTicket) -> Self {
    value.clone()
  }
}
impl FlightTicket {
  pub fn builder() -> builder::FlightTicket {
    Default::default()
  }
}
///Footer
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Footer",
///  "type": "object",
///  "properties": {
///    "supplemental_text": {
///      "type": [
///        "string",
///        "null"
///      ]
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Footer {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub supplemental_text: Option<String>,
}
impl From<&Footer> for Footer {
  fn from(value: &Footer) -> Self {
    value.clone()
  }
}
impl Footer {
  pub fn builder() -> builder::Footer {
    Default::default()
  }
}
///Header
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Header",
///  "type": "object",
///  "properties": {
///    "booked_at": {
///      "type": [
///        "integer",
///        "null"
///      ],
///      "maximum": 4102462800.0,
///      "minimum": 0.0
///    },
///    "customer": {
///      "oneOf": [
///        {
///          "$ref": "#/$defs/customer"
///        },
///        {
///          "type": "null"
///        }
///      ]
///    },
///    "lifecycle_status": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "title": "LifecycleStatus",
///          "type": "string",
///          "enum": [
///            "active",
///            "canceled",
///            "refunded"
///          ]
///        }
///      ]
///    },
///    "third_party": {
///      "type": [
///        "object",
///        "null"
///      ],
///      "required": [
///        "make_primary",
///        "relation"
///      ],
///      "properties": {
///        "make_primary": {
///          "description": "Determines whether the merchant or third party gets top billing on the receipt",
///          "type": "boolean"
///        },
///        "merchant": {
///          "oneOf": [
///            {
///              "$ref": "#/$defs/org"
///            },
///            {
///              "type": "null"
///            }
///          ]
///        },
///        "relation": {
///          "type": "string",
///          "enum": [
///            "bnpl",
///            "delivery_service",
///            "marketplace",
///            "payment_processor",
///            "platform",
///            "point_of_sale"
///          ]
///        }
///      }
///    },
///    "trip": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "$ref": "#/$defs/trip"
///        }
///      ]
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Header {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub booked_at: Option<i64>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub customer: Option<Customer>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub lifecycle_status: Option<LifecycleStatus>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub third_party: Option<HeaderThirdParty>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub trip: Option<Trip>,
}
impl From<&Header> for Header {
  fn from(value: &Header) -> Self {
    value.clone()
  }
}
impl Header {
  pub fn builder() -> builder::Header {
    Default::default()
  }
}
///HeaderThirdParty
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "object",
///  "required": [
///    "make_primary",
///    "relation"
///  ],
///  "properties": {
///    "make_primary": {
///      "description": "Determines whether the merchant or third party gets top billing on the receipt",
///      "type": "boolean"
///    },
///    "merchant": {
///      "oneOf": [
///        {
///          "$ref": "#/$defs/org"
///        },
///        {
///          "type": "null"
///        }
///      ]
///    },
///    "relation": {
///      "type": "string",
///      "enum": [
///        "bnpl",
///        "delivery_service",
///        "marketplace",
///        "payment_processor",
///        "platform",
///        "point_of_sale"
///      ]
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct HeaderThirdParty {
  ///Determines whether the merchant or third party gets top billing on the receipt
  pub make_primary: bool,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub merchant: Option<Org>,
  pub relation: HeaderThirdPartyRelation,
}
impl From<&HeaderThirdParty> for HeaderThirdParty {
  fn from(value: &HeaderThirdParty) -> Self {
    value.clone()
  }
}
impl HeaderThirdParty {
  pub fn builder() -> builder::HeaderThirdParty {
    Default::default()
  }
}
///HeaderThirdPartyRelation
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "enum": [
///    "bnpl",
///    "delivery_service",
///    "marketplace",
///    "payment_processor",
///    "platform",
///    "point_of_sale"
///  ]
///}
/// ```
/// </details>
#[derive(
  ::serde::Deserialize, ::serde::Serialize, Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd,
)]
pub enum HeaderThirdPartyRelation {
  #[serde(rename = "bnpl")]
  Bnpl,
  #[serde(rename = "delivery_service")]
  DeliveryService,
  #[serde(rename = "marketplace")]
  Marketplace,
  #[serde(rename = "payment_processor")]
  PaymentProcessor,
  #[serde(rename = "platform")]
  Platform,
  #[serde(rename = "point_of_sale")]
  PointOfSale,
}
impl From<&HeaderThirdPartyRelation> for HeaderThirdPartyRelation {
  fn from(value: &HeaderThirdPartyRelation) -> Self {
    value.clone()
  }
}
impl ::std::fmt::Display for HeaderThirdPartyRelation {
  fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
    match *self {
      Self::Bnpl => write!(f, "bnpl"),
      Self::DeliveryService => write!(f, "delivery_service"),
      Self::Marketplace => write!(f, "marketplace"),
      Self::PaymentProcessor => write!(f, "payment_processor"),
      Self::Platform => write!(f, "platform"),
      Self::PointOfSale => write!(f, "point_of_sale"),
    }
  }
}
impl std::str::FromStr for HeaderThirdPartyRelation {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    match value {
      "bnpl" => Ok(Self::Bnpl),
      "delivery_service" => Ok(Self::DeliveryService),
      "marketplace" => Ok(Self::Marketplace),
      "payment_processor" => Ok(Self::PaymentProcessor),
      "platform" => Ok(Self::Platform),
      "point_of_sale" => Ok(Self::PointOfSale),
      _ => Err("invalid value".into()),
    }
  }
}
impl std::convert::TryFrom<&str> for HeaderThirdPartyRelation {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl std::convert::TryFrom<&String> for HeaderThirdPartyRelation {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl std::convert::TryFrom<String> for HeaderThirdPartyRelation {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
///Item
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Item",
///  "type": "object",
///  "required": [
///    "description"
///  ],
///  "properties": {
///    "date": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "string",
///          "format": "date"
///        }
///      ]
///    },
///    "description": {
///      "type": "string"
///    },
///    "group": {
///      "type": [
///        "null",
///        "string"
///      ]
///    },
///    "metadata": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "array",
///          "items": {
///            "$ref": "#/$defs/metadatum"
///          }
///        }
///      ]
///    },
///    "product_image_asset_id": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "quantity": {
///      "type": [
///        "null",
///        "number"
///      ]
///    },
///    "unit": {
///      "type": [
///        "null",
///        "string"
///      ]
///    },
///    "unspsc": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "string",
///          "pattern": "^\\d{8}$"
///        }
///      ]
///    },
///    "url": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "string",
///          "format": "uri"
///        }
///      ]
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Item {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub date: Option<String>,
  pub description: String,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub group: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub metadata: Option<Vec<Metadatum>>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub product_image_asset_id: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub quantity: Option<f64>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub unit: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub unspsc: Option<ItemUnspsc>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub url: Option<String>,
}
impl From<&Item> for Item {
  fn from(value: &Item) -> Self {
    value.clone()
  }
}
impl Item {
  pub fn builder() -> builder::Item {
    Default::default()
  }
}
///ItemUnspsc
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "pattern": "^\\d{8}$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ItemUnspsc(String);
impl ::std::ops::Deref for ItemUnspsc {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<ItemUnspsc> for String {
  fn from(value: ItemUnspsc) -> Self {
    value.0
  }
}
impl From<&ItemUnspsc> for ItemUnspsc {
  fn from(value: &ItemUnspsc) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for ItemUnspsc {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if regress::Regex::new("^\\d{8}$")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err("doesn't match pattern \"^\\d{8}$\"".into());
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for ItemUnspsc {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for ItemUnspsc {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for ItemUnspsc {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for ItemUnspsc {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///Itemization
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Itemization",
///  "type": "object",
///  "properties": {
///    "car_rental": {
///      "oneOf": [
///        {
///          "$ref": "#/$defs/car_rental"
///        },
///        {
///          "type": "null"
///        }
///      ]
///    },
///    "flight": {
///      "oneOf": [
///        {
///          "$ref": "#/$defs/flight"
///        },
///        {
///          "type": "null"
///        }
///      ]
///    },
///    "lodging": {
///      "oneOf": [
///        {
///          "$ref": "#/$defs/lodging"
///        },
///        {
///          "type": "null"
///        }
///      ]
///    },
///    "service": {
///      "oneOf": [
///        {
///          "$ref": "#/$defs/service"
///        },
///        {
///          "type": "null"
///        }
///      ]
///    },
///    "transit_route": {
///      "oneOf": [
///        {
///          "$ref": "#/$defs/transit_route"
///        },
///        {
///          "type": "null"
///        }
///      ]
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Itemization {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub car_rental: Option<CarRental>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub flight: Option<Flight>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub lodging: Option<Lodging>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub service: Option<Service>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub transit_route: Option<TransitRoute>,
}
impl From<&Itemization> for Itemization {
  fn from(value: &Itemization) -> Self {
    value.clone()
  }
}
impl Itemization {
  pub fn builder() -> builder::Itemization {
    Default::default()
  }
}
///A Versa itinerary
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "$id": "events/itinerary",
///  "title": "Itinerary",
///  "description": "A Versa itinerary",
///  "type": "object",
///  "required": [
///    "header",
///    "itemization",
///    "schema_version"
///  ],
///  "properties": {
///    "footer": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "$ref": "#/$defs/footer"
///        }
///      ]
///    },
///    "header": {
///      "$ref": "#/$defs/header"
///    },
///    "itemization": {
///      "$ref": "#/$defs/itemization"
///    },
///    "schema_version": {
///      "title": "SchemaVersion",
///      "type": "string",
///      "maxLength": 14,
///      "minLength": 5,
///      "pattern": "^(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)$"
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Itinerary {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub footer: Option<Footer>,
  pub header: Header,
  pub itemization: Itemization,
  pub schema_version: SchemaVersion,
}
impl From<&Itinerary> for Itinerary {
  fn from(value: &Itinerary) -> Self {
    value.clone()
  }
}
impl Itinerary {
  pub fn builder() -> builder::Itinerary {
    Default::default()
  }
}
///LifecycleStatus
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "LifecycleStatus",
///  "type": "string",
///  "enum": [
///    "active",
///    "canceled",
///    "refunded"
///  ]
///}
/// ```
/// </details>
#[derive(
  ::serde::Deserialize, ::serde::Serialize, Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd,
)]
pub enum LifecycleStatus {
  #[serde(rename = "active")]
  Active,
  #[serde(rename = "canceled")]
  Canceled,
  #[serde(rename = "refunded")]
  Refunded,
}
impl From<&LifecycleStatus> for LifecycleStatus {
  fn from(value: &LifecycleStatus) -> Self {
    value.clone()
  }
}
impl ::std::fmt::Display for LifecycleStatus {
  fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
    match *self {
      Self::Active => write!(f, "active"),
      Self::Canceled => write!(f, "canceled"),
      Self::Refunded => write!(f, "refunded"),
    }
  }
}
impl std::str::FromStr for LifecycleStatus {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    match value {
      "active" => Ok(Self::Active),
      "canceled" => Ok(Self::Canceled),
      "refunded" => Ok(Self::Refunded),
      _ => Err("invalid value".into()),
    }
  }
}
impl std::convert::TryFrom<&str> for LifecycleStatus {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl std::convert::TryFrom<&String> for LifecycleStatus {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl std::convert::TryFrom<String> for LifecycleStatus {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
///Lodging
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Lodging",
///  "type": "object",
///  "required": [
///    "check_in",
///    "check_out",
///    "items",
///    "location"
///  ],
///  "properties": {
///    "chain_code": {
///      "type": [
///        "string",
///        "null"
///      ],
///      "pattern": "^[A-Z]{2}$"
///    },
///    "check_in": {
///      "type": "integer"
///    },
///    "check_out": {
///      "type": "integer"
///    },
///    "confirmation_number": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "guests": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "array",
///          "items": {
///            "$ref": "#/$defs/person"
///          }
///        }
///      ]
///    },
///    "items": {
///      "type": "array",
///      "items": {
///        "$ref": "#/$defs/item"
///      },
///      "minItems": 1
///    },
///    "location": {
///      "$ref": "#/$defs/place"
///    },
///    "metadata": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "array",
///          "items": {
///            "$ref": "#/$defs/metadatum"
///          }
///        }
///      ]
///    },
///    "property_id": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "record_locator": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "room": {
///      "type": [
///        "null",
///        "string"
///      ]
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Lodging {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub chain_code: Option<LodgingChainCode>,
  pub check_in: i64,
  pub check_out: i64,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub confirmation_number: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub guests: Option<Vec<Person>>,
  pub items: Vec<Item>,
  pub location: Place,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub metadata: Option<Vec<Metadatum>>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub property_id: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub record_locator: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub room: Option<String>,
}
impl From<&Lodging> for Lodging {
  fn from(value: &Lodging) -> Self {
    value.clone()
  }
}
impl Lodging {
  pub fn builder() -> builder::Lodging {
    Default::default()
  }
}
///LodgingChainCode
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "pattern": "^[A-Z]{2}$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct LodgingChainCode(String);
impl ::std::ops::Deref for LodgingChainCode {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<LodgingChainCode> for String {
  fn from(value: LodgingChainCode) -> Self {
    value.0
  }
}
impl From<&LodgingChainCode> for LodgingChainCode {
  fn from(value: &LodgingChainCode) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for LodgingChainCode {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if regress::Regex::new("^[A-Z]{2}$")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err("doesn't match pattern \"^[A-Z]{2}$\"".into());
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for LodgingChainCode {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for LodgingChainCode {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for LodgingChainCode {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for LodgingChainCode {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///Metadatum
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Metadatum",
///  "type": "object",
///  "required": [
///    "key",
///    "value"
///  ],
///  "properties": {
///    "key": {
///      "type": "string"
///    },
///    "value": {
///      "type": "string"
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Metadatum {
  pub key: String,
  pub value: String,
}
impl From<&Metadatum> for Metadatum {
  fn from(value: &Metadatum) -> Self {
    value.clone()
  }
}
impl Metadatum {
  pub fn builder() -> builder::Metadatum {
    Default::default()
  }
}
///Org
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Org",
///  "type": "object",
///  "required": [
///    "name"
///  ],
///  "properties": {
///    "address": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "$ref": "#/$defs/address"
///        }
///      ]
///    },
///    "brand_color": {
///      "description": "Hex color",
///      "type": [
///        "string",
///        "null"
///      ],
///      "pattern": "^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$"
///    },
///    "legal_name": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "logo": {
///      "type": [
///        "string",
///        "null"
///      ],
///      "format": "uri"
///    },
///    "logo_asset_id": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "name": {
///      "type": "string"
///    },
///    "vat_number": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "website": {
///      "type": [
///        "string",
///        "null"
///      ],
///      "format": "hostname"
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Org {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub address: Option<Address>,
  ///Hex color
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub brand_color: Option<OrgBrandColor>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub legal_name: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub logo: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub logo_asset_id: Option<String>,
  pub name: String,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub vat_number: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub website: Option<String>,
}
impl From<&Org> for Org {
  fn from(value: &Org) -> Self {
    value.clone()
  }
}
impl Org {
  pub fn builder() -> builder::Org {
    Default::default()
  }
}
///Hex color
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "description": "Hex color",
///  "type": "string",
///  "pattern": "^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct OrgBrandColor(String);
impl ::std::ops::Deref for OrgBrandColor {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<OrgBrandColor> for String {
  fn from(value: OrgBrandColor) -> Self {
    value.0
  }
}
impl From<&OrgBrandColor> for OrgBrandColor {
  fn from(value: &OrgBrandColor) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for OrgBrandColor {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if regress::Regex::new("^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err("doesn't match pattern \"^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$\"".into());
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for OrgBrandColor {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for OrgBrandColor {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for OrgBrandColor {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for OrgBrandColor {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///Person
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Person",
///  "type": "object",
///  "properties": {
///    "email": {
///      "type": [
///        "string",
///        "null"
///      ],
///      "format": "email",
///      "maxLength": 254,
///      "minLength": 6
///    },
///    "first_name": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "last_name": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "metadata": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "array",
///          "items": {
///            "$ref": "#/$defs/metadatum"
///          }
///        }
///      ]
///    },
///    "phone": {
///      "type": [
///        "string",
///        "null"
///      ],
///      "pattern": "^\\+?[1-9]\\d{1,14}$"
///    },
///    "preferred_first_name": {
///      "type": [
///        "string",
///        "null"
///      ]
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Person {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub email: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub first_name: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub last_name: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub metadata: Option<Vec<Metadatum>>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub phone: Option<PersonPhone>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub preferred_first_name: Option<String>,
}
impl From<&Person> for Person {
  fn from(value: &Person) -> Self {
    value.clone()
  }
}
impl Person {
  pub fn builder() -> builder::Person {
    Default::default()
  }
}
///PersonPhone
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "pattern": "^\\+?[1-9]\\d{1,14}$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PersonPhone(String);
impl ::std::ops::Deref for PersonPhone {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<PersonPhone> for String {
  fn from(value: PersonPhone) -> Self {
    value.0
  }
}
impl From<&PersonPhone> for PersonPhone {
  fn from(value: &PersonPhone) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for PersonPhone {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if regress::Regex::new("^\\+?[1-9]\\d{1,14}$")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err("doesn't match pattern \"^\\+?[1-9]\\d{1,14}$\"".into());
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for PersonPhone {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for PersonPhone {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for PersonPhone {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for PersonPhone {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///The physical or online location where a transaction occurred
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Place",
///  "description": "The physical or online location where a transaction occurred",
///  "type": "object",
///  "properties": {
///    "address": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "$ref": "#/$defs/address"
///        }
///      ]
///    },
///    "google_place_id": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "image": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "string",
///          "format": "uri"
///        }
///      ]
///    },
///    "name": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "phone": {
///      "type": [
///        "string",
///        "null"
///      ],
///      "pattern": "^\\+?[1-9]\\d{1,14}$"
///    },
///    "url": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "string",
///          "format": "uri"
///        }
///      ]
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Place {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub address: Option<Address>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub google_place_id: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub image: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub name: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub phone: Option<PlacePhone>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub url: Option<String>,
}
impl From<&Place> for Place {
  fn from(value: &Place) -> Self {
    value.clone()
  }
}
impl Place {
  pub fn builder() -> builder::Place {
    Default::default()
  }
}
///PlacePhone
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "pattern": "^\\+?[1-9]\\d{1,14}$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PlacePhone(String);
impl ::std::ops::Deref for PlacePhone {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<PlacePhone> for String {
  fn from(value: PlacePhone) -> Self {
    value.0
  }
}
impl From<&PlacePhone> for PlacePhone {
  fn from(value: &PlacePhone) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for PlacePhone {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if regress::Regex::new("^\\+?[1-9]\\d{1,14}$")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err("doesn't match pattern \"^\\+?[1-9]\\d{1,14}$\"".into());
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for PlacePhone {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for PlacePhone {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for PlacePhone {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for PlacePhone {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///SchemaVersion
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "SchemaVersion",
///  "type": "string",
///  "maxLength": 14,
///  "minLength": 5,
///  "pattern": "^(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SchemaVersion(String);
impl ::std::ops::Deref for SchemaVersion {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<SchemaVersion> for String {
  fn from(value: SchemaVersion) -> Self {
    value.0
  }
}
impl From<&SchemaVersion> for SchemaVersion {
  fn from(value: &SchemaVersion) -> Self {
    value.clone()
  }
}
impl ::std::str::FromStr for SchemaVersion {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    if value.len() > 14usize {
      return Err("longer than 14 characters".into());
    }
    if value.len() < 5usize {
      return Err("shorter than 5 characters".into());
    }
    if regress::Regex::new("^(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)$")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err(
        "doesn't match pattern \"^(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)$\"".into(),
      );
    }
    Ok(Self(value.to_string()))
  }
}
impl ::std::convert::TryFrom<&str> for SchemaVersion {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<&String> for SchemaVersion {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl ::std::convert::TryFrom<String> for SchemaVersion {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl<'de> ::serde::Deserialize<'de> for SchemaVersion {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: ::serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: self::error::ConversionError| {
        <D::Error as ::serde::de::Error>::custom(e.to_string())
      })
  }
}
///Service
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Service",
///  "type": "object",
///  "required": [
///    "service_items"
///  ],
///  "properties": {
///    "service_items": {
///      "type": "array",
///      "items": {
///        "$ref": "#/$defs/service_item"
///      },
///      "minItems": 1
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Service {
  pub service_items: Vec<ServiceItem>,
}
impl From<&Service> for Service {
  fn from(value: &Service) -> Self {
    value.clone()
  }
}
impl Service {
  pub fn builder() -> builder::Service {
    Default::default()
  }
}
///ServiceItem
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "ServiceItem",
///  "type": "object",
///  "required": [
///    "description"
///  ],
///  "properties": {
///    "current_period_end_at": {
///      "type": [
///        "integer",
///        "null"
///      ],
///      "maximum": 4102462800.0,
///      "minimum": 0.0
///    },
///    "current_period_start_at": {
///      "type": [
///        "integer",
///        "null"
///      ],
///      "maximum": 4102462800.0,
///      "minimum": 0.0
///    },
///    "description": {
///      "type": "string"
///    },
///    "metadata": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "array",
///          "items": {
///            "$ref": "#/$defs/metadatum"
///          }
///        }
///      ]
///    },
///    "service_location": {
///      "oneOf": [
///        {
///          "$ref": "#/$defs/place"
///        },
///        {
///          "type": "null"
///        }
///      ]
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct ServiceItem {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub current_period_end_at: Option<i64>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub current_period_start_at: Option<i64>,
  pub description: String,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub metadata: Option<Vec<Metadatum>>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub service_location: Option<Place>,
}
impl From<&ServiceItem> for ServiceItem {
  fn from(value: &ServiceItem) -> Self {
    value.clone()
  }
}
impl ServiceItem {
  pub fn builder() -> builder::ServiceItem {
    Default::default()
  }
}
///TransitRoute
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "TransitRoute",
///  "type": "object",
///  "required": [
///    "transit_route_items"
///  ],
///  "properties": {
///    "transit_route_items": {
///      "type": "array",
///      "items": {
///        "$ref": "#/$defs/transit_route_item"
///      },
///      "minItems": 1
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct TransitRoute {
  pub transit_route_items: Vec<TransitRouteItem>,
}
impl From<&TransitRoute> for TransitRoute {
  fn from(value: &TransitRoute) -> Self {
    value.clone()
  }
}
impl TransitRoute {
  pub fn builder() -> builder::TransitRoute {
    Default::default()
  }
}
///TransitRouteItem
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "TransitRouteItem",
///  "type": "object",
///  "properties": {
///    "arrival_at": {
///      "type": [
///        "integer",
///        "null"
///      ],
///      "maximum": 4102462800.0,
///      "minimum": 0.0
///    },
///    "arrival_location": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "$ref": "#/$defs/place"
///        }
///      ]
///    },
///    "departure_at": {
///      "type": [
///        "integer",
///        "null"
///      ],
///      "maximum": 4102462800.0,
///      "minimum": 0.0
///    },
///    "departure_location": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "$ref": "#/$defs/place"
///        }
///      ]
///    },
///    "metadata": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "array",
///          "items": {
///            "$ref": "#/$defs/metadatum"
///          }
///        }
///      ]
///    },
///    "mode": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "string",
///          "enum": [
///            "car",
///            "taxi",
///            "rail",
///            "bus",
///            "ferry",
///            "other"
///          ]
///        }
///      ]
///    },
///    "passenger": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "$ref": "#/$defs/person"
///        }
///      ]
///    },
///    "polyline": {
///      "oneOf": [
///        {
///          "type": "null"
///        },
///        {
///          "type": "string"
///        }
///      ]
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct TransitRouteItem {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub arrival_at: Option<i64>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub arrival_location: Option<Place>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub departure_at: Option<i64>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub departure_location: Option<Place>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub metadata: Option<Vec<Metadatum>>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub mode: Option<TransitRouteItemMode>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub passenger: Option<Person>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub polyline: Option<String>,
}
impl From<&TransitRouteItem> for TransitRouteItem {
  fn from(value: &TransitRouteItem) -> Self {
    value.clone()
  }
}
impl TransitRouteItem {
  pub fn builder() -> builder::TransitRouteItem {
    Default::default()
  }
}
///TransitRouteItemMode
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "enum": [
///    "car",
///    "taxi",
///    "rail",
///    "bus",
///    "ferry",
///    "other"
///  ]
///}
/// ```
/// </details>
#[derive(
  ::serde::Deserialize, ::serde::Serialize, Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd,
)]
pub enum TransitRouteItemMode {
  #[serde(rename = "car")]
  Car,
  #[serde(rename = "taxi")]
  Taxi,
  #[serde(rename = "rail")]
  Rail,
  #[serde(rename = "bus")]
  Bus,
  #[serde(rename = "ferry")]
  Ferry,
  #[serde(rename = "other")]
  Other,
}
impl From<&TransitRouteItemMode> for TransitRouteItemMode {
  fn from(value: &TransitRouteItemMode) -> Self {
    value.clone()
  }
}
impl ::std::fmt::Display for TransitRouteItemMode {
  fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
    match *self {
      Self::Car => write!(f, "car"),
      Self::Taxi => write!(f, "taxi"),
      Self::Rail => write!(f, "rail"),
      Self::Bus => write!(f, "bus"),
      Self::Ferry => write!(f, "ferry"),
      Self::Other => write!(f, "other"),
    }
  }
}
impl std::str::FromStr for TransitRouteItemMode {
  type Err = self::error::ConversionError;
  fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
    match value {
      "car" => Ok(Self::Car),
      "taxi" => Ok(Self::Taxi),
      "rail" => Ok(Self::Rail),
      "bus" => Ok(Self::Bus),
      "ferry" => Ok(Self::Ferry),
      "other" => Ok(Self::Other),
      _ => Err("invalid value".into()),
    }
  }
}
impl std::convert::TryFrom<&str> for TransitRouteItemMode {
  type Error = self::error::ConversionError;
  fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl std::convert::TryFrom<&String> for TransitRouteItemMode {
  type Error = self::error::ConversionError;
  fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
impl std::convert::TryFrom<String> for TransitRouteItemMode {
  type Error = self::error::ConversionError;
  fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
    value.parse()
  }
}
///Trip
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Trip",
///  "type": "object",
///  "properties": {
///    "description": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "id": {
///      "type": [
///        "string",
///        "null"
///      ]
///    },
///    "name": {
///      "type": [
///        "string",
///        "null"
///      ]
///    }
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Trip {
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub description: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub id: Option<String>,
  #[serde(default, skip_serializing_if = "Option::is_none")]
  pub name: Option<String>,
}
impl From<&Trip> for Trip {
  fn from(value: &Trip) -> Self {
    value.clone()
  }
}
impl Trip {
  pub fn builder() -> builder::Trip {
    Default::default()
  }
}
/// Types for composing complex structures.
pub mod builder {
  #[derive(Clone, Debug)]
  pub struct Address {
    city: Result<Option<String>, String>,
    country: Result<Option<super::AddressCountry>, String>,
    lat: Result<Option<f64>, String>,
    lon: Result<Option<f64>, String>,
    postal_code: Result<Option<String>, String>,
    region: Result<Option<super::AddressRegion>, String>,
    street_address: Result<Option<String>, String>,
    tz: Result<Option<String>, String>,
  }
  impl Default for Address {
    fn default() -> Self {
      Self {
        city: Ok(Default::default()),
        country: Ok(Default::default()),
        lat: Ok(Default::default()),
        lon: Ok(Default::default()),
        postal_code: Ok(Default::default()),
        region: Ok(Default::default()),
        street_address: Ok(Default::default()),
        tz: Ok(Default::default()),
      }
    }
  }
  impl Address {
    pub fn city<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.city = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for city: {}", e));
      self
    }
    pub fn country<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::AddressCountry>>,
      T::Error: std::fmt::Display,
    {
      self.country = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for country: {}", e));
      self
    }
    pub fn lat<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<f64>>,
      T::Error: std::fmt::Display,
    {
      self.lat = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for lat: {}", e));
      self
    }
    pub fn lon<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<f64>>,
      T::Error: std::fmt::Display,
    {
      self.lon = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for lon: {}", e));
      self
    }
    pub fn postal_code<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.postal_code = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for postal_code: {}", e));
      self
    }
    pub fn region<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::AddressRegion>>,
      T::Error: std::fmt::Display,
    {
      self.region = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for region: {}", e));
      self
    }
    pub fn street_address<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.street_address = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for street_address: {}", e));
      self
    }
    pub fn tz<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.tz = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for tz: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Address> for super::Address {
    type Error = super::error::ConversionError;
    fn try_from(value: Address) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        city: value.city?,
        country: value.country?,
        lat: value.lat?,
        lon: value.lon?,
        postal_code: value.postal_code?,
        region: value.region?,
        street_address: value.street_address?,
        tz: value.tz?,
      })
    }
  }
  impl From<super::Address> for Address {
    fn from(value: super::Address) -> Self {
      Self {
        city: Ok(value.city),
        country: Ok(value.country),
        lat: Ok(value.lat),
        lon: Ok(value.lon),
        postal_code: Ok(value.postal_code),
        region: Ok(value.region),
        street_address: Ok(value.street_address),
        tz: Ok(value.tz),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct CarRental {
    confirmation_number: Result<Option<String>, String>,
    drivers: Result<Option<Vec<super::Person>>, String>,
    items: Result<Vec<super::Item>, String>,
    metadata: Result<Option<Vec<super::Metadatum>>, String>,
    odometer_reading_in: Result<Option<i64>, String>,
    odometer_reading_out: Result<Option<i64>, String>,
    record_locator: Result<Option<String>, String>,
    rental_at: Result<i64, String>,
    rental_location: Result<super::Place, String>,
    return_at: Result<i64, String>,
    return_location: Result<super::Place, String>,
    vehicle: Result<Option<super::CarRentalVehicle>, String>,
    vendor_code: Result<Option<super::CarRentalVendorCode>, String>,
  }
  impl Default for CarRental {
    fn default() -> Self {
      Self {
        confirmation_number: Ok(Default::default()),
        drivers: Ok(Default::default()),
        items: Err("no value supplied for items".to_string()),
        metadata: Ok(Default::default()),
        odometer_reading_in: Ok(Default::default()),
        odometer_reading_out: Ok(Default::default()),
        record_locator: Ok(Default::default()),
        rental_at: Err("no value supplied for rental_at".to_string()),
        rental_location: Err("no value supplied for rental_location".to_string()),
        return_at: Err("no value supplied for return_at".to_string()),
        return_location: Err("no value supplied for return_location".to_string()),
        vehicle: Ok(Default::default()),
        vendor_code: Ok(Default::default()),
      }
    }
  }
  impl CarRental {
    pub fn confirmation_number<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.confirmation_number = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for confirmation_number: {}",
          e
        )
      });
      self
    }
    pub fn drivers<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<Vec<super::Person>>>,
      T::Error: std::fmt::Display,
    {
      self.drivers = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for drivers: {}", e));
      self
    }
    pub fn items<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Vec<super::Item>>,
      T::Error: std::fmt::Display,
    {
      self.items = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for items: {}", e));
      self
    }
    pub fn metadata<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<Vec<super::Metadatum>>>,
      T::Error: std::fmt::Display,
    {
      self.metadata = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for metadata: {}", e));
      self
    }
    pub fn odometer_reading_in<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<i64>>,
      T::Error: std::fmt::Display,
    {
      self.odometer_reading_in = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for odometer_reading_in: {}",
          e
        )
      });
      self
    }
    pub fn odometer_reading_out<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<i64>>,
      T::Error: std::fmt::Display,
    {
      self.odometer_reading_out = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for odometer_reading_out: {}",
          e
        )
      });
      self
    }
    pub fn record_locator<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.record_locator = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for record_locator: {}", e));
      self
    }
    pub fn rental_at<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<i64>,
      T::Error: std::fmt::Display,
    {
      self.rental_at = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for rental_at: {}", e));
      self
    }
    pub fn rental_location<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<super::Place>,
      T::Error: std::fmt::Display,
    {
      self.rental_location = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for rental_location: {}", e));
      self
    }
    pub fn return_at<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<i64>,
      T::Error: std::fmt::Display,
    {
      self.return_at = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for return_at: {}", e));
      self
    }
    pub fn return_location<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<super::Place>,
      T::Error: std::fmt::Display,
    {
      self.return_location = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for return_location: {}", e));
      self
    }
    pub fn vehicle<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::CarRentalVehicle>>,
      T::Error: std::fmt::Display,
    {
      self.vehicle = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for vehicle: {}", e));
      self
    }
    pub fn vendor_code<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::CarRentalVendorCode>>,
      T::Error: std::fmt::Display,
    {
      self.vendor_code = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for vendor_code: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<CarRental> for super::CarRental {
    type Error = super::error::ConversionError;
    fn try_from(value: CarRental) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        confirmation_number: value.confirmation_number?,
        drivers: value.drivers?,
        items: value.items?,
        metadata: value.metadata?,
        odometer_reading_in: value.odometer_reading_in?,
        odometer_reading_out: value.odometer_reading_out?,
        record_locator: value.record_locator?,
        rental_at: value.rental_at?,
        rental_location: value.rental_location?,
        return_at: value.return_at?,
        return_location: value.return_location?,
        vehicle: value.vehicle?,
        vendor_code: value.vendor_code?,
      })
    }
  }
  impl From<super::CarRental> for CarRental {
    fn from(value: super::CarRental) -> Self {
      Self {
        confirmation_number: Ok(value.confirmation_number),
        drivers: Ok(value.drivers),
        items: Ok(value.items),
        metadata: Ok(value.metadata),
        odometer_reading_in: Ok(value.odometer_reading_in),
        odometer_reading_out: Ok(value.odometer_reading_out),
        record_locator: Ok(value.record_locator),
        rental_at: Ok(value.rental_at),
        rental_location: Ok(value.rental_location),
        return_at: Ok(value.return_at),
        return_location: Ok(value.return_location),
        vehicle: Ok(value.vehicle),
        vendor_code: Ok(value.vendor_code),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct CarRentalVehicle {
    description: Result<String, String>,
    image: Result<Option<String>, String>,
    license_plate_number: Result<Option<String>, String>,
    vehicle_class: Result<Option<super::CarRentalVehicleVehicleClass>, String>,
  }
  impl Default for CarRentalVehicle {
    fn default() -> Self {
      Self {
        description: Err("no value supplied for description".to_string()),
        image: Ok(Default::default()),
        license_plate_number: Ok(Default::default()),
        vehicle_class: Ok(Default::default()),
      }
    }
  }
  impl CarRentalVehicle {
    pub fn description<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<String>,
      T::Error: std::fmt::Display,
    {
      self.description = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for description: {}", e));
      self
    }
    pub fn image<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.image = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for image: {}", e));
      self
    }
    pub fn license_plate_number<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.license_plate_number = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for license_plate_number: {}",
          e
        )
      });
      self
    }
    pub fn vehicle_class<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::CarRentalVehicleVehicleClass>>,
      T::Error: std::fmt::Display,
    {
      self.vehicle_class = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for vehicle_class: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<CarRentalVehicle> for super::CarRentalVehicle {
    type Error = super::error::ConversionError;
    fn try_from(value: CarRentalVehicle) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        description: value.description?,
        image: value.image?,
        license_plate_number: value.license_plate_number?,
        vehicle_class: value.vehicle_class?,
      })
    }
  }
  impl From<super::CarRentalVehicle> for CarRentalVehicle {
    fn from(value: super::CarRentalVehicle) -> Self {
      Self {
        description: Ok(value.description),
        image: Ok(value.image),
        license_plate_number: Ok(value.license_plate_number),
        vehicle_class: Ok(value.vehicle_class),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Customer {
    address: Result<Option<super::Address>, String>,
    booker: Result<Option<super::Person>, String>,
    email: Result<Option<String>, String>,
    metadata: Result<Option<Vec<super::Metadatum>>, String>,
    name: Result<String, String>,
    phone: Result<Option<super::CustomerPhone>, String>,
    website: Result<Option<String>, String>,
  }
  impl Default for Customer {
    fn default() -> Self {
      Self {
        address: Ok(Default::default()),
        booker: Ok(Default::default()),
        email: Ok(Default::default()),
        metadata: Ok(Default::default()),
        name: Err("no value supplied for name".to_string()),
        phone: Ok(Default::default()),
        website: Ok(Default::default()),
      }
    }
  }
  impl Customer {
    pub fn address<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Address>>,
      T::Error: std::fmt::Display,
    {
      self.address = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for address: {}", e));
      self
    }
    pub fn booker<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Person>>,
      T::Error: std::fmt::Display,
    {
      self.booker = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for booker: {}", e));
      self
    }
    pub fn email<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.email = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for email: {}", e));
      self
    }
    pub fn metadata<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<Vec<super::Metadatum>>>,
      T::Error: std::fmt::Display,
    {
      self.metadata = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for metadata: {}", e));
      self
    }
    pub fn name<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<String>,
      T::Error: std::fmt::Display,
    {
      self.name = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for name: {}", e));
      self
    }
    pub fn phone<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::CustomerPhone>>,
      T::Error: std::fmt::Display,
    {
      self.phone = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for phone: {}", e));
      self
    }
    pub fn website<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.website = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for website: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Customer> for super::Customer {
    type Error = super::error::ConversionError;
    fn try_from(value: Customer) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        address: value.address?,
        booker: value.booker?,
        email: value.email?,
        metadata: value.metadata?,
        name: value.name?,
        phone: value.phone?,
        website: value.website?,
      })
    }
  }
  impl From<super::Customer> for Customer {
    fn from(value: super::Customer) -> Self {
      Self {
        address: Ok(value.address),
        booker: Ok(value.booker),
        email: Ok(value.email),
        metadata: Ok(value.metadata),
        name: Ok(value.name),
        phone: Ok(value.phone),
        website: Ok(value.website),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Doc {
    body: Result<String, String>,
    title: Result<String, String>,
  }
  impl Default for Doc {
    fn default() -> Self {
      Self {
        body: Err("no value supplied for body".to_string()),
        title: Err("no value supplied for title".to_string()),
      }
    }
  }
  impl Doc {
    pub fn body<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<String>,
      T::Error: std::fmt::Display,
    {
      self.body = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for body: {}", e));
      self
    }
    pub fn title<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<String>,
      T::Error: std::fmt::Display,
    {
      self.title = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for title: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Doc> for super::Doc {
    type Error = super::error::ConversionError;
    fn try_from(value: Doc) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        body: value.body?,
        title: value.title?,
      })
    }
  }
  impl From<super::Doc> for Doc {
    fn from(value: super::Doc) -> Self {
      Self {
        body: Ok(value.body),
        title: Ok(value.title),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Flight {
    itinerary_locator: Result<Option<String>, String>,
    tickets: Result<Vec<super::FlightTicket>, String>,
  }
  impl Default for Flight {
    fn default() -> Self {
      Self {
        itinerary_locator: Ok(Default::default()),
        tickets: Err("no value supplied for tickets".to_string()),
      }
    }
  }
  impl Flight {
    pub fn itinerary_locator<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.itinerary_locator = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for itinerary_locator: {}",
          e
        )
      });
      self
    }
    pub fn tickets<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Vec<super::FlightTicket>>,
      T::Error: std::fmt::Display,
    {
      self.tickets = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for tickets: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Flight> for super::Flight {
    type Error = super::error::ConversionError;
    fn try_from(value: Flight) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        itinerary_locator: value.itinerary_locator?,
        tickets: value.tickets?,
      })
    }
  }
  impl From<super::Flight> for Flight {
    fn from(value: super::Flight) -> Self {
      Self {
        itinerary_locator: Ok(value.itinerary_locator),
        tickets: Ok(value.tickets),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct FlightSegment {
    aircraft_type: Result<Option<super::FlightSegmentAircraftType>, String>,
    arrival_airport_code: Result<super::FlightSegmentArrivalAirportCode, String>,
    arrival_at: Result<Option<i64>, String>,
    arrival_tz: Result<Option<String>, String>,
    class_of_service: Result<Option<String>, String>,
    departure_airport_code: Result<super::FlightSegmentDepartureAirportCode, String>,
    departure_at: Result<Option<i64>, String>,
    departure_tz: Result<Option<String>, String>,
    flight_number: Result<Option<String>, String>,
    metadata: Result<Option<Vec<super::Metadatum>>, String>,
    seat: Result<Option<String>, String>,
  }
  impl Default for FlightSegment {
    fn default() -> Self {
      Self {
        aircraft_type: Ok(Default::default()),
        arrival_airport_code: Err("no value supplied for arrival_airport_code".to_string()),
        arrival_at: Ok(Default::default()),
        arrival_tz: Ok(Default::default()),
        class_of_service: Ok(Default::default()),
        departure_airport_code: Err("no value supplied for departure_airport_code".to_string()),
        departure_at: Ok(Default::default()),
        departure_tz: Ok(Default::default()),
        flight_number: Ok(Default::default()),
        metadata: Ok(Default::default()),
        seat: Ok(Default::default()),
      }
    }
  }
  impl FlightSegment {
    pub fn aircraft_type<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::FlightSegmentAircraftType>>,
      T::Error: std::fmt::Display,
    {
      self.aircraft_type = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for aircraft_type: {}", e));
      self
    }
    pub fn arrival_airport_code<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<super::FlightSegmentArrivalAirportCode>,
      T::Error: std::fmt::Display,
    {
      self.arrival_airport_code = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for arrival_airport_code: {}",
          e
        )
      });
      self
    }
    pub fn arrival_at<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<i64>>,
      T::Error: std::fmt::Display,
    {
      self.arrival_at = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for arrival_at: {}", e));
      self
    }
    pub fn arrival_tz<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.arrival_tz = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for arrival_tz: {}", e));
      self
    }
    pub fn class_of_service<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.class_of_service = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for class_of_service: {}",
          e
        )
      });
      self
    }
    pub fn departure_airport_code<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<super::FlightSegmentDepartureAirportCode>,
      T::Error: std::fmt::Display,
    {
      self.departure_airport_code = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for departure_airport_code: {}",
          e
        )
      });
      self
    }
    pub fn departure_at<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<i64>>,
      T::Error: std::fmt::Display,
    {
      self.departure_at = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for departure_at: {}", e));
      self
    }
    pub fn departure_tz<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.departure_tz = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for departure_tz: {}", e));
      self
    }
    pub fn flight_number<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.flight_number = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for flight_number: {}", e));
      self
    }
    pub fn metadata<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<Vec<super::Metadatum>>>,
      T::Error: std::fmt::Display,
    {
      self.metadata = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for metadata: {}", e));
      self
    }
    pub fn seat<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.seat = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for seat: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<FlightSegment> for super::FlightSegment {
    type Error = super::error::ConversionError;
    fn try_from(value: FlightSegment) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        aircraft_type: value.aircraft_type?,
        arrival_airport_code: value.arrival_airport_code?,
        arrival_at: value.arrival_at?,
        arrival_tz: value.arrival_tz?,
        class_of_service: value.class_of_service?,
        departure_airport_code: value.departure_airport_code?,
        departure_at: value.departure_at?,
        departure_tz: value.departure_tz?,
        flight_number: value.flight_number?,
        metadata: value.metadata?,
        seat: value.seat?,
      })
    }
  }
  impl From<super::FlightSegment> for FlightSegment {
    fn from(value: super::FlightSegment) -> Self {
      Self {
        aircraft_type: Ok(value.aircraft_type),
        arrival_airport_code: Ok(value.arrival_airport_code),
        arrival_at: Ok(value.arrival_at),
        arrival_tz: Ok(value.arrival_tz),
        class_of_service: Ok(value.class_of_service),
        departure_airport_code: Ok(value.departure_airport_code),
        departure_at: Ok(value.departure_at),
        departure_tz: Ok(value.departure_tz),
        flight_number: Ok(value.flight_number),
        metadata: Ok(value.metadata),
        seat: Ok(value.seat),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct FlightTicket {
    number: Result<Option<String>, String>,
    passenger: Result<Option<super::Person>, String>,
    record_locator: Result<Option<String>, String>,
    segments: Result<Vec<super::FlightSegment>, String>,
  }
  impl Default for FlightTicket {
    fn default() -> Self {
      Self {
        number: Ok(Default::default()),
        passenger: Ok(Default::default()),
        record_locator: Ok(Default::default()),
        segments: Err("no value supplied for segments".to_string()),
      }
    }
  }
  impl FlightTicket {
    pub fn number<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.number = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for number: {}", e));
      self
    }
    pub fn passenger<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Person>>,
      T::Error: std::fmt::Display,
    {
      self.passenger = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for passenger: {}", e));
      self
    }
    pub fn record_locator<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.record_locator = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for record_locator: {}", e));
      self
    }
    pub fn segments<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Vec<super::FlightSegment>>,
      T::Error: std::fmt::Display,
    {
      self.segments = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for segments: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<FlightTicket> for super::FlightTicket {
    type Error = super::error::ConversionError;
    fn try_from(value: FlightTicket) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        number: value.number?,
        passenger: value.passenger?,
        record_locator: value.record_locator?,
        segments: value.segments?,
      })
    }
  }
  impl From<super::FlightTicket> for FlightTicket {
    fn from(value: super::FlightTicket) -> Self {
      Self {
        number: Ok(value.number),
        passenger: Ok(value.passenger),
        record_locator: Ok(value.record_locator),
        segments: Ok(value.segments),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Footer {
    supplemental_text: Result<Option<String>, String>,
  }
  impl Default for Footer {
    fn default() -> Self {
      Self {
        supplemental_text: Ok(Default::default()),
      }
    }
  }
  impl Footer {
    pub fn supplemental_text<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.supplemental_text = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for supplemental_text: {}",
          e
        )
      });
      self
    }
  }
  impl std::convert::TryFrom<Footer> for super::Footer {
    type Error = super::error::ConversionError;
    fn try_from(value: Footer) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        supplemental_text: value.supplemental_text?,
      })
    }
  }
  impl From<super::Footer> for Footer {
    fn from(value: super::Footer) -> Self {
      Self {
        supplemental_text: Ok(value.supplemental_text),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Header {
    booked_at: Result<Option<i64>, String>,
    customer: Result<Option<super::Customer>, String>,
    lifecycle_status: Result<Option<super::LifecycleStatus>, String>,
    third_party: Result<Option<super::HeaderThirdParty>, String>,
    trip: Result<Option<super::Trip>, String>,
  }
  impl Default for Header {
    fn default() -> Self {
      Self {
        booked_at: Ok(Default::default()),
        customer: Ok(Default::default()),
        lifecycle_status: Ok(Default::default()),
        third_party: Ok(Default::default()),
        trip: Ok(Default::default()),
      }
    }
  }
  impl Header {
    pub fn booked_at<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<i64>>,
      T::Error: std::fmt::Display,
    {
      self.booked_at = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for booked_at: {}", e));
      self
    }
    pub fn customer<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Customer>>,
      T::Error: std::fmt::Display,
    {
      self.customer = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for customer: {}", e));
      self
    }
    pub fn lifecycle_status<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::LifecycleStatus>>,
      T::Error: std::fmt::Display,
    {
      self.lifecycle_status = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for lifecycle_status: {}",
          e
        )
      });
      self
    }
    pub fn third_party<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::HeaderThirdParty>>,
      T::Error: std::fmt::Display,
    {
      self.third_party = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for third_party: {}", e));
      self
    }
    pub fn trip<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Trip>>,
      T::Error: std::fmt::Display,
    {
      self.trip = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for trip: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Header> for super::Header {
    type Error = super::error::ConversionError;
    fn try_from(value: Header) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        booked_at: value.booked_at?,
        customer: value.customer?,
        lifecycle_status: value.lifecycle_status?,
        third_party: value.third_party?,
        trip: value.trip?,
      })
    }
  }
  impl From<super::Header> for Header {
    fn from(value: super::Header) -> Self {
      Self {
        booked_at: Ok(value.booked_at),
        customer: Ok(value.customer),
        lifecycle_status: Ok(value.lifecycle_status),
        third_party: Ok(value.third_party),
        trip: Ok(value.trip),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct HeaderThirdParty {
    make_primary: Result<bool, String>,
    merchant: Result<Option<super::Org>, String>,
    relation: Result<super::HeaderThirdPartyRelation, String>,
  }
  impl Default for HeaderThirdParty {
    fn default() -> Self {
      Self {
        make_primary: Err("no value supplied for make_primary".to_string()),
        merchant: Ok(Default::default()),
        relation: Err("no value supplied for relation".to_string()),
      }
    }
  }
  impl HeaderThirdParty {
    pub fn make_primary<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<bool>,
      T::Error: std::fmt::Display,
    {
      self.make_primary = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for make_primary: {}", e));
      self
    }
    pub fn merchant<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Org>>,
      T::Error: std::fmt::Display,
    {
      self.merchant = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for merchant: {}", e));
      self
    }
    pub fn relation<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<super::HeaderThirdPartyRelation>,
      T::Error: std::fmt::Display,
    {
      self.relation = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for relation: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<HeaderThirdParty> for super::HeaderThirdParty {
    type Error = super::error::ConversionError;
    fn try_from(value: HeaderThirdParty) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        make_primary: value.make_primary?,
        merchant: value.merchant?,
        relation: value.relation?,
      })
    }
  }
  impl From<super::HeaderThirdParty> for HeaderThirdParty {
    fn from(value: super::HeaderThirdParty) -> Self {
      Self {
        make_primary: Ok(value.make_primary),
        merchant: Ok(value.merchant),
        relation: Ok(value.relation),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Item {
    date: Result<Option<String>, String>,
    description: Result<String, String>,
    group: Result<Option<String>, String>,
    metadata: Result<Option<Vec<super::Metadatum>>, String>,
    product_image_asset_id: Result<Option<String>, String>,
    quantity: Result<Option<f64>, String>,
    unit: Result<Option<String>, String>,
    unspsc: Result<Option<super::ItemUnspsc>, String>,
    url: Result<Option<String>, String>,
  }
  impl Default for Item {
    fn default() -> Self {
      Self {
        date: Ok(Default::default()),
        description: Err("no value supplied for description".to_string()),
        group: Ok(Default::default()),
        metadata: Ok(Default::default()),
        product_image_asset_id: Ok(Default::default()),
        quantity: Ok(Default::default()),
        unit: Ok(Default::default()),
        unspsc: Ok(Default::default()),
        url: Ok(Default::default()),
      }
    }
  }
  impl Item {
    pub fn date<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.date = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for date: {}", e));
      self
    }
    pub fn description<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<String>,
      T::Error: std::fmt::Display,
    {
      self.description = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for description: {}", e));
      self
    }
    pub fn group<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.group = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for group: {}", e));
      self
    }
    pub fn metadata<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<Vec<super::Metadatum>>>,
      T::Error: std::fmt::Display,
    {
      self.metadata = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for metadata: {}", e));
      self
    }
    pub fn product_image_asset_id<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.product_image_asset_id = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for product_image_asset_id: {}",
          e
        )
      });
      self
    }
    pub fn quantity<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<f64>>,
      T::Error: std::fmt::Display,
    {
      self.quantity = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for quantity: {}", e));
      self
    }
    pub fn unit<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.unit = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for unit: {}", e));
      self
    }
    pub fn unspsc<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::ItemUnspsc>>,
      T::Error: std::fmt::Display,
    {
      self.unspsc = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for unspsc: {}", e));
      self
    }
    pub fn url<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.url = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for url: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Item> for super::Item {
    type Error = super::error::ConversionError;
    fn try_from(value: Item) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        date: value.date?,
        description: value.description?,
        group: value.group?,
        metadata: value.metadata?,
        product_image_asset_id: value.product_image_asset_id?,
        quantity: value.quantity?,
        unit: value.unit?,
        unspsc: value.unspsc?,
        url: value.url?,
      })
    }
  }
  impl From<super::Item> for Item {
    fn from(value: super::Item) -> Self {
      Self {
        date: Ok(value.date),
        description: Ok(value.description),
        group: Ok(value.group),
        metadata: Ok(value.metadata),
        product_image_asset_id: Ok(value.product_image_asset_id),
        quantity: Ok(value.quantity),
        unit: Ok(value.unit),
        unspsc: Ok(value.unspsc),
        url: Ok(value.url),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Itemization {
    car_rental: Result<Option<super::CarRental>, String>,
    flight: Result<Option<super::Flight>, String>,
    lodging: Result<Option<super::Lodging>, String>,
    service: Result<Option<super::Service>, String>,
    transit_route: Result<Option<super::TransitRoute>, String>,
  }
  impl Default for Itemization {
    fn default() -> Self {
      Self {
        car_rental: Ok(Default::default()),
        flight: Ok(Default::default()),
        lodging: Ok(Default::default()),
        service: Ok(Default::default()),
        transit_route: Ok(Default::default()),
      }
    }
  }
  impl Itemization {
    pub fn car_rental<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::CarRental>>,
      T::Error: std::fmt::Display,
    {
      self.car_rental = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for car_rental: {}", e));
      self
    }
    pub fn flight<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Flight>>,
      T::Error: std::fmt::Display,
    {
      self.flight = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for flight: {}", e));
      self
    }
    pub fn lodging<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Lodging>>,
      T::Error: std::fmt::Display,
    {
      self.lodging = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for lodging: {}", e));
      self
    }
    pub fn service<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Service>>,
      T::Error: std::fmt::Display,
    {
      self.service = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for service: {}", e));
      self
    }
    pub fn transit_route<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::TransitRoute>>,
      T::Error: std::fmt::Display,
    {
      self.transit_route = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for transit_route: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Itemization> for super::Itemization {
    type Error = super::error::ConversionError;
    fn try_from(value: Itemization) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        car_rental: value.car_rental?,
        flight: value.flight?,
        lodging: value.lodging?,
        service: value.service?,
        transit_route: value.transit_route?,
      })
    }
  }
  impl From<super::Itemization> for Itemization {
    fn from(value: super::Itemization) -> Self {
      Self {
        car_rental: Ok(value.car_rental),
        flight: Ok(value.flight),
        lodging: Ok(value.lodging),
        service: Ok(value.service),
        transit_route: Ok(value.transit_route),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Itinerary {
    footer: Result<Option<super::Footer>, String>,
    header: Result<super::Header, String>,
    itemization: Result<super::Itemization, String>,
    schema_version: Result<super::SchemaVersion, String>,
  }
  impl Default for Itinerary {
    fn default() -> Self {
      Self {
        footer: Ok(Default::default()),
        header: Err("no value supplied for header".to_string()),
        itemization: Err("no value supplied for itemization".to_string()),
        schema_version: Err("no value supplied for schema_version".to_string()),
      }
    }
  }
  impl Itinerary {
    pub fn footer<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Footer>>,
      T::Error: std::fmt::Display,
    {
      self.footer = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for footer: {}", e));
      self
    }
    pub fn header<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<super::Header>,
      T::Error: std::fmt::Display,
    {
      self.header = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for header: {}", e));
      self
    }
    pub fn itemization<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<super::Itemization>,
      T::Error: std::fmt::Display,
    {
      self.itemization = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for itemization: {}", e));
      self
    }
    pub fn schema_version<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<super::SchemaVersion>,
      T::Error: std::fmt::Display,
    {
      self.schema_version = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for schema_version: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Itinerary> for super::Itinerary {
    type Error = super::error::ConversionError;
    fn try_from(value: Itinerary) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        footer: value.footer?,
        header: value.header?,
        itemization: value.itemization?,
        schema_version: value.schema_version?,
      })
    }
  }
  impl From<super::Itinerary> for Itinerary {
    fn from(value: super::Itinerary) -> Self {
      Self {
        footer: Ok(value.footer),
        header: Ok(value.header),
        itemization: Ok(value.itemization),
        schema_version: Ok(value.schema_version),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Lodging {
    chain_code: Result<Option<super::LodgingChainCode>, String>,
    check_in: Result<i64, String>,
    check_out: Result<i64, String>,
    confirmation_number: Result<Option<String>, String>,
    guests: Result<Option<Vec<super::Person>>, String>,
    items: Result<Vec<super::Item>, String>,
    location: Result<super::Place, String>,
    metadata: Result<Option<Vec<super::Metadatum>>, String>,
    property_id: Result<Option<String>, String>,
    record_locator: Result<Option<String>, String>,
    room: Result<Option<String>, String>,
  }
  impl Default for Lodging {
    fn default() -> Self {
      Self {
        chain_code: Ok(Default::default()),
        check_in: Err("no value supplied for check_in".to_string()),
        check_out: Err("no value supplied for check_out".to_string()),
        confirmation_number: Ok(Default::default()),
        guests: Ok(Default::default()),
        items: Err("no value supplied for items".to_string()),
        location: Err("no value supplied for location".to_string()),
        metadata: Ok(Default::default()),
        property_id: Ok(Default::default()),
        record_locator: Ok(Default::default()),
        room: Ok(Default::default()),
      }
    }
  }
  impl Lodging {
    pub fn chain_code<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::LodgingChainCode>>,
      T::Error: std::fmt::Display,
    {
      self.chain_code = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for chain_code: {}", e));
      self
    }
    pub fn check_in<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<i64>,
      T::Error: std::fmt::Display,
    {
      self.check_in = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for check_in: {}", e));
      self
    }
    pub fn check_out<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<i64>,
      T::Error: std::fmt::Display,
    {
      self.check_out = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for check_out: {}", e));
      self
    }
    pub fn confirmation_number<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.confirmation_number = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for confirmation_number: {}",
          e
        )
      });
      self
    }
    pub fn guests<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<Vec<super::Person>>>,
      T::Error: std::fmt::Display,
    {
      self.guests = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for guests: {}", e));
      self
    }
    pub fn items<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Vec<super::Item>>,
      T::Error: std::fmt::Display,
    {
      self.items = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for items: {}", e));
      self
    }
    pub fn location<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<super::Place>,
      T::Error: std::fmt::Display,
    {
      self.location = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for location: {}", e));
      self
    }
    pub fn metadata<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<Vec<super::Metadatum>>>,
      T::Error: std::fmt::Display,
    {
      self.metadata = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for metadata: {}", e));
      self
    }
    pub fn property_id<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.property_id = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for property_id: {}", e));
      self
    }
    pub fn record_locator<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.record_locator = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for record_locator: {}", e));
      self
    }
    pub fn room<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.room = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for room: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Lodging> for super::Lodging {
    type Error = super::error::ConversionError;
    fn try_from(value: Lodging) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        chain_code: value.chain_code?,
        check_in: value.check_in?,
        check_out: value.check_out?,
        confirmation_number: value.confirmation_number?,
        guests: value.guests?,
        items: value.items?,
        location: value.location?,
        metadata: value.metadata?,
        property_id: value.property_id?,
        record_locator: value.record_locator?,
        room: value.room?,
      })
    }
  }
  impl From<super::Lodging> for Lodging {
    fn from(value: super::Lodging) -> Self {
      Self {
        chain_code: Ok(value.chain_code),
        check_in: Ok(value.check_in),
        check_out: Ok(value.check_out),
        confirmation_number: Ok(value.confirmation_number),
        guests: Ok(value.guests),
        items: Ok(value.items),
        location: Ok(value.location),
        metadata: Ok(value.metadata),
        property_id: Ok(value.property_id),
        record_locator: Ok(value.record_locator),
        room: Ok(value.room),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Metadatum {
    key: Result<String, String>,
    value: Result<String, String>,
  }
  impl Default for Metadatum {
    fn default() -> Self {
      Self {
        key: Err("no value supplied for key".to_string()),
        value: Err("no value supplied for value".to_string()),
      }
    }
  }
  impl Metadatum {
    pub fn key<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<String>,
      T::Error: std::fmt::Display,
    {
      self.key = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for key: {}", e));
      self
    }
    pub fn value<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<String>,
      T::Error: std::fmt::Display,
    {
      self.value = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for value: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Metadatum> for super::Metadatum {
    type Error = super::error::ConversionError;
    fn try_from(value: Metadatum) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        key: value.key?,
        value: value.value?,
      })
    }
  }
  impl From<super::Metadatum> for Metadatum {
    fn from(value: super::Metadatum) -> Self {
      Self {
        key: Ok(value.key),
        value: Ok(value.value),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Org {
    address: Result<Option<super::Address>, String>,
    brand_color: Result<Option<super::OrgBrandColor>, String>,
    legal_name: Result<Option<String>, String>,
    logo: Result<Option<String>, String>,
    logo_asset_id: Result<Option<String>, String>,
    name: Result<String, String>,
    vat_number: Result<Option<String>, String>,
    website: Result<Option<String>, String>,
  }
  impl Default for Org {
    fn default() -> Self {
      Self {
        address: Ok(Default::default()),
        brand_color: Ok(Default::default()),
        legal_name: Ok(Default::default()),
        logo: Ok(Default::default()),
        logo_asset_id: Ok(Default::default()),
        name: Err("no value supplied for name".to_string()),
        vat_number: Ok(Default::default()),
        website: Ok(Default::default()),
      }
    }
  }
  impl Org {
    pub fn address<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Address>>,
      T::Error: std::fmt::Display,
    {
      self.address = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for address: {}", e));
      self
    }
    pub fn brand_color<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::OrgBrandColor>>,
      T::Error: std::fmt::Display,
    {
      self.brand_color = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for brand_color: {}", e));
      self
    }
    pub fn legal_name<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.legal_name = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for legal_name: {}", e));
      self
    }
    pub fn logo<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.logo = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for logo: {}", e));
      self
    }
    pub fn logo_asset_id<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.logo_asset_id = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for logo_asset_id: {}", e));
      self
    }
    pub fn name<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<String>,
      T::Error: std::fmt::Display,
    {
      self.name = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for name: {}", e));
      self
    }
    pub fn vat_number<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.vat_number = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for vat_number: {}", e));
      self
    }
    pub fn website<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.website = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for website: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Org> for super::Org {
    type Error = super::error::ConversionError;
    fn try_from(value: Org) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        address: value.address?,
        brand_color: value.brand_color?,
        legal_name: value.legal_name?,
        logo: value.logo?,
        logo_asset_id: value.logo_asset_id?,
        name: value.name?,
        vat_number: value.vat_number?,
        website: value.website?,
      })
    }
  }
  impl From<super::Org> for Org {
    fn from(value: super::Org) -> Self {
      Self {
        address: Ok(value.address),
        brand_color: Ok(value.brand_color),
        legal_name: Ok(value.legal_name),
        logo: Ok(value.logo),
        logo_asset_id: Ok(value.logo_asset_id),
        name: Ok(value.name),
        vat_number: Ok(value.vat_number),
        website: Ok(value.website),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Person {
    email: Result<Option<String>, String>,
    first_name: Result<Option<String>, String>,
    last_name: Result<Option<String>, String>,
    metadata: Result<Option<Vec<super::Metadatum>>, String>,
    phone: Result<Option<super::PersonPhone>, String>,
    preferred_first_name: Result<Option<String>, String>,
  }
  impl Default for Person {
    fn default() -> Self {
      Self {
        email: Ok(Default::default()),
        first_name: Ok(Default::default()),
        last_name: Ok(Default::default()),
        metadata: Ok(Default::default()),
        phone: Ok(Default::default()),
        preferred_first_name: Ok(Default::default()),
      }
    }
  }
  impl Person {
    pub fn email<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.email = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for email: {}", e));
      self
    }
    pub fn first_name<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.first_name = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for first_name: {}", e));
      self
    }
    pub fn last_name<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.last_name = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for last_name: {}", e));
      self
    }
    pub fn metadata<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<Vec<super::Metadatum>>>,
      T::Error: std::fmt::Display,
    {
      self.metadata = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for metadata: {}", e));
      self
    }
    pub fn phone<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::PersonPhone>>,
      T::Error: std::fmt::Display,
    {
      self.phone = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for phone: {}", e));
      self
    }
    pub fn preferred_first_name<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.preferred_first_name = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for preferred_first_name: {}",
          e
        )
      });
      self
    }
  }
  impl std::convert::TryFrom<Person> for super::Person {
    type Error = super::error::ConversionError;
    fn try_from(value: Person) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        email: value.email?,
        first_name: value.first_name?,
        last_name: value.last_name?,
        metadata: value.metadata?,
        phone: value.phone?,
        preferred_first_name: value.preferred_first_name?,
      })
    }
  }
  impl From<super::Person> for Person {
    fn from(value: super::Person) -> Self {
      Self {
        email: Ok(value.email),
        first_name: Ok(value.first_name),
        last_name: Ok(value.last_name),
        metadata: Ok(value.metadata),
        phone: Ok(value.phone),
        preferred_first_name: Ok(value.preferred_first_name),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Place {
    address: Result<Option<super::Address>, String>,
    google_place_id: Result<Option<String>, String>,
    image: Result<Option<String>, String>,
    name: Result<Option<String>, String>,
    phone: Result<Option<super::PlacePhone>, String>,
    url: Result<Option<String>, String>,
  }
  impl Default for Place {
    fn default() -> Self {
      Self {
        address: Ok(Default::default()),
        google_place_id: Ok(Default::default()),
        image: Ok(Default::default()),
        name: Ok(Default::default()),
        phone: Ok(Default::default()),
        url: Ok(Default::default()),
      }
    }
  }
  impl Place {
    pub fn address<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Address>>,
      T::Error: std::fmt::Display,
    {
      self.address = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for address: {}", e));
      self
    }
    pub fn google_place_id<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.google_place_id = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for google_place_id: {}", e));
      self
    }
    pub fn image<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.image = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for image: {}", e));
      self
    }
    pub fn name<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.name = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for name: {}", e));
      self
    }
    pub fn phone<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::PlacePhone>>,
      T::Error: std::fmt::Display,
    {
      self.phone = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for phone: {}", e));
      self
    }
    pub fn url<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.url = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for url: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Place> for super::Place {
    type Error = super::error::ConversionError;
    fn try_from(value: Place) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        address: value.address?,
        google_place_id: value.google_place_id?,
        image: value.image?,
        name: value.name?,
        phone: value.phone?,
        url: value.url?,
      })
    }
  }
  impl From<super::Place> for Place {
    fn from(value: super::Place) -> Self {
      Self {
        address: Ok(value.address),
        google_place_id: Ok(value.google_place_id),
        image: Ok(value.image),
        name: Ok(value.name),
        phone: Ok(value.phone),
        url: Ok(value.url),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Service {
    service_items: Result<Vec<super::ServiceItem>, String>,
  }
  impl Default for Service {
    fn default() -> Self {
      Self {
        service_items: Err("no value supplied for service_items".to_string()),
      }
    }
  }
  impl Service {
    pub fn service_items<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Vec<super::ServiceItem>>,
      T::Error: std::fmt::Display,
    {
      self.service_items = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for service_items: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Service> for super::Service {
    type Error = super::error::ConversionError;
    fn try_from(value: Service) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        service_items: value.service_items?,
      })
    }
  }
  impl From<super::Service> for Service {
    fn from(value: super::Service) -> Self {
      Self {
        service_items: Ok(value.service_items),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct ServiceItem {
    current_period_end_at: Result<Option<i64>, String>,
    current_period_start_at: Result<Option<i64>, String>,
    description: Result<String, String>,
    metadata: Result<Option<Vec<super::Metadatum>>, String>,
    service_location: Result<Option<super::Place>, String>,
  }
  impl Default for ServiceItem {
    fn default() -> Self {
      Self {
        current_period_end_at: Ok(Default::default()),
        current_period_start_at: Ok(Default::default()),
        description: Err("no value supplied for description".to_string()),
        metadata: Ok(Default::default()),
        service_location: Ok(Default::default()),
      }
    }
  }
  impl ServiceItem {
    pub fn current_period_end_at<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<i64>>,
      T::Error: std::fmt::Display,
    {
      self.current_period_end_at = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for current_period_end_at: {}",
          e
        )
      });
      self
    }
    pub fn current_period_start_at<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<i64>>,
      T::Error: std::fmt::Display,
    {
      self.current_period_start_at = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for current_period_start_at: {}",
          e
        )
      });
      self
    }
    pub fn description<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<String>,
      T::Error: std::fmt::Display,
    {
      self.description = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for description: {}", e));
      self
    }
    pub fn metadata<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<Vec<super::Metadatum>>>,
      T::Error: std::fmt::Display,
    {
      self.metadata = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for metadata: {}", e));
      self
    }
    pub fn service_location<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Place>>,
      T::Error: std::fmt::Display,
    {
      self.service_location = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for service_location: {}",
          e
        )
      });
      self
    }
  }
  impl std::convert::TryFrom<ServiceItem> for super::ServiceItem {
    type Error = super::error::ConversionError;
    fn try_from(value: ServiceItem) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        current_period_end_at: value.current_period_end_at?,
        current_period_start_at: value.current_period_start_at?,
        description: value.description?,
        metadata: value.metadata?,
        service_location: value.service_location?,
      })
    }
  }
  impl From<super::ServiceItem> for ServiceItem {
    fn from(value: super::ServiceItem) -> Self {
      Self {
        current_period_end_at: Ok(value.current_period_end_at),
        current_period_start_at: Ok(value.current_period_start_at),
        description: Ok(value.description),
        metadata: Ok(value.metadata),
        service_location: Ok(value.service_location),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct TransitRoute {
    transit_route_items: Result<Vec<super::TransitRouteItem>, String>,
  }
  impl Default for TransitRoute {
    fn default() -> Self {
      Self {
        transit_route_items: Err("no value supplied for transit_route_items".to_string()),
      }
    }
  }
  impl TransitRoute {
    pub fn transit_route_items<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Vec<super::TransitRouteItem>>,
      T::Error: std::fmt::Display,
    {
      self.transit_route_items = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for transit_route_items: {}",
          e
        )
      });
      self
    }
  }
  impl std::convert::TryFrom<TransitRoute> for super::TransitRoute {
    type Error = super::error::ConversionError;
    fn try_from(value: TransitRoute) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        transit_route_items: value.transit_route_items?,
      })
    }
  }
  impl From<super::TransitRoute> for TransitRoute {
    fn from(value: super::TransitRoute) -> Self {
      Self {
        transit_route_items: Ok(value.transit_route_items),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct TransitRouteItem {
    arrival_at: Result<Option<i64>, String>,
    arrival_location: Result<Option<super::Place>, String>,
    departure_at: Result<Option<i64>, String>,
    departure_location: Result<Option<super::Place>, String>,
    metadata: Result<Option<Vec<super::Metadatum>>, String>,
    mode: Result<Option<super::TransitRouteItemMode>, String>,
    passenger: Result<Option<super::Person>, String>,
    polyline: Result<Option<String>, String>,
  }
  impl Default for TransitRouteItem {
    fn default() -> Self {
      Self {
        arrival_at: Ok(Default::default()),
        arrival_location: Ok(Default::default()),
        departure_at: Ok(Default::default()),
        departure_location: Ok(Default::default()),
        metadata: Ok(Default::default()),
        mode: Ok(Default::default()),
        passenger: Ok(Default::default()),
        polyline: Ok(Default::default()),
      }
    }
  }
  impl TransitRouteItem {
    pub fn arrival_at<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<i64>>,
      T::Error: std::fmt::Display,
    {
      self.arrival_at = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for arrival_at: {}", e));
      self
    }
    pub fn arrival_location<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Place>>,
      T::Error: std::fmt::Display,
    {
      self.arrival_location = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for arrival_location: {}",
          e
        )
      });
      self
    }
    pub fn departure_at<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<i64>>,
      T::Error: std::fmt::Display,
    {
      self.departure_at = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for departure_at: {}", e));
      self
    }
    pub fn departure_location<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Place>>,
      T::Error: std::fmt::Display,
    {
      self.departure_location = value.try_into().map_err(|e| {
        format!(
          "error converting supplied value for departure_location: {}",
          e
        )
      });
      self
    }
    pub fn metadata<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<Vec<super::Metadatum>>>,
      T::Error: std::fmt::Display,
    {
      self.metadata = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for metadata: {}", e));
      self
    }
    pub fn mode<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::TransitRouteItemMode>>,
      T::Error: std::fmt::Display,
    {
      self.mode = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for mode: {}", e));
      self
    }
    pub fn passenger<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<super::Person>>,
      T::Error: std::fmt::Display,
    {
      self.passenger = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for passenger: {}", e));
      self
    }
    pub fn polyline<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.polyline = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for polyline: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<TransitRouteItem> for super::TransitRouteItem {
    type Error = super::error::ConversionError;
    fn try_from(value: TransitRouteItem) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        arrival_at: value.arrival_at?,
        arrival_location: value.arrival_location?,
        departure_at: value.departure_at?,
        departure_location: value.departure_location?,
        metadata: value.metadata?,
        mode: value.mode?,
        passenger: value.passenger?,
        polyline: value.polyline?,
      })
    }
  }
  impl From<super::TransitRouteItem> for TransitRouteItem {
    fn from(value: super::TransitRouteItem) -> Self {
      Self {
        arrival_at: Ok(value.arrival_at),
        arrival_location: Ok(value.arrival_location),
        departure_at: Ok(value.departure_at),
        departure_location: Ok(value.departure_location),
        metadata: Ok(value.metadata),
        mode: Ok(value.mode),
        passenger: Ok(value.passenger),
        polyline: Ok(value.polyline),
      }
    }
  }
  #[derive(Clone, Debug)]
  pub struct Trip {
    description: Result<Option<String>, String>,
    id: Result<Option<String>, String>,
    name: Result<Option<String>, String>,
  }
  impl Default for Trip {
    fn default() -> Self {
      Self {
        description: Ok(Default::default()),
        id: Ok(Default::default()),
        name: Ok(Default::default()),
      }
    }
  }
  impl Trip {
    pub fn description<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.description = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for description: {}", e));
      self
    }
    pub fn id<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.id = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for id: {}", e));
      self
    }
    pub fn name<T>(mut self, value: T) -> Self
    where
      T: std::convert::TryInto<Option<String>>,
      T::Error: std::fmt::Display,
    {
      self.name = value
        .try_into()
        .map_err(|e| format!("error converting supplied value for name: {}", e));
      self
    }
  }
  impl std::convert::TryFrom<Trip> for super::Trip {
    type Error = super::error::ConversionError;
    fn try_from(value: Trip) -> Result<Self, super::error::ConversionError> {
      Ok(Self {
        description: value.description?,
        id: value.id?,
        name: value.name?,
      })
    }
  }
  impl From<super::Trip> for Trip {
    fn from(value: super::Trip) -> Self {
      Self {
        description: Ok(value.description),
        id: Ok(value.id),
        name: Ok(value.name),
      }
    }
  }
}