stripe_misc/
tax_product_resource_tax_breakdown.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct TaxProductResourceTaxBreakdown {
5    /// The amount of tax, in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal).
6    pub amount: i64,
7    /// Specifies whether the tax amount is included in the line item amount.
8    pub inclusive: bool,
9    pub tax_rate_details: stripe_misc::TaxProductResourceTaxRateDetails,
10    /// The reasoning behind this tax, for example, if the product is tax exempt.
11    /// We might extend the possible values for this field to support new tax rules.
12    pub taxability_reason: TaxProductResourceTaxBreakdownTaxabilityReason,
13    /// The amount on which tax is calculated, in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal).
14    pub taxable_amount: i64,
15}
16#[doc(hidden)]
17pub struct TaxProductResourceTaxBreakdownBuilder {
18    amount: Option<i64>,
19    inclusive: Option<bool>,
20    tax_rate_details: Option<stripe_misc::TaxProductResourceTaxRateDetails>,
21    taxability_reason: Option<TaxProductResourceTaxBreakdownTaxabilityReason>,
22    taxable_amount: Option<i64>,
23}
24
25#[allow(
26    unused_variables,
27    irrefutable_let_patterns,
28    clippy::let_unit_value,
29    clippy::match_single_binding,
30    clippy::single_match
31)]
32const _: () = {
33    use miniserde::de::{Map, Visitor};
34    use miniserde::json::Value;
35    use miniserde::{Deserialize, Result, make_place};
36    use stripe_types::miniserde_helpers::FromValueOpt;
37    use stripe_types::{MapBuilder, ObjectDeser};
38
39    make_place!(Place);
40
41    impl Deserialize for TaxProductResourceTaxBreakdown {
42        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
43            Place::new(out)
44        }
45    }
46
47    struct Builder<'a> {
48        out: &'a mut Option<TaxProductResourceTaxBreakdown>,
49        builder: TaxProductResourceTaxBreakdownBuilder,
50    }
51
52    impl Visitor for Place<TaxProductResourceTaxBreakdown> {
53        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
54            Ok(Box::new(Builder {
55                out: &mut self.out,
56                builder: TaxProductResourceTaxBreakdownBuilder::deser_default(),
57            }))
58        }
59    }
60
61    impl MapBuilder for TaxProductResourceTaxBreakdownBuilder {
62        type Out = TaxProductResourceTaxBreakdown;
63        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
64            Ok(match k {
65                "amount" => Deserialize::begin(&mut self.amount),
66                "inclusive" => Deserialize::begin(&mut self.inclusive),
67                "tax_rate_details" => Deserialize::begin(&mut self.tax_rate_details),
68                "taxability_reason" => Deserialize::begin(&mut self.taxability_reason),
69                "taxable_amount" => Deserialize::begin(&mut self.taxable_amount),
70                _ => <dyn Visitor>::ignore(),
71            })
72        }
73
74        fn deser_default() -> Self {
75            Self {
76                amount: Deserialize::default(),
77                inclusive: Deserialize::default(),
78                tax_rate_details: Deserialize::default(),
79                taxability_reason: Deserialize::default(),
80                taxable_amount: Deserialize::default(),
81            }
82        }
83
84        fn take_out(&mut self) -> Option<Self::Out> {
85            let (
86                Some(amount),
87                Some(inclusive),
88                Some(tax_rate_details),
89                Some(taxability_reason),
90                Some(taxable_amount),
91            ) = (
92                self.amount,
93                self.inclusive,
94                self.tax_rate_details.take(),
95                self.taxability_reason.take(),
96                self.taxable_amount,
97            )
98            else {
99                return None;
100            };
101            Some(Self::Out {
102                amount,
103                inclusive,
104                tax_rate_details,
105                taxability_reason,
106                taxable_amount,
107            })
108        }
109    }
110
111    impl Map for Builder<'_> {
112        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
113            self.builder.key(k)
114        }
115
116        fn finish(&mut self) -> Result<()> {
117            *self.out = self.builder.take_out();
118            Ok(())
119        }
120    }
121
122    impl ObjectDeser for TaxProductResourceTaxBreakdown {
123        type Builder = TaxProductResourceTaxBreakdownBuilder;
124    }
125
126    impl FromValueOpt for TaxProductResourceTaxBreakdown {
127        fn from_value(v: Value) -> Option<Self> {
128            let Value::Object(obj) = v else {
129                return None;
130            };
131            let mut b = TaxProductResourceTaxBreakdownBuilder::deser_default();
132            for (k, v) in obj {
133                match k.as_str() {
134                    "amount" => b.amount = FromValueOpt::from_value(v),
135                    "inclusive" => b.inclusive = FromValueOpt::from_value(v),
136                    "tax_rate_details" => b.tax_rate_details = FromValueOpt::from_value(v),
137                    "taxability_reason" => b.taxability_reason = FromValueOpt::from_value(v),
138                    "taxable_amount" => b.taxable_amount = FromValueOpt::from_value(v),
139                    _ => {}
140                }
141            }
142            b.take_out()
143        }
144    }
145};
146/// The reasoning behind this tax, for example, if the product is tax exempt.
147/// We might extend the possible values for this field to support new tax rules.
148#[derive(Clone, Eq, PartialEq)]
149#[non_exhaustive]
150pub enum TaxProductResourceTaxBreakdownTaxabilityReason {
151    CustomerExempt,
152    NotCollecting,
153    NotSubjectToTax,
154    NotSupported,
155    PortionProductExempt,
156    PortionReducedRated,
157    PortionStandardRated,
158    ProductExempt,
159    ProductExemptHoliday,
160    ProportionallyRated,
161    ReducedRated,
162    ReverseCharge,
163    StandardRated,
164    TaxableBasisReduced,
165    ZeroRated,
166    /// An unrecognized value from Stripe. Should not be used as a request parameter.
167    Unknown(String),
168}
169impl TaxProductResourceTaxBreakdownTaxabilityReason {
170    pub fn as_str(&self) -> &str {
171        use TaxProductResourceTaxBreakdownTaxabilityReason::*;
172        match self {
173            CustomerExempt => "customer_exempt",
174            NotCollecting => "not_collecting",
175            NotSubjectToTax => "not_subject_to_tax",
176            NotSupported => "not_supported",
177            PortionProductExempt => "portion_product_exempt",
178            PortionReducedRated => "portion_reduced_rated",
179            PortionStandardRated => "portion_standard_rated",
180            ProductExempt => "product_exempt",
181            ProductExemptHoliday => "product_exempt_holiday",
182            ProportionallyRated => "proportionally_rated",
183            ReducedRated => "reduced_rated",
184            ReverseCharge => "reverse_charge",
185            StandardRated => "standard_rated",
186            TaxableBasisReduced => "taxable_basis_reduced",
187            ZeroRated => "zero_rated",
188            Unknown(v) => v,
189        }
190    }
191}
192
193impl std::str::FromStr for TaxProductResourceTaxBreakdownTaxabilityReason {
194    type Err = std::convert::Infallible;
195    fn from_str(s: &str) -> Result<Self, Self::Err> {
196        use TaxProductResourceTaxBreakdownTaxabilityReason::*;
197        match s {
198            "customer_exempt" => Ok(CustomerExempt),
199            "not_collecting" => Ok(NotCollecting),
200            "not_subject_to_tax" => Ok(NotSubjectToTax),
201            "not_supported" => Ok(NotSupported),
202            "portion_product_exempt" => Ok(PortionProductExempt),
203            "portion_reduced_rated" => Ok(PortionReducedRated),
204            "portion_standard_rated" => Ok(PortionStandardRated),
205            "product_exempt" => Ok(ProductExempt),
206            "product_exempt_holiday" => Ok(ProductExemptHoliday),
207            "proportionally_rated" => Ok(ProportionallyRated),
208            "reduced_rated" => Ok(ReducedRated),
209            "reverse_charge" => Ok(ReverseCharge),
210            "standard_rated" => Ok(StandardRated),
211            "taxable_basis_reduced" => Ok(TaxableBasisReduced),
212            "zero_rated" => Ok(ZeroRated),
213            v => Ok(Unknown(v.to_owned())),
214        }
215    }
216}
217impl std::fmt::Display for TaxProductResourceTaxBreakdownTaxabilityReason {
218    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
219        f.write_str(self.as_str())
220    }
221}
222
223impl std::fmt::Debug for TaxProductResourceTaxBreakdownTaxabilityReason {
224    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
225        f.write_str(self.as_str())
226    }
227}
228#[cfg(feature = "serialize")]
229impl serde::Serialize for TaxProductResourceTaxBreakdownTaxabilityReason {
230    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
231    where
232        S: serde::Serializer,
233    {
234        serializer.serialize_str(self.as_str())
235    }
236}
237impl miniserde::Deserialize for TaxProductResourceTaxBreakdownTaxabilityReason {
238    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
239        crate::Place::new(out)
240    }
241}
242
243impl miniserde::de::Visitor for crate::Place<TaxProductResourceTaxBreakdownTaxabilityReason> {
244    fn string(&mut self, s: &str) -> miniserde::Result<()> {
245        use std::str::FromStr;
246        self.out = Some(TaxProductResourceTaxBreakdownTaxabilityReason::from_str(s).unwrap());
247        Ok(())
248    }
249}
250
251stripe_types::impl_from_val_with_from_str!(TaxProductResourceTaxBreakdownTaxabilityReason);
252#[cfg(feature = "deserialize")]
253impl<'de> serde::Deserialize<'de> for TaxProductResourceTaxBreakdownTaxabilityReason {
254    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
255        use std::str::FromStr;
256        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
257        Ok(Self::from_str(&s).unwrap())
258    }
259}
stripe_misc/tax_product_resource_tax_breakdown.rs

stripe_misc/
tax_product_resource_tax_breakdown.rs
