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 Map for Builder<'_> {
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};