pub mod error {
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())
}
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct AchPayment {
pub routing_number: String,
}
impl From<&AchPayment> for AchPayment {
fn from(value: &AchPayment) -> Self {
value.clone()
}
}
impl AchPayment {
pub fn builder() -> builder::AchPayment {
Default::default()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Action {
pub name: String,
pub url: String,
}
impl From<&Action> for Action {
fn from(value: &Action) -> Self {
value.clone()
}
}
impl Action {
pub fn builder() -> builder::Action {
Default::default()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Address {
pub city: Option<String>,
pub country: Option<AddressCountry>,
pub lat: Option<f64>,
pub lon: Option<f64>,
pub postal_code: Option<String>,
pub region: Option<AddressRegion>,
pub street_address: Option<String>,
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()
}
}
#[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())
})
}
}
#[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 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 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())
})
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Adjustment {
pub adjustment_type: AdjustmentType,
pub amount: i64,
pub name: Option<String>,
pub rate: Option<f64>,
}
impl From<&Adjustment> for Adjustment {
fn from(value: &Adjustment) -> Self {
value.clone()
}
}
impl Adjustment {
pub fn builder() -> builder::Adjustment {
Default::default()
}
}
#[derive(
::serde::Deserialize,
::serde::Serialize,
Clone,
Copy,
Debug,
Eq,
Hash,
Ord,
PartialEq,
PartialOrd
)]
pub enum AdjustmentType {
#[serde(rename = "discount")]
Discount,
#[serde(rename = "tip")]
Tip,
#[serde(rename = "fee")]
Fee,
#[serde(rename = "other")]
Other,
}
impl From<&AdjustmentType> for AdjustmentType {
fn from(value: &AdjustmentType) -> Self {
value.clone()
}
}
impl ::std::fmt::Display for AdjustmentType {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match *self {
Self::Discount => write!(f, "discount"),
Self::Tip => write!(f, "tip"),
Self::Fee => write!(f, "fee"),
Self::Other => write!(f, "other"),
}
}
}
impl std::str::FromStr for AdjustmentType {
type Err = self::error::ConversionError;
fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
match value {
"discount" => Ok(Self::Discount),
"tip" => Ok(Self::Tip),
"fee" => Ok(Self::Fee),
"other" => Ok(Self::Other),
_ => Err("invalid value".into()),
}
}
}
impl std::convert::TryFrom<&str> for AdjustmentType {
type Error = self::error::ConversionError;
fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<&String> for AdjustmentType {
type Error = self::error::ConversionError;
fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<String> for AdjustmentType {
type Error = self::error::ConversionError;
fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct CarRental {
pub driver_name: String,
pub invoice_level_adjustments: Vec<Adjustment>,
pub items: Vec<Item>,
pub odometer_reading_in: i64,
pub odometer_reading_out: i64,
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>,
}
impl From<&CarRental> for CarRental {
fn from(value: &CarRental) -> Self {
value.clone()
}
}
impl CarRental {
pub fn builder() -> builder::CarRental {
Default::default()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct CarRentalVehicle {
pub description: String,
pub image: Option<String>,
}
impl From<&CarRentalVehicle> for CarRentalVehicle {
fn from(value: &CarRentalVehicle) -> Self {
value.clone()
}
}
impl CarRentalVehicle {
pub fn builder() -> builder::CarRentalVehicle {
Default::default()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct CardPayment {
pub last_four: String,
pub network: Option<CardPaymentNetwork>,
}
impl From<&CardPayment> for CardPayment {
fn from(value: &CardPayment) -> Self {
value.clone()
}
}
impl CardPayment {
pub fn builder() -> builder::CardPayment {
Default::default()
}
}
#[derive(
::serde::Deserialize,
::serde::Serialize,
Clone,
Copy,
Debug,
Eq,
Hash,
Ord,
PartialEq,
PartialOrd
)]
pub enum CardPaymentNetwork {
#[serde(rename = "amex")]
Amex,
#[serde(rename = "diners")]
Diners,
#[serde(rename = "discover")]
Discover,
#[serde(rename = "eftpos_au")]
EftposAu,
#[serde(rename = "jcb")]
Jcb,
#[serde(rename = "mastercard")]
Mastercard,
#[serde(rename = "unionpay")]
Unionpay,
#[serde(rename = "visa")]
Visa,
}
impl From<&CardPaymentNetwork> for CardPaymentNetwork {
fn from(value: &CardPaymentNetwork) -> Self {
value.clone()
}
}
impl ::std::fmt::Display for CardPaymentNetwork {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match *self {
Self::Amex => write!(f, "amex"),
Self::Diners => write!(f, "diners"),
Self::Discover => write!(f, "discover"),
Self::EftposAu => write!(f, "eftpos_au"),
Self::Jcb => write!(f, "jcb"),
Self::Mastercard => write!(f, "mastercard"),
Self::Unionpay => write!(f, "unionpay"),
Self::Visa => write!(f, "visa"),
}
}
}
impl std::str::FromStr for CardPaymentNetwork {
type Err = self::error::ConversionError;
fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
match value {
"amex" => Ok(Self::Amex),
"diners" => Ok(Self::Diners),
"discover" => Ok(Self::Discover),
"eftpos_au" => Ok(Self::EftposAu),
"jcb" => Ok(Self::Jcb),
"mastercard" => Ok(Self::Mastercard),
"unionpay" => Ok(Self::Unionpay),
"visa" => Ok(Self::Visa),
_ => Err("invalid value".into()),
}
}
}
impl std::convert::TryFrom<&str> for CardPaymentNetwork {
type Error = self::error::ConversionError;
fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<&String> for CardPaymentNetwork {
type Error = self::error::ConversionError;
fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<String> for CardPaymentNetwork {
type Error = self::error::ConversionError;
fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
#[derive(
::serde::Deserialize,
::serde::Serialize,
Clone,
Copy,
Debug,
Eq,
Hash,
Ord,
PartialEq,
PartialOrd
)]
pub enum Currency {
#[serde(rename = "usd")]
Usd,
#[serde(rename = "eur")]
Eur,
#[serde(rename = "jpy")]
Jpy,
#[serde(rename = "gbp")]
Gbp,
#[serde(rename = "aud")]
Aud,
#[serde(rename = "cad")]
Cad,
#[serde(rename = "chf")]
Chf,
#[serde(rename = "cnh")]
Cnh,
}
impl From<&Currency> for Currency {
fn from(value: &Currency) -> Self {
value.clone()
}
}
impl ::std::fmt::Display for Currency {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match *self {
Self::Usd => write!(f, "usd"),
Self::Eur => write!(f, "eur"),
Self::Jpy => write!(f, "jpy"),
Self::Gbp => write!(f, "gbp"),
Self::Aud => write!(f, "aud"),
Self::Cad => write!(f, "cad"),
Self::Chf => write!(f, "chf"),
Self::Cnh => write!(f, "cnh"),
}
}
}
impl std::str::FromStr for Currency {
type Err = self::error::ConversionError;
fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
match value {
"usd" => Ok(Self::Usd),
"eur" => Ok(Self::Eur),
"jpy" => Ok(Self::Jpy),
"gbp" => Ok(Self::Gbp),
"aud" => Ok(Self::Aud),
"cad" => Ok(Self::Cad),
"chf" => Ok(Self::Chf),
"cnh" => Ok(Self::Cnh),
_ => Err("invalid value".into()),
}
}
}
impl std::convert::TryFrom<&str> for Currency {
type Error = self::error::ConversionError;
fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<&String> for Currency {
type Error = self::error::ConversionError;
fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<String> for Currency {
type Error = self::error::ConversionError;
fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Customer {
pub address: Option<Address>,
pub email: Option<String>,
pub metadata: Vec<Metadatum>,
pub name: String,
pub phone: Option<String>,
}
impl From<&Customer> for Customer {
fn from(value: &Customer) -> Self {
value.clone()
}
}
impl Customer {
pub fn builder() -> builder::Customer {
Default::default()
}
}
#[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()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Ecommerce {
pub invoice_level_adjustments: Vec<Adjustment>,
pub invoice_level_line_items: Vec<Item>,
pub shipments: Vec<Shipment>,
}
impl From<&Ecommerce> for Ecommerce {
fn from(value: &Ecommerce) -> Self {
value.clone()
}
}
impl Ecommerce {
pub fn builder() -> builder::Ecommerce {
Default::default()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Flight {
pub invoice_level_adjustments: Vec<Adjustment>,
#[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()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct FlightSegment {
pub adjustments: Vec<Adjustment>,
pub arrival_airport_code: String,
pub arrival_at: Option<i64>,
pub arrival_tz: Option<String>,
pub class_of_service: Option<String>,
pub departure_airport_code: String,
pub departure_at: Option<i64>,
pub departure_tz: Option<String>,
pub fare: i64,
pub flight_number: Option<String>,
pub taxes: Vec<Tax>,
}
impl From<&FlightSegment> for FlightSegment {
fn from(value: &FlightSegment) -> Self {
value.clone()
}
}
impl FlightSegment {
pub fn builder() -> builder::FlightSegment {
Default::default()
}
}
#[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<String>,
#[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()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct GeneralItemization {
pub invoice_level_adjustments: Vec<Adjustment>,
pub line_items: Vec<Item>,
}
impl From<&GeneralItemization> for GeneralItemization {
fn from(value: &GeneralItemization) -> Self {
value.clone()
}
}
impl GeneralItemization {
pub fn builder() -> builder::GeneralItemization {
Default::default()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct Header {
pub currency: Currency,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub customer: Option<Customer>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub invoice_asset_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub invoice_number: Option<String>,
pub invoiced_at: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub location: Option<Place>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mcc: Option<String>,
pub paid: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub receipt_asset_id: Option<String>,
pub subtotal: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub third_party: Option<HeaderThirdParty>,
pub total: i64,
}
impl From<&Header> for Header {
fn from(value: &Header) -> Self {
value.clone()
}
}
impl Header {
pub fn builder() -> builder::Header {
Default::default()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct HeaderThirdParty {
pub first_party_relation: HeaderThirdPartyFirstPartyRelation,
pub make_primary: bool,
pub merchant: Org,
}
impl From<&HeaderThirdParty> for HeaderThirdParty {
fn from(value: &HeaderThirdParty) -> Self {
value.clone()
}
}
impl HeaderThirdParty {
pub fn builder() -> builder::HeaderThirdParty {
Default::default()
}
}
#[derive(
::serde::Deserialize,
::serde::Serialize,
Clone,
Copy,
Debug,
Eq,
Hash,
Ord,
PartialEq,
PartialOrd
)]
pub enum HeaderThirdPartyFirstPartyRelation {
#[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<&HeaderThirdPartyFirstPartyRelation> for HeaderThirdPartyFirstPartyRelation {
fn from(value: &HeaderThirdPartyFirstPartyRelation) -> Self {
value.clone()
}
}
impl ::std::fmt::Display for HeaderThirdPartyFirstPartyRelation {
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 HeaderThirdPartyFirstPartyRelation {
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 HeaderThirdPartyFirstPartyRelation {
type Error = self::error::ConversionError;
fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<&String> for HeaderThirdPartyFirstPartyRelation {
type Error = self::error::ConversionError;
fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<String> for HeaderThirdPartyFirstPartyRelation {
type Error = self::error::ConversionError;
fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
#[derive(
::serde::Deserialize,
::serde::Serialize,
Clone,
Copy,
Debug,
Eq,
Hash,
Ord,
PartialEq,
PartialOrd
)]
pub enum Interval {
#[serde(rename = "day")]
Day,
#[serde(rename = "week")]
Week,
#[serde(rename = "month")]
Month,
#[serde(rename = "year")]
Year,
}
impl From<&Interval> for Interval {
fn from(value: &Interval) -> Self {
value.clone()
}
}
impl ::std::fmt::Display for Interval {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match *self {
Self::Day => write!(f, "day"),
Self::Week => write!(f, "week"),
Self::Month => write!(f, "month"),
Self::Year => write!(f, "year"),
}
}
}
impl std::str::FromStr for Interval {
type Err = self::error::ConversionError;
fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
match value {
"day" => Ok(Self::Day),
"week" => Ok(Self::Week),
"month" => Ok(Self::Month),
"year" => Ok(Self::Year),
_ => Err("invalid value".into()),
}
}
}
impl std::convert::TryFrom<&str> for Interval {
type Error = self::error::ConversionError;
fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<&String> for Interval {
type Error = self::error::ConversionError;
fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<String> for Interval {
type Error = self::error::ConversionError;
fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Item {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub adjustments: Vec<Adjustment>,
#[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 = "Vec::is_empty")]
pub metadata: Vec<Metadatum>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub product_image: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub quantity: Option<f64>,
pub subtotal: i64,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub taxes: Vec<Tax>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub unit: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub unit_cost: Option<i64>,
#[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()
}
}
#[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())
})
}
}
#[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 ecommerce: Option<Ecommerce>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub flight: Option<Flight>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub general: Option<GeneralItemization>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub lodging: Option<Lodging>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub subscription: Option<Subscription>,
#[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()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Lodging {
pub check_in: i64,
pub check_out: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub guests: Option<String>,
pub invoice_level_adjustments: Vec<Adjustment>,
pub items: Vec<Item>,
pub location: Place,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub metadata: Vec<Metadatum>,
#[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()
}
}
#[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()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Org {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub address: Option<Address>,
#[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>,
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()
}
}
#[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-f0-9]{6}|[a-f0-9]{3})$")
.unwrap()
.find(value)
.is_none()
{
return Err("doesn't match pattern \"^#?([a-f0-9]{6}|[a-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())
})
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Payment {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ach_payment: Option<AchPayment>,
pub amount: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub card_payment: Option<CardPayment>,
pub paid_at: i64,
pub payment_type: PaymentPaymentType,
}
impl From<&Payment> for Payment {
fn from(value: &Payment) -> Self {
value.clone()
}
}
impl Payment {
pub fn builder() -> builder::Payment {
Default::default()
}
}
#[derive(
::serde::Deserialize,
::serde::Serialize,
Clone,
Copy,
Debug,
Eq,
Hash,
Ord,
PartialEq,
PartialOrd
)]
pub enum PaymentPaymentType {
#[serde(rename = "card")]
Card,
#[serde(rename = "ach")]
Ach,
}
impl From<&PaymentPaymentType> for PaymentPaymentType {
fn from(value: &PaymentPaymentType) -> Self {
value.clone()
}
}
impl ::std::fmt::Display for PaymentPaymentType {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match *self {
Self::Card => write!(f, "card"),
Self::Ach => write!(f, "ach"),
}
}
}
impl std::str::FromStr for PaymentPaymentType {
type Err = self::error::ConversionError;
fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
match value {
"card" => Ok(Self::Card),
"ach" => Ok(Self::Ach),
_ => Err("invalid value".into()),
}
}
}
impl std::convert::TryFrom<&str> for PaymentPaymentType {
type Error = self::error::ConversionError;
fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<&String> for PaymentPaymentType {
type Error = self::error::ConversionError;
fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<String> for PaymentPaymentType {
type Error = self::error::ConversionError;
fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Place {
pub address: Option<Address>,
pub google_place_id: Option<String>,
pub image: Option<String>,
pub name: Option<String>,
pub phone: Option<String>,
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()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct Receipt {
pub actions: Vec<Action>,
pub header: Header,
pub itemization: Itemization,
pub payments: Vec<Payment>,
pub schema_version: SchemaVersion,
}
impl From<&Receipt> for Receipt {
fn from(value: &Receipt) -> Self {
value.clone()
}
}
impl Receipt {
pub fn builder() -> builder::Receipt {
Default::default()
}
}
#[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())
})
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Shipment {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub destination_address: Option<Address>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub expected_delivery_at: Option<i64>,
pub items: Vec<Item>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub shipment_status: Option<ShipmentShipmentStatus>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tracking_number: Option<String>,
}
impl From<&Shipment> for Shipment {
fn from(value: &Shipment) -> Self {
value.clone()
}
}
impl Shipment {
pub fn builder() -> builder::Shipment {
Default::default()
}
}
#[derive(
::serde::Deserialize,
::serde::Serialize,
Clone,
Copy,
Debug,
Eq,
Hash,
Ord,
PartialEq,
PartialOrd
)]
pub enum ShipmentShipmentStatus {
#[serde(rename = "prep")]
Prep,
#[serde(rename = "in_transit")]
InTransit,
#[serde(rename = "delivered")]
Delivered,
}
impl From<&ShipmentShipmentStatus> for ShipmentShipmentStatus {
fn from(value: &ShipmentShipmentStatus) -> Self {
value.clone()
}
}
impl ::std::fmt::Display for ShipmentShipmentStatus {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match *self {
Self::Prep => write!(f, "prep"),
Self::InTransit => write!(f, "in_transit"),
Self::Delivered => write!(f, "delivered"),
}
}
}
impl std::str::FromStr for ShipmentShipmentStatus {
type Err = self::error::ConversionError;
fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
match value {
"prep" => Ok(Self::Prep),
"in_transit" => Ok(Self::InTransit),
"delivered" => Ok(Self::Delivered),
_ => Err("invalid value".into()),
}
}
}
impl std::convert::TryFrom<&str> for ShipmentShipmentStatus {
type Error = self::error::ConversionError;
fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<&String> for ShipmentShipmentStatus {
type Error = self::error::ConversionError;
fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<String> for ShipmentShipmentStatus {
type Error = self::error::ConversionError;
fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Subscription {
pub invoice_level_adjustments: Vec<Adjustment>,
pub subscription_items: Vec<SubscriptionItem>,
}
impl From<&Subscription> for Subscription {
fn from(value: &Subscription) -> Self {
value.clone()
}
}
impl Subscription {
pub fn builder() -> builder::Subscription {
Default::default()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct SubscriptionItem {
pub adjustments: Vec<Adjustment>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub current_period_end: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub current_period_start: Option<i64>,
pub description: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub interval: Option<Interval>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub interval_count: Option<i64>,
pub metadata: Vec<Metadatum>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub quantity: Option<f64>,
pub subscription_type: SubscriptionType,
pub subtotal: i64,
pub taxes: Vec<Tax>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub unit_cost: Option<f64>,
}
impl From<&SubscriptionItem> for SubscriptionItem {
fn from(value: &SubscriptionItem) -> Self {
value.clone()
}
}
impl SubscriptionItem {
pub fn builder() -> builder::SubscriptionItem {
Default::default()
}
}
#[derive(
::serde::Deserialize,
::serde::Serialize,
Clone,
Copy,
Debug,
Eq,
Hash,
Ord,
PartialEq,
PartialOrd
)]
pub enum SubscriptionType {
#[serde(rename = "one_time")]
OneTime,
#[serde(rename = "recurring")]
Recurring,
}
impl From<&SubscriptionType> for SubscriptionType {
fn from(value: &SubscriptionType) -> Self {
value.clone()
}
}
impl ::std::fmt::Display for SubscriptionType {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match *self {
Self::OneTime => write!(f, "one_time"),
Self::Recurring => write!(f, "recurring"),
}
}
}
impl std::str::FromStr for SubscriptionType {
type Err = self::error::ConversionError;
fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
match value {
"one_time" => Ok(Self::OneTime),
"recurring" => Ok(Self::Recurring),
_ => Err("invalid value".into()),
}
}
}
impl std::convert::TryFrom<&str> for SubscriptionType {
type Error = self::error::ConversionError;
fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<&String> for SubscriptionType {
type Error = self::error::ConversionError;
fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
impl std::convert::TryFrom<String> for SubscriptionType {
type Error = self::error::ConversionError;
fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
value.parse()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct Tax {
pub amount: i64,
pub name: String,
pub rate: Option<f64>,
}
impl From<&Tax> for Tax {
fn from(value: &Tax) -> Self {
value.clone()
}
}
impl Tax {
pub fn builder() -> builder::Tax {
Default::default()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct TransitRoute {
pub invoice_level_adjustments: Vec<Adjustment>,
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()
}
}
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
pub struct TransitRouteItem {
pub adjustments: Vec<Adjustment>,
#[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>,
pub fare: i64,
pub metadata: 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<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub polyline: Option<String>,
pub taxes: Vec<Tax>,
}
impl From<&TransitRouteItem> for TransitRouteItem {
fn from(value: &TransitRouteItem) -> Self {
value.clone()
}
}
impl TransitRouteItem {
pub fn builder() -> builder::TransitRouteItem {
Default::default()
}
}
#[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()
}
}
pub mod builder {
#[derive(Clone, Debug)]
pub struct AchPayment {
routing_number: Result<String, String>,
}
impl Default for AchPayment {
fn default() -> Self {
Self {
routing_number: Err("no value supplied for routing_number".to_string()),
}
}
}
impl AchPayment {
pub fn routing_number<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<String>,
T::Error: std::fmt::Display,
{
self.routing_number = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for routing_number: {}", e)
});
self
}
}
impl std::convert::TryFrom<AchPayment> for super::AchPayment {
type Error = super::error::ConversionError;
fn try_from(value: AchPayment) -> Result<Self, super::error::ConversionError> {
Ok(Self {
routing_number: value.routing_number?,
})
}
}
impl From<super::AchPayment> for AchPayment {
fn from(value: super::AchPayment) -> Self {
Self {
routing_number: Ok(value.routing_number),
}
}
}
#[derive(Clone, Debug)]
pub struct Action {
name: Result<String, String>,
url: Result<String, String>,
}
impl Default for Action {
fn default() -> Self {
Self {
name: Err("no value supplied for name".to_string()),
url: Err("no value supplied for url".to_string()),
}
}
}
impl Action {
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 url<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<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<Action> for super::Action {
type Error = super::error::ConversionError;
fn try_from(value: Action) -> Result<Self, super::error::ConversionError> {
Ok(Self {
name: value.name?,
url: value.url?,
})
}
}
impl From<super::Action> for Action {
fn from(value: super::Action) -> Self {
Self {
name: Ok(value.name),
url: Ok(value.url),
}
}
}
#[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: Err("no value supplied for city".to_string()),
country: Err("no value supplied for country".to_string()),
lat: Err("no value supplied for lat".to_string()),
lon: Err("no value supplied for lon".to_string()),
postal_code: Err("no value supplied for postal_code".to_string()),
region: Err("no value supplied for region".to_string()),
street_address: Err("no value supplied for street_address".to_string()),
tz: Err("no value supplied for tz".to_string()),
}
}
}
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 Adjustment {
adjustment_type: Result<super::AdjustmentType, String>,
amount: Result<i64, String>,
name: Result<Option<String>, String>,
rate: Result<Option<f64>, String>,
}
impl Default for Adjustment {
fn default() -> Self {
Self {
adjustment_type: Err(
"no value supplied for adjustment_type".to_string(),
),
amount: Err("no value supplied for amount".to_string()),
name: Err("no value supplied for name".to_string()),
rate: Err("no value supplied for rate".to_string()),
}
}
}
impl Adjustment {
pub fn adjustment_type<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<super::AdjustmentType>,
T::Error: std::fmt::Display,
{
self.adjustment_type = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for adjustment_type: {}", e)
});
self
}
pub fn amount<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<i64>,
T::Error: std::fmt::Display,
{
self.amount = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for amount: {}", 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 rate<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<f64>>,
T::Error: std::fmt::Display,
{
self.rate = value
.try_into()
.map_err(|e| format!("error converting supplied value for rate: {}", e));
self
}
}
impl std::convert::TryFrom<Adjustment> for super::Adjustment {
type Error = super::error::ConversionError;
fn try_from(value: Adjustment) -> Result<Self, super::error::ConversionError> {
Ok(Self {
adjustment_type: value.adjustment_type?,
amount: value.amount?,
name: value.name?,
rate: value.rate?,
})
}
}
impl From<super::Adjustment> for Adjustment {
fn from(value: super::Adjustment) -> Self {
Self {
adjustment_type: Ok(value.adjustment_type),
amount: Ok(value.amount),
name: Ok(value.name),
rate: Ok(value.rate),
}
}
}
#[derive(Clone, Debug)]
pub struct CarRental {
driver_name: Result<String, String>,
invoice_level_adjustments: Result<Vec<super::Adjustment>, String>,
items: Result<Vec<super::Item>, String>,
odometer_reading_in: Result<i64, String>,
odometer_reading_out: Result<i64, 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>,
}
impl Default for CarRental {
fn default() -> Self {
Self {
driver_name: Err("no value supplied for driver_name".to_string()),
invoice_level_adjustments: Err(
"no value supplied for invoice_level_adjustments".to_string(),
),
items: Err("no value supplied for items".to_string()),
odometer_reading_in: Err(
"no value supplied for odometer_reading_in".to_string(),
),
odometer_reading_out: Err(
"no value supplied for odometer_reading_out".to_string(),
),
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()),
}
}
}
impl CarRental {
pub fn driver_name<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<String>,
T::Error: std::fmt::Display,
{
self.driver_name = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for driver_name: {}", e)
});
self
}
pub fn invoice_level_adjustments<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Adjustment>>,
T::Error: std::fmt::Display,
{
self.invoice_level_adjustments = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for invoice_level_adjustments: {}",
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 odometer_reading_in<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<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<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 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
}
}
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 {
driver_name: value.driver_name?,
invoice_level_adjustments: value.invoice_level_adjustments?,
items: value.items?,
odometer_reading_in: value.odometer_reading_in?,
odometer_reading_out: value.odometer_reading_out?,
rental_at: value.rental_at?,
rental_location: value.rental_location?,
return_at: value.return_at?,
return_location: value.return_location?,
vehicle: value.vehicle?,
})
}
}
impl From<super::CarRental> for CarRental {
fn from(value: super::CarRental) -> Self {
Self {
driver_name: Ok(value.driver_name),
invoice_level_adjustments: Ok(value.invoice_level_adjustments),
items: Ok(value.items),
odometer_reading_in: Ok(value.odometer_reading_in),
odometer_reading_out: Ok(value.odometer_reading_out),
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),
}
}
}
#[derive(Clone, Debug)]
pub struct CarRentalVehicle {
description: Result<String, String>,
image: Result<Option<String>, String>,
}
impl Default for CarRentalVehicle {
fn default() -> Self {
Self {
description: Err("no value supplied for description".to_string()),
image: Err("no value supplied for image".to_string()),
}
}
}
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
}
}
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?,
})
}
}
impl From<super::CarRentalVehicle> for CarRentalVehicle {
fn from(value: super::CarRentalVehicle) -> Self {
Self {
description: Ok(value.description),
image: Ok(value.image),
}
}
}
#[derive(Clone, Debug)]
pub struct CardPayment {
last_four: Result<String, String>,
network: Result<Option<super::CardPaymentNetwork>, String>,
}
impl Default for CardPayment {
fn default() -> Self {
Self {
last_four: Err("no value supplied for last_four".to_string()),
network: Err("no value supplied for network".to_string()),
}
}
}
impl CardPayment {
pub fn last_four<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<String>,
T::Error: std::fmt::Display,
{
self.last_four = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for last_four: {}", e)
});
self
}
pub fn network<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<super::CardPaymentNetwork>>,
T::Error: std::fmt::Display,
{
self.network = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for network: {}", e)
});
self
}
}
impl std::convert::TryFrom<CardPayment> for super::CardPayment {
type Error = super::error::ConversionError;
fn try_from(value: CardPayment) -> Result<Self, super::error::ConversionError> {
Ok(Self {
last_four: value.last_four?,
network: value.network?,
})
}
}
impl From<super::CardPayment> for CardPayment {
fn from(value: super::CardPayment) -> Self {
Self {
last_four: Ok(value.last_four),
network: Ok(value.network),
}
}
}
#[derive(Clone, Debug)]
pub struct Customer {
address: Result<Option<super::Address>, String>,
email: Result<Option<String>, String>,
metadata: Result<Vec<super::Metadatum>, String>,
name: Result<String, String>,
phone: Result<Option<String>, String>,
}
impl Default for Customer {
fn default() -> Self {
Self {
address: Err("no value supplied for address".to_string()),
email: Err("no value supplied for email".to_string()),
metadata: Err("no value supplied for metadata".to_string()),
name: Err("no value supplied for name".to_string()),
phone: Err("no value supplied for phone".to_string()),
}
}
}
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 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<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<String>>,
T::Error: std::fmt::Display,
{
self.phone = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for phone: {}", 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?,
email: value.email?,
metadata: value.metadata?,
name: value.name?,
phone: value.phone?,
})
}
}
impl From<super::Customer> for Customer {
fn from(value: super::Customer) -> Self {
Self {
address: Ok(value.address),
email: Ok(value.email),
metadata: Ok(value.metadata),
name: Ok(value.name),
phone: Ok(value.phone),
}
}
}
#[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 Ecommerce {
invoice_level_adjustments: Result<Vec<super::Adjustment>, String>,
invoice_level_line_items: Result<Vec<super::Item>, String>,
shipments: Result<Vec<super::Shipment>, String>,
}
impl Default for Ecommerce {
fn default() -> Self {
Self {
invoice_level_adjustments: Err(
"no value supplied for invoice_level_adjustments".to_string(),
),
invoice_level_line_items: Err(
"no value supplied for invoice_level_line_items".to_string(),
),
shipments: Err("no value supplied for shipments".to_string()),
}
}
}
impl Ecommerce {
pub fn invoice_level_adjustments<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Adjustment>>,
T::Error: std::fmt::Display,
{
self.invoice_level_adjustments = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for invoice_level_adjustments: {}",
e
)
});
self
}
pub fn invoice_level_line_items<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Item>>,
T::Error: std::fmt::Display,
{
self.invoice_level_line_items = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for invoice_level_line_items: {}",
e
)
});
self
}
pub fn shipments<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Shipment>>,
T::Error: std::fmt::Display,
{
self.shipments = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for shipments: {}", e)
});
self
}
}
impl std::convert::TryFrom<Ecommerce> for super::Ecommerce {
type Error = super::error::ConversionError;
fn try_from(value: Ecommerce) -> Result<Self, super::error::ConversionError> {
Ok(Self {
invoice_level_adjustments: value.invoice_level_adjustments?,
invoice_level_line_items: value.invoice_level_line_items?,
shipments: value.shipments?,
})
}
}
impl From<super::Ecommerce> for Ecommerce {
fn from(value: super::Ecommerce) -> Self {
Self {
invoice_level_adjustments: Ok(value.invoice_level_adjustments),
invoice_level_line_items: Ok(value.invoice_level_line_items),
shipments: Ok(value.shipments),
}
}
}
#[derive(Clone, Debug)]
pub struct Flight {
invoice_level_adjustments: Result<Vec<super::Adjustment>, String>,
itinerary_locator: Result<Option<String>, String>,
tickets: Result<Vec<super::FlightTicket>, String>,
}
impl Default for Flight {
fn default() -> Self {
Self {
invoice_level_adjustments: Err(
"no value supplied for invoice_level_adjustments".to_string(),
),
itinerary_locator: Ok(Default::default()),
tickets: Err("no value supplied for tickets".to_string()),
}
}
}
impl Flight {
pub fn invoice_level_adjustments<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Adjustment>>,
T::Error: std::fmt::Display,
{
self.invoice_level_adjustments = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for invoice_level_adjustments: {}",
e
)
});
self
}
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 {
invoice_level_adjustments: value.invoice_level_adjustments?,
itinerary_locator: value.itinerary_locator?,
tickets: value.tickets?,
})
}
}
impl From<super::Flight> for Flight {
fn from(value: super::Flight) -> Self {
Self {
invoice_level_adjustments: Ok(value.invoice_level_adjustments),
itinerary_locator: Ok(value.itinerary_locator),
tickets: Ok(value.tickets),
}
}
}
#[derive(Clone, Debug)]
pub struct FlightSegment {
adjustments: Result<Vec<super::Adjustment>, String>,
arrival_airport_code: Result<String, String>,
arrival_at: Result<Option<i64>, String>,
arrival_tz: Result<Option<String>, String>,
class_of_service: Result<Option<String>, String>,
departure_airport_code: Result<String, String>,
departure_at: Result<Option<i64>, String>,
departure_tz: Result<Option<String>, String>,
fare: Result<i64, String>,
flight_number: Result<Option<String>, String>,
taxes: Result<Vec<super::Tax>, String>,
}
impl Default for FlightSegment {
fn default() -> Self {
Self {
adjustments: Err("no value supplied for adjustments".to_string()),
arrival_airport_code: Err(
"no value supplied for arrival_airport_code".to_string(),
),
arrival_at: Err("no value supplied for arrival_at".to_string()),
arrival_tz: Err("no value supplied for arrival_tz".to_string()),
class_of_service: Err(
"no value supplied for class_of_service".to_string(),
),
departure_airport_code: Err(
"no value supplied for departure_airport_code".to_string(),
),
departure_at: Err("no value supplied for departure_at".to_string()),
departure_tz: Err("no value supplied for departure_tz".to_string()),
fare: Err("no value supplied for fare".to_string()),
flight_number: Err("no value supplied for flight_number".to_string()),
taxes: Err("no value supplied for taxes".to_string()),
}
}
}
impl FlightSegment {
pub fn adjustments<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Adjustment>>,
T::Error: std::fmt::Display,
{
self.adjustments = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for adjustments: {}", e)
});
self
}
pub fn arrival_airport_code<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<String>,
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<String>,
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 fare<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<i64>,
T::Error: std::fmt::Display,
{
self.fare = value
.try_into()
.map_err(|e| format!("error converting supplied value for fare: {}", 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 taxes<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Tax>>,
T::Error: std::fmt::Display,
{
self.taxes = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for taxes: {}", 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 {
adjustments: value.adjustments?,
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?,
fare: value.fare?,
flight_number: value.flight_number?,
taxes: value.taxes?,
})
}
}
impl From<super::FlightSegment> for FlightSegment {
fn from(value: super::FlightSegment) -> Self {
Self {
adjustments: Ok(value.adjustments),
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),
fare: Ok(value.fare),
flight_number: Ok(value.flight_number),
taxes: Ok(value.taxes),
}
}
}
#[derive(Clone, Debug)]
pub struct FlightTicket {
number: Result<Option<String>, String>,
passenger: Result<Option<String>, 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<String>>,
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 GeneralItemization {
invoice_level_adjustments: Result<Vec<super::Adjustment>, String>,
line_items: Result<Vec<super::Item>, String>,
}
impl Default for GeneralItemization {
fn default() -> Self {
Self {
invoice_level_adjustments: Err(
"no value supplied for invoice_level_adjustments".to_string(),
),
line_items: Err("no value supplied for line_items".to_string()),
}
}
}
impl GeneralItemization {
pub fn invoice_level_adjustments<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Adjustment>>,
T::Error: std::fmt::Display,
{
self.invoice_level_adjustments = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for invoice_level_adjustments: {}",
e
)
});
self
}
pub fn line_items<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Item>>,
T::Error: std::fmt::Display,
{
self.line_items = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for line_items: {}", e)
});
self
}
}
impl std::convert::TryFrom<GeneralItemization> for super::GeneralItemization {
type Error = super::error::ConversionError;
fn try_from(
value: GeneralItemization,
) -> Result<Self, super::error::ConversionError> {
Ok(Self {
invoice_level_adjustments: value.invoice_level_adjustments?,
line_items: value.line_items?,
})
}
}
impl From<super::GeneralItemization> for GeneralItemization {
fn from(value: super::GeneralItemization) -> Self {
Self {
invoice_level_adjustments: Ok(value.invoice_level_adjustments),
line_items: Ok(value.line_items),
}
}
}
#[derive(Clone, Debug)]
pub struct Header {
currency: Result<super::Currency, String>,
customer: Result<Option<super::Customer>, String>,
invoice_asset_id: Result<Option<String>, String>,
invoice_number: Result<Option<String>, String>,
invoiced_at: Result<i64, String>,
location: Result<Option<super::Place>, String>,
mcc: Result<Option<String>, String>,
paid: Result<i64, String>,
receipt_asset_id: Result<Option<String>, String>,
subtotal: Result<i64, String>,
third_party: Result<Option<super::HeaderThirdParty>, String>,
total: Result<i64, String>,
}
impl Default for Header {
fn default() -> Self {
Self {
currency: Err("no value supplied for currency".to_string()),
customer: Ok(Default::default()),
invoice_asset_id: Ok(Default::default()),
invoice_number: Ok(Default::default()),
invoiced_at: Err("no value supplied for invoiced_at".to_string()),
location: Ok(Default::default()),
mcc: Ok(Default::default()),
paid: Err("no value supplied for paid".to_string()),
receipt_asset_id: Ok(Default::default()),
subtotal: Err("no value supplied for subtotal".to_string()),
third_party: Ok(Default::default()),
total: Err("no value supplied for total".to_string()),
}
}
}
impl Header {
pub fn currency<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<super::Currency>,
T::Error: std::fmt::Display,
{
self.currency = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for currency: {}", 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 invoice_asset_id<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<String>>,
T::Error: std::fmt::Display,
{
self.invoice_asset_id = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for invoice_asset_id: {}", e
)
});
self
}
pub fn invoice_number<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<String>>,
T::Error: std::fmt::Display,
{
self.invoice_number = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for invoice_number: {}", e)
});
self
}
pub fn invoiced_at<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<i64>,
T::Error: std::fmt::Display,
{
self.invoiced_at = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for invoiced_at: {}", e)
});
self
}
pub fn location<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<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 mcc<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<String>>,
T::Error: std::fmt::Display,
{
self.mcc = value
.try_into()
.map_err(|e| format!("error converting supplied value for mcc: {}", e));
self
}
pub fn paid<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<i64>,
T::Error: std::fmt::Display,
{
self.paid = value
.try_into()
.map_err(|e| format!("error converting supplied value for paid: {}", e));
self
}
pub fn receipt_asset_id<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<String>>,
T::Error: std::fmt::Display,
{
self.receipt_asset_id = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for receipt_asset_id: {}", e
)
});
self
}
pub fn subtotal<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<i64>,
T::Error: std::fmt::Display,
{
self.subtotal = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for subtotal: {}", 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 total<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<i64>,
T::Error: std::fmt::Display,
{
self.total = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for total: {}", 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 {
currency: value.currency?,
customer: value.customer?,
invoice_asset_id: value.invoice_asset_id?,
invoice_number: value.invoice_number?,
invoiced_at: value.invoiced_at?,
location: value.location?,
mcc: value.mcc?,
paid: value.paid?,
receipt_asset_id: value.receipt_asset_id?,
subtotal: value.subtotal?,
third_party: value.third_party?,
total: value.total?,
})
}
}
impl From<super::Header> for Header {
fn from(value: super::Header) -> Self {
Self {
currency: Ok(value.currency),
customer: Ok(value.customer),
invoice_asset_id: Ok(value.invoice_asset_id),
invoice_number: Ok(value.invoice_number),
invoiced_at: Ok(value.invoiced_at),
location: Ok(value.location),
mcc: Ok(value.mcc),
paid: Ok(value.paid),
receipt_asset_id: Ok(value.receipt_asset_id),
subtotal: Ok(value.subtotal),
third_party: Ok(value.third_party),
total: Ok(value.total),
}
}
}
#[derive(Clone, Debug)]
pub struct HeaderThirdParty {
first_party_relation: Result<super::HeaderThirdPartyFirstPartyRelation, String>,
make_primary: Result<bool, String>,
merchant: Result<super::Org, String>,
}
impl Default for HeaderThirdParty {
fn default() -> Self {
Self {
first_party_relation: Err(
"no value supplied for first_party_relation".to_string(),
),
make_primary: Err("no value supplied for make_primary".to_string()),
merchant: Err("no value supplied for merchant".to_string()),
}
}
}
impl HeaderThirdParty {
pub fn first_party_relation<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<super::HeaderThirdPartyFirstPartyRelation>,
T::Error: std::fmt::Display,
{
self.first_party_relation = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for first_party_relation: {}", e
)
});
self
}
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<super::Org>,
T::Error: std::fmt::Display,
{
self.merchant = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for merchant: {}", 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 {
first_party_relation: value.first_party_relation?,
make_primary: value.make_primary?,
merchant: value.merchant?,
})
}
}
impl From<super::HeaderThirdParty> for HeaderThirdParty {
fn from(value: super::HeaderThirdParty) -> Self {
Self {
first_party_relation: Ok(value.first_party_relation),
make_primary: Ok(value.make_primary),
merchant: Ok(value.merchant),
}
}
}
#[derive(Clone, Debug)]
pub struct Item {
adjustments: Result<Vec<super::Adjustment>, String>,
date: Result<Option<String>, String>,
description: Result<String, String>,
group: Result<Option<String>, String>,
metadata: Result<Vec<super::Metadatum>, String>,
product_image: Result<Option<String>, String>,
quantity: Result<Option<f64>, String>,
subtotal: Result<i64, String>,
taxes: Result<Vec<super::Tax>, String>,
unit: Result<Option<String>, String>,
unit_cost: Result<Option<i64>, String>,
unspsc: Result<Option<super::ItemUnspsc>, String>,
url: Result<Option<String>, String>,
}
impl Default for Item {
fn default() -> Self {
Self {
adjustments: Ok(Default::default()),
date: Ok(Default::default()),
description: Err("no value supplied for description".to_string()),
group: Ok(Default::default()),
metadata: Ok(Default::default()),
product_image: Ok(Default::default()),
quantity: Ok(Default::default()),
subtotal: Err("no value supplied for subtotal".to_string()),
taxes: Ok(Default::default()),
unit: Ok(Default::default()),
unit_cost: Ok(Default::default()),
unspsc: Ok(Default::default()),
url: Ok(Default::default()),
}
}
}
impl Item {
pub fn adjustments<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Adjustment>>,
T::Error: std::fmt::Display,
{
self.adjustments = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for adjustments: {}", e)
});
self
}
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<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<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<String>>,
T::Error: std::fmt::Display,
{
self.product_image = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for product_image: {}", 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 subtotal<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<i64>,
T::Error: std::fmt::Display,
{
self.subtotal = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for subtotal: {}", e)
});
self
}
pub fn taxes<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Tax>>,
T::Error: std::fmt::Display,
{
self.taxes = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for taxes: {}", 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 unit_cost<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<i64>>,
T::Error: std::fmt::Display,
{
self.unit_cost = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for unit_cost: {}", 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 {
adjustments: value.adjustments?,
date: value.date?,
description: value.description?,
group: value.group?,
metadata: value.metadata?,
product_image: value.product_image?,
quantity: value.quantity?,
subtotal: value.subtotal?,
taxes: value.taxes?,
unit: value.unit?,
unit_cost: value.unit_cost?,
unspsc: value.unspsc?,
url: value.url?,
})
}
}
impl From<super::Item> for Item {
fn from(value: super::Item) -> Self {
Self {
adjustments: Ok(value.adjustments),
date: Ok(value.date),
description: Ok(value.description),
group: Ok(value.group),
metadata: Ok(value.metadata),
product_image: Ok(value.product_image),
quantity: Ok(value.quantity),
subtotal: Ok(value.subtotal),
taxes: Ok(value.taxes),
unit: Ok(value.unit),
unit_cost: Ok(value.unit_cost),
unspsc: Ok(value.unspsc),
url: Ok(value.url),
}
}
}
#[derive(Clone, Debug)]
pub struct Itemization {
car_rental: Result<Option<super::CarRental>, String>,
ecommerce: Result<Option<super::Ecommerce>, String>,
flight: Result<Option<super::Flight>, String>,
general: Result<Option<super::GeneralItemization>, String>,
lodging: Result<Option<super::Lodging>, String>,
subscription: Result<Option<super::Subscription>, String>,
transit_route: Result<Option<super::TransitRoute>, String>,
}
impl Default for Itemization {
fn default() -> Self {
Self {
car_rental: Ok(Default::default()),
ecommerce: Ok(Default::default()),
flight: Ok(Default::default()),
general: Ok(Default::default()),
lodging: Ok(Default::default()),
subscription: 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 ecommerce<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<super::Ecommerce>>,
T::Error: std::fmt::Display,
{
self.ecommerce = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for ecommerce: {}", 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 general<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<super::GeneralItemization>>,
T::Error: std::fmt::Display,
{
self.general = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for general: {}", 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 subscription<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<super::Subscription>>,
T::Error: std::fmt::Display,
{
self.subscription = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for subscription: {}", 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?,
ecommerce: value.ecommerce?,
flight: value.flight?,
general: value.general?,
lodging: value.lodging?,
subscription: value.subscription?,
transit_route: value.transit_route?,
})
}
}
impl From<super::Itemization> for Itemization {
fn from(value: super::Itemization) -> Self {
Self {
car_rental: Ok(value.car_rental),
ecommerce: Ok(value.ecommerce),
flight: Ok(value.flight),
general: Ok(value.general),
lodging: Ok(value.lodging),
subscription: Ok(value.subscription),
transit_route: Ok(value.transit_route),
}
}
}
#[derive(Clone, Debug)]
pub struct Lodging {
check_in: Result<i64, String>,
check_out: Result<i64, String>,
guests: Result<Option<String>, String>,
invoice_level_adjustments: Result<Vec<super::Adjustment>, String>,
items: Result<Vec<super::Item>, String>,
location: Result<super::Place, String>,
metadata: Result<Vec<super::Metadatum>, String>,
room: Result<Option<String>, String>,
}
impl Default for Lodging {
fn default() -> Self {
Self {
check_in: Err("no value supplied for check_in".to_string()),
check_out: Err("no value supplied for check_out".to_string()),
guests: Ok(Default::default()),
invoice_level_adjustments: Err(
"no value supplied for invoice_level_adjustments".to_string(),
),
items: Err("no value supplied for items".to_string()),
location: Err("no value supplied for location".to_string()),
metadata: Ok(Default::default()),
room: Ok(Default::default()),
}
}
}
impl Lodging {
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 guests<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<String>>,
T::Error: std::fmt::Display,
{
self.guests = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for guests: {}", e)
});
self
}
pub fn invoice_level_adjustments<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Adjustment>>,
T::Error: std::fmt::Display,
{
self.invoice_level_adjustments = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for invoice_level_adjustments: {}",
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<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 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 {
check_in: value.check_in?,
check_out: value.check_out?,
guests: value.guests?,
invoice_level_adjustments: value.invoice_level_adjustments?,
items: value.items?,
location: value.location?,
metadata: value.metadata?,
room: value.room?,
})
}
}
impl From<super::Lodging> for Lodging {
fn from(value: super::Lodging) -> Self {
Self {
check_in: Ok(value.check_in),
check_out: Ok(value.check_out),
guests: Ok(value.guests),
invoice_level_adjustments: Ok(value.invoice_level_adjustments),
items: Ok(value.items),
location: Ok(value.location),
metadata: Ok(value.metadata),
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>,
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()),
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 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?,
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),
name: Ok(value.name),
vat_number: Ok(value.vat_number),
website: Ok(value.website),
}
}
}
#[derive(Clone, Debug)]
pub struct Payment {
ach_payment: Result<Option<super::AchPayment>, String>,
amount: Result<i64, String>,
card_payment: Result<Option<super::CardPayment>, String>,
paid_at: Result<i64, String>,
payment_type: Result<super::PaymentPaymentType, String>,
}
impl Default for Payment {
fn default() -> Self {
Self {
ach_payment: Ok(Default::default()),
amount: Err("no value supplied for amount".to_string()),
card_payment: Ok(Default::default()),
paid_at: Err("no value supplied for paid_at".to_string()),
payment_type: Err("no value supplied for payment_type".to_string()),
}
}
}
impl Payment {
pub fn ach_payment<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<super::AchPayment>>,
T::Error: std::fmt::Display,
{
self.ach_payment = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for ach_payment: {}", e)
});
self
}
pub fn amount<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<i64>,
T::Error: std::fmt::Display,
{
self.amount = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for amount: {}", e)
});
self
}
pub fn card_payment<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<super::CardPayment>>,
T::Error: std::fmt::Display,
{
self.card_payment = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for card_payment: {}", e)
});
self
}
pub fn paid_at<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<i64>,
T::Error: std::fmt::Display,
{
self.paid_at = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for paid_at: {}", e)
});
self
}
pub fn payment_type<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<super::PaymentPaymentType>,
T::Error: std::fmt::Display,
{
self.payment_type = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for payment_type: {}", e)
});
self
}
}
impl std::convert::TryFrom<Payment> for super::Payment {
type Error = super::error::ConversionError;
fn try_from(value: Payment) -> Result<Self, super::error::ConversionError> {
Ok(Self {
ach_payment: value.ach_payment?,
amount: value.amount?,
card_payment: value.card_payment?,
paid_at: value.paid_at?,
payment_type: value.payment_type?,
})
}
}
impl From<super::Payment> for Payment {
fn from(value: super::Payment) -> Self {
Self {
ach_payment: Ok(value.ach_payment),
amount: Ok(value.amount),
card_payment: Ok(value.card_payment),
paid_at: Ok(value.paid_at),
payment_type: Ok(value.payment_type),
}
}
}
#[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<String>, String>,
url: Result<Option<String>, String>,
}
impl Default for Place {
fn default() -> Self {
Self {
address: Err("no value supplied for address".to_string()),
google_place_id: Err(
"no value supplied for google_place_id".to_string(),
),
image: Err("no value supplied for image".to_string()),
name: Err("no value supplied for name".to_string()),
phone: Err("no value supplied for phone".to_string()),
url: Err("no value supplied for url".to_string()),
}
}
}
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<String>>,
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 Receipt {
actions: Result<Vec<super::Action>, String>,
header: Result<super::Header, String>,
itemization: Result<super::Itemization, String>,
payments: Result<Vec<super::Payment>, String>,
schema_version: Result<super::SchemaVersion, String>,
}
impl Default for Receipt {
fn default() -> Self {
Self {
actions: Err("no value supplied for actions".to_string()),
header: Err("no value supplied for header".to_string()),
itemization: Err("no value supplied for itemization".to_string()),
payments: Err("no value supplied for payments".to_string()),
schema_version: Err("no value supplied for schema_version".to_string()),
}
}
}
impl Receipt {
pub fn actions<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Action>>,
T::Error: std::fmt::Display,
{
self.actions = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for actions: {}", 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 payments<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Payment>>,
T::Error: std::fmt::Display,
{
self.payments = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for payments: {}", 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<Receipt> for super::Receipt {
type Error = super::error::ConversionError;
fn try_from(value: Receipt) -> Result<Self, super::error::ConversionError> {
Ok(Self {
actions: value.actions?,
header: value.header?,
itemization: value.itemization?,
payments: value.payments?,
schema_version: value.schema_version?,
})
}
}
impl From<super::Receipt> for Receipt {
fn from(value: super::Receipt) -> Self {
Self {
actions: Ok(value.actions),
header: Ok(value.header),
itemization: Ok(value.itemization),
payments: Ok(value.payments),
schema_version: Ok(value.schema_version),
}
}
}
#[derive(Clone, Debug)]
pub struct Shipment {
destination_address: Result<Option<super::Address>, String>,
expected_delivery_at: Result<Option<i64>, String>,
items: Result<Vec<super::Item>, String>,
shipment_status: Result<Option<super::ShipmentShipmentStatus>, String>,
tracking_number: Result<Option<String>, String>,
}
impl Default for Shipment {
fn default() -> Self {
Self {
destination_address: Ok(Default::default()),
expected_delivery_at: Ok(Default::default()),
items: Err("no value supplied for items".to_string()),
shipment_status: Ok(Default::default()),
tracking_number: Ok(Default::default()),
}
}
}
impl Shipment {
pub fn destination_address<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<super::Address>>,
T::Error: std::fmt::Display,
{
self.destination_address = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for destination_address: {}", e
)
});
self
}
pub fn expected_delivery_at<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<i64>>,
T::Error: std::fmt::Display,
{
self.expected_delivery_at = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for expected_delivery_at: {}", 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 shipment_status<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<super::ShipmentShipmentStatus>>,
T::Error: std::fmt::Display,
{
self.shipment_status = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for shipment_status: {}", e)
});
self
}
pub fn tracking_number<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<String>>,
T::Error: std::fmt::Display,
{
self.tracking_number = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for tracking_number: {}", e)
});
self
}
}
impl std::convert::TryFrom<Shipment> for super::Shipment {
type Error = super::error::ConversionError;
fn try_from(value: Shipment) -> Result<Self, super::error::ConversionError> {
Ok(Self {
destination_address: value.destination_address?,
expected_delivery_at: value.expected_delivery_at?,
items: value.items?,
shipment_status: value.shipment_status?,
tracking_number: value.tracking_number?,
})
}
}
impl From<super::Shipment> for Shipment {
fn from(value: super::Shipment) -> Self {
Self {
destination_address: Ok(value.destination_address),
expected_delivery_at: Ok(value.expected_delivery_at),
items: Ok(value.items),
shipment_status: Ok(value.shipment_status),
tracking_number: Ok(value.tracking_number),
}
}
}
#[derive(Clone, Debug)]
pub struct Subscription {
invoice_level_adjustments: Result<Vec<super::Adjustment>, String>,
subscription_items: Result<Vec<super::SubscriptionItem>, String>,
}
impl Default for Subscription {
fn default() -> Self {
Self {
invoice_level_adjustments: Err(
"no value supplied for invoice_level_adjustments".to_string(),
),
subscription_items: Err(
"no value supplied for subscription_items".to_string(),
),
}
}
}
impl Subscription {
pub fn invoice_level_adjustments<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Adjustment>>,
T::Error: std::fmt::Display,
{
self.invoice_level_adjustments = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for invoice_level_adjustments: {}",
e
)
});
self
}
pub fn subscription_items<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::SubscriptionItem>>,
T::Error: std::fmt::Display,
{
self.subscription_items = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for subscription_items: {}", e
)
});
self
}
}
impl std::convert::TryFrom<Subscription> for super::Subscription {
type Error = super::error::ConversionError;
fn try_from(value: Subscription) -> Result<Self, super::error::ConversionError> {
Ok(Self {
invoice_level_adjustments: value.invoice_level_adjustments?,
subscription_items: value.subscription_items?,
})
}
}
impl From<super::Subscription> for Subscription {
fn from(value: super::Subscription) -> Self {
Self {
invoice_level_adjustments: Ok(value.invoice_level_adjustments),
subscription_items: Ok(value.subscription_items),
}
}
}
#[derive(Clone, Debug)]
pub struct SubscriptionItem {
adjustments: Result<Vec<super::Adjustment>, String>,
current_period_end: Result<Option<i64>, String>,
current_period_start: Result<Option<i64>, String>,
description: Result<String, String>,
interval: Result<Option<super::Interval>, String>,
interval_count: Result<Option<i64>, String>,
metadata: Result<Vec<super::Metadatum>, String>,
quantity: Result<Option<f64>, String>,
subscription_type: Result<super::SubscriptionType, String>,
subtotal: Result<i64, String>,
taxes: Result<Vec<super::Tax>, String>,
unit_cost: Result<Option<f64>, String>,
}
impl Default for SubscriptionItem {
fn default() -> Self {
Self {
adjustments: Err("no value supplied for adjustments".to_string()),
current_period_end: Ok(Default::default()),
current_period_start: Ok(Default::default()),
description: Err("no value supplied for description".to_string()),
interval: Ok(Default::default()),
interval_count: Ok(Default::default()),
metadata: Err("no value supplied for metadata".to_string()),
quantity: Ok(Default::default()),
subscription_type: Err(
"no value supplied for subscription_type".to_string(),
),
subtotal: Err("no value supplied for subtotal".to_string()),
taxes: Err("no value supplied for taxes".to_string()),
unit_cost: Ok(Default::default()),
}
}
}
impl SubscriptionItem {
pub fn adjustments<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Adjustment>>,
T::Error: std::fmt::Display,
{
self.adjustments = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for adjustments: {}", e)
});
self
}
pub fn current_period_end<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<i64>>,
T::Error: std::fmt::Display,
{
self.current_period_end = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for current_period_end: {}", e
)
});
self
}
pub fn current_period_start<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<i64>>,
T::Error: std::fmt::Display,
{
self.current_period_start = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for current_period_start: {}", 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 interval<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<super::Interval>>,
T::Error: std::fmt::Display,
{
self.interval = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for interval: {}", e)
});
self
}
pub fn interval_count<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<i64>>,
T::Error: std::fmt::Display,
{
self.interval_count = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for interval_count: {}", e)
});
self
}
pub fn metadata<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<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 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 subscription_type<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<super::SubscriptionType>,
T::Error: std::fmt::Display,
{
self.subscription_type = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for subscription_type: {}", e
)
});
self
}
pub fn subtotal<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<i64>,
T::Error: std::fmt::Display,
{
self.subtotal = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for subtotal: {}", e)
});
self
}
pub fn taxes<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Tax>>,
T::Error: std::fmt::Display,
{
self.taxes = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for taxes: {}", e)
});
self
}
pub fn unit_cost<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<f64>>,
T::Error: std::fmt::Display,
{
self.unit_cost = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for unit_cost: {}", e)
});
self
}
}
impl std::convert::TryFrom<SubscriptionItem> for super::SubscriptionItem {
type Error = super::error::ConversionError;
fn try_from(
value: SubscriptionItem,
) -> Result<Self, super::error::ConversionError> {
Ok(Self {
adjustments: value.adjustments?,
current_period_end: value.current_period_end?,
current_period_start: value.current_period_start?,
description: value.description?,
interval: value.interval?,
interval_count: value.interval_count?,
metadata: value.metadata?,
quantity: value.quantity?,
subscription_type: value.subscription_type?,
subtotal: value.subtotal?,
taxes: value.taxes?,
unit_cost: value.unit_cost?,
})
}
}
impl From<super::SubscriptionItem> for SubscriptionItem {
fn from(value: super::SubscriptionItem) -> Self {
Self {
adjustments: Ok(value.adjustments),
current_period_end: Ok(value.current_period_end),
current_period_start: Ok(value.current_period_start),
description: Ok(value.description),
interval: Ok(value.interval),
interval_count: Ok(value.interval_count),
metadata: Ok(value.metadata),
quantity: Ok(value.quantity),
subscription_type: Ok(value.subscription_type),
subtotal: Ok(value.subtotal),
taxes: Ok(value.taxes),
unit_cost: Ok(value.unit_cost),
}
}
}
#[derive(Clone, Debug)]
pub struct Tax {
amount: Result<i64, String>,
name: Result<String, String>,
rate: Result<Option<f64>, String>,
}
impl Default for Tax {
fn default() -> Self {
Self {
amount: Err("no value supplied for amount".to_string()),
name: Err("no value supplied for name".to_string()),
rate: Err("no value supplied for rate".to_string()),
}
}
}
impl Tax {
pub fn amount<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<i64>,
T::Error: std::fmt::Display,
{
self.amount = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for amount: {}", 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 rate<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Option<f64>>,
T::Error: std::fmt::Display,
{
self.rate = value
.try_into()
.map_err(|e| format!("error converting supplied value for rate: {}", e));
self
}
}
impl std::convert::TryFrom<Tax> for super::Tax {
type Error = super::error::ConversionError;
fn try_from(value: Tax) -> Result<Self, super::error::ConversionError> {
Ok(Self {
amount: value.amount?,
name: value.name?,
rate: value.rate?,
})
}
}
impl From<super::Tax> for Tax {
fn from(value: super::Tax) -> Self {
Self {
amount: Ok(value.amount),
name: Ok(value.name),
rate: Ok(value.rate),
}
}
}
#[derive(Clone, Debug)]
pub struct TransitRoute {
invoice_level_adjustments: Result<Vec<super::Adjustment>, String>,
transit_route_items: Result<Vec<super::TransitRouteItem>, String>,
}
impl Default for TransitRoute {
fn default() -> Self {
Self {
invoice_level_adjustments: Err(
"no value supplied for invoice_level_adjustments".to_string(),
),
transit_route_items: Err(
"no value supplied for transit_route_items".to_string(),
),
}
}
}
impl TransitRoute {
pub fn invoice_level_adjustments<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Adjustment>>,
T::Error: std::fmt::Display,
{
self.invoice_level_adjustments = value
.try_into()
.map_err(|e| {
format!(
"error converting supplied value for invoice_level_adjustments: {}",
e
)
});
self
}
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 {
invoice_level_adjustments: value.invoice_level_adjustments?,
transit_route_items: value.transit_route_items?,
})
}
}
impl From<super::TransitRoute> for TransitRoute {
fn from(value: super::TransitRoute) -> Self {
Self {
invoice_level_adjustments: Ok(value.invoice_level_adjustments),
transit_route_items: Ok(value.transit_route_items),
}
}
}
#[derive(Clone, Debug)]
pub struct TransitRouteItem {
adjustments: Result<Vec<super::Adjustment>, String>,
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>,
fare: Result<i64, String>,
metadata: Result<Vec<super::Metadatum>, String>,
mode: Result<Option<super::TransitRouteItemMode>, String>,
passenger: Result<Option<String>, String>,
polyline: Result<Option<String>, String>,
taxes: Result<Vec<super::Tax>, String>,
}
impl Default for TransitRouteItem {
fn default() -> Self {
Self {
adjustments: Err("no value supplied for adjustments".to_string()),
arrival_at: Ok(Default::default()),
arrival_location: Ok(Default::default()),
departure_at: Ok(Default::default()),
departure_location: Ok(Default::default()),
fare: Err("no value supplied for fare".to_string()),
metadata: Err("no value supplied for metadata".to_string()),
mode: Ok(Default::default()),
passenger: Ok(Default::default()),
polyline: Ok(Default::default()),
taxes: Err("no value supplied for taxes".to_string()),
}
}
}
impl TransitRouteItem {
pub fn adjustments<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Adjustment>>,
T::Error: std::fmt::Display,
{
self.adjustments = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for adjustments: {}", 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_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 fare<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<i64>,
T::Error: std::fmt::Display,
{
self.fare = value
.try_into()
.map_err(|e| format!("error converting supplied value for fare: {}", e));
self
}
pub fn metadata<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<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<String>>,
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
}
pub fn taxes<T>(mut self, value: T) -> Self
where
T: std::convert::TryInto<Vec<super::Tax>>,
T::Error: std::fmt::Display,
{
self.taxes = value
.try_into()
.map_err(|e| {
format!("error converting supplied value for taxes: {}", 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 {
adjustments: value.adjustments?,
arrival_at: value.arrival_at?,
arrival_location: value.arrival_location?,
departure_at: value.departure_at?,
departure_location: value.departure_location?,
fare: value.fare?,
metadata: value.metadata?,
mode: value.mode?,
passenger: value.passenger?,
polyline: value.polyline?,
taxes: value.taxes?,
})
}
}
impl From<super::TransitRouteItem> for TransitRouteItem {
fn from(value: super::TransitRouteItem) -> Self {
Self {
adjustments: Ok(value.adjustments),
arrival_at: Ok(value.arrival_at),
arrival_location: Ok(value.arrival_location),
departure_at: Ok(value.departure_at),
departure_location: Ok(value.departure_location),
fare: Ok(value.fare),
metadata: Ok(value.metadata),
mode: Ok(value.mode),
passenger: Ok(value.passenger),
polyline: Ok(value.polyline),
taxes: Ok(value.taxes),
}
}
}
}