stripe_shared/
source_type_card.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct SourceTypeCard {
5    pub address_line1_check: Option<String>,
6    pub address_zip_check: Option<String>,
7    pub brand: Option<String>,
8    pub country: Option<String>,
9    pub cvc_check: Option<String>,
10    pub description: Option<String>,
11    pub dynamic_last4: Option<String>,
12    pub exp_month: Option<i64>,
13    pub exp_year: Option<i64>,
14    pub fingerprint: Option<String>,
15    pub funding: Option<String>,
16    pub iin: Option<String>,
17    pub issuer: Option<String>,
18    pub last4: Option<String>,
19    pub name: Option<String>,
20    pub three_d_secure: Option<String>,
21    pub tokenization_method: Option<String>,
22}
23#[doc(hidden)]
24pub struct SourceTypeCardBuilder {
25    address_line1_check: Option<Option<String>>,
26    address_zip_check: Option<Option<String>>,
27    brand: Option<Option<String>>,
28    country: Option<Option<String>>,
29    cvc_check: Option<Option<String>>,
30    description: Option<Option<String>>,
31    dynamic_last4: Option<Option<String>>,
32    exp_month: Option<Option<i64>>,
33    exp_year: Option<Option<i64>>,
34    fingerprint: Option<Option<String>>,
35    funding: Option<Option<String>>,
36    iin: Option<Option<String>>,
37    issuer: Option<Option<String>>,
38    last4: Option<Option<String>>,
39    name: Option<Option<String>>,
40    three_d_secure: Option<Option<String>>,
41    tokenization_method: Option<Option<String>>,
42}
43
44#[allow(
45    unused_variables,
46    irrefutable_let_patterns,
47    clippy::let_unit_value,
48    clippy::match_single_binding,
49    clippy::single_match
50)]
51const _: () = {
52    use miniserde::de::{Map, Visitor};
53    use miniserde::json::Value;
54    use miniserde::{make_place, Deserialize, Result};
55    use stripe_types::miniserde_helpers::FromValueOpt;
56    use stripe_types::{MapBuilder, ObjectDeser};
57
58    make_place!(Place);
59
60    impl Deserialize for SourceTypeCard {
61        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
62            Place::new(out)
63        }
64    }
65
66    struct Builder<'a> {
67        out: &'a mut Option<SourceTypeCard>,
68        builder: SourceTypeCardBuilder,
69    }
70
71    impl Visitor for Place<SourceTypeCard> {
72        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
73            Ok(Box::new(Builder {
74                out: &mut self.out,
75                builder: SourceTypeCardBuilder::deser_default(),
76            }))
77        }
78    }
79
80    impl MapBuilder for SourceTypeCardBuilder {
81        type Out = SourceTypeCard;
82        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
83            Ok(match k {
84                "address_line1_check" => Deserialize::begin(&mut self.address_line1_check),
85                "address_zip_check" => Deserialize::begin(&mut self.address_zip_check),
86                "brand" => Deserialize::begin(&mut self.brand),
87                "country" => Deserialize::begin(&mut self.country),
88                "cvc_check" => Deserialize::begin(&mut self.cvc_check),
89                "description" => Deserialize::begin(&mut self.description),
90                "dynamic_last4" => Deserialize::begin(&mut self.dynamic_last4),
91                "exp_month" => Deserialize::begin(&mut self.exp_month),
92                "exp_year" => Deserialize::begin(&mut self.exp_year),
93                "fingerprint" => Deserialize::begin(&mut self.fingerprint),
94                "funding" => Deserialize::begin(&mut self.funding),
95                "iin" => Deserialize::begin(&mut self.iin),
96                "issuer" => Deserialize::begin(&mut self.issuer),
97                "last4" => Deserialize::begin(&mut self.last4),
98                "name" => Deserialize::begin(&mut self.name),
99                "three_d_secure" => Deserialize::begin(&mut self.three_d_secure),
100                "tokenization_method" => Deserialize::begin(&mut self.tokenization_method),
101
102                _ => <dyn Visitor>::ignore(),
103            })
104        }
105
106        fn deser_default() -> Self {
107            Self {
108                address_line1_check: Deserialize::default(),
109                address_zip_check: Deserialize::default(),
110                brand: Deserialize::default(),
111                country: Deserialize::default(),
112                cvc_check: Deserialize::default(),
113                description: Deserialize::default(),
114                dynamic_last4: Deserialize::default(),
115                exp_month: Deserialize::default(),
116                exp_year: Deserialize::default(),
117                fingerprint: Deserialize::default(),
118                funding: Deserialize::default(),
119                iin: Deserialize::default(),
120                issuer: Deserialize::default(),
121                last4: Deserialize::default(),
122                name: Deserialize::default(),
123                three_d_secure: Deserialize::default(),
124                tokenization_method: Deserialize::default(),
125            }
126        }
127
128        fn take_out(&mut self) -> Option<Self::Out> {
129            let (
130                Some(address_line1_check),
131                Some(address_zip_check),
132                Some(brand),
133                Some(country),
134                Some(cvc_check),
135                Some(description),
136                Some(dynamic_last4),
137                Some(exp_month),
138                Some(exp_year),
139                Some(fingerprint),
140                Some(funding),
141                Some(iin),
142                Some(issuer),
143                Some(last4),
144                Some(name),
145                Some(three_d_secure),
146                Some(tokenization_method),
147            ) = (
148                self.address_line1_check.take(),
149                self.address_zip_check.take(),
150                self.brand.take(),
151                self.country.take(),
152                self.cvc_check.take(),
153                self.description.take(),
154                self.dynamic_last4.take(),
155                self.exp_month,
156                self.exp_year,
157                self.fingerprint.take(),
158                self.funding.take(),
159                self.iin.take(),
160                self.issuer.take(),
161                self.last4.take(),
162                self.name.take(),
163                self.three_d_secure.take(),
164                self.tokenization_method.take(),
165            )
166            else {
167                return None;
168            };
169            Some(Self::Out {
170                address_line1_check,
171                address_zip_check,
172                brand,
173                country,
174                cvc_check,
175                description,
176                dynamic_last4,
177                exp_month,
178                exp_year,
179                fingerprint,
180                funding,
181                iin,
182                issuer,
183                last4,
184                name,
185                three_d_secure,
186                tokenization_method,
187            })
188        }
189    }
190
191    impl<'a> Map for Builder<'a> {
192        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
193            self.builder.key(k)
194        }
195
196        fn finish(&mut self) -> Result<()> {
197            *self.out = self.builder.take_out();
198            Ok(())
199        }
200    }
201
202    impl ObjectDeser for SourceTypeCard {
203        type Builder = SourceTypeCardBuilder;
204    }
205
206    impl FromValueOpt for SourceTypeCard {
207        fn from_value(v: Value) -> Option<Self> {
208            let Value::Object(obj) = v else {
209                return None;
210            };
211            let mut b = SourceTypeCardBuilder::deser_default();
212            for (k, v) in obj {
213                match k.as_str() {
214                    "address_line1_check" => b.address_line1_check = FromValueOpt::from_value(v),
215                    "address_zip_check" => b.address_zip_check = FromValueOpt::from_value(v),
216                    "brand" => b.brand = FromValueOpt::from_value(v),
217                    "country" => b.country = FromValueOpt::from_value(v),
218                    "cvc_check" => b.cvc_check = FromValueOpt::from_value(v),
219                    "description" => b.description = FromValueOpt::from_value(v),
220                    "dynamic_last4" => b.dynamic_last4 = FromValueOpt::from_value(v),
221                    "exp_month" => b.exp_month = FromValueOpt::from_value(v),
222                    "exp_year" => b.exp_year = FromValueOpt::from_value(v),
223                    "fingerprint" => b.fingerprint = FromValueOpt::from_value(v),
224                    "funding" => b.funding = FromValueOpt::from_value(v),
225                    "iin" => b.iin = FromValueOpt::from_value(v),
226                    "issuer" => b.issuer = FromValueOpt::from_value(v),
227                    "last4" => b.last4 = FromValueOpt::from_value(v),
228                    "name" => b.name = FromValueOpt::from_value(v),
229                    "three_d_secure" => b.three_d_secure = FromValueOpt::from_value(v),
230                    "tokenization_method" => b.tokenization_method = FromValueOpt::from_value(v),
231
232                    _ => {}
233                }
234            }
235            b.take_out()
236        }
237    }
238};