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::{Deserialize, Result, make_place};
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 _ => <dyn Visitor>::ignore(),
102 })
103 }
104
105 fn deser_default() -> Self {
106 Self {
107 address_line1_check: Deserialize::default(),
108 address_zip_check: Deserialize::default(),
109 brand: Deserialize::default(),
110 country: Deserialize::default(),
111 cvc_check: Deserialize::default(),
112 description: Deserialize::default(),
113 dynamic_last4: Deserialize::default(),
114 exp_month: Deserialize::default(),
115 exp_year: Deserialize::default(),
116 fingerprint: Deserialize::default(),
117 funding: Deserialize::default(),
118 iin: Deserialize::default(),
119 issuer: Deserialize::default(),
120 last4: Deserialize::default(),
121 name: Deserialize::default(),
122 three_d_secure: Deserialize::default(),
123 tokenization_method: Deserialize::default(),
124 }
125 }
126
127 fn take_out(&mut self) -> Option<Self::Out> {
128 let (
129 Some(address_line1_check),
130 Some(address_zip_check),
131 Some(brand),
132 Some(country),
133 Some(cvc_check),
134 Some(description),
135 Some(dynamic_last4),
136 Some(exp_month),
137 Some(exp_year),
138 Some(fingerprint),
139 Some(funding),
140 Some(iin),
141 Some(issuer),
142 Some(last4),
143 Some(name),
144 Some(three_d_secure),
145 Some(tokenization_method),
146 ) = (
147 self.address_line1_check.take(),
148 self.address_zip_check.take(),
149 self.brand.take(),
150 self.country.take(),
151 self.cvc_check.take(),
152 self.description.take(),
153 self.dynamic_last4.take(),
154 self.exp_month,
155 self.exp_year,
156 self.fingerprint.take(),
157 self.funding.take(),
158 self.iin.take(),
159 self.issuer.take(),
160 self.last4.take(),
161 self.name.take(),
162 self.three_d_secure.take(),
163 self.tokenization_method.take(),
164 )
165 else {
166 return None;
167 };
168 Some(Self::Out {
169 address_line1_check,
170 address_zip_check,
171 brand,
172 country,
173 cvc_check,
174 description,
175 dynamic_last4,
176 exp_month,
177 exp_year,
178 fingerprint,
179 funding,
180 iin,
181 issuer,
182 last4,
183 name,
184 three_d_secure,
185 tokenization_method,
186 })
187 }
188 }
189
190 impl Map for Builder<'_> {
191 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
192 self.builder.key(k)
193 }
194
195 fn finish(&mut self) -> Result<()> {
196 *self.out = self.builder.take_out();
197 Ok(())
198 }
199 }
200
201 impl ObjectDeser for SourceTypeCard {
202 type Builder = SourceTypeCardBuilder;
203 }
204
205 impl FromValueOpt for SourceTypeCard {
206 fn from_value(v: Value) -> Option<Self> {
207 let Value::Object(obj) = v else {
208 return None;
209 };
210 let mut b = SourceTypeCardBuilder::deser_default();
211 for (k, v) in obj {
212 match k.as_str() {
213 "address_line1_check" => b.address_line1_check = FromValueOpt::from_value(v),
214 "address_zip_check" => b.address_zip_check = FromValueOpt::from_value(v),
215 "brand" => b.brand = FromValueOpt::from_value(v),
216 "country" => b.country = FromValueOpt::from_value(v),
217 "cvc_check" => b.cvc_check = FromValueOpt::from_value(v),
218 "description" => b.description = FromValueOpt::from_value(v),
219 "dynamic_last4" => b.dynamic_last4 = FromValueOpt::from_value(v),
220 "exp_month" => b.exp_month = FromValueOpt::from_value(v),
221 "exp_year" => b.exp_year = FromValueOpt::from_value(v),
222 "fingerprint" => b.fingerprint = FromValueOpt::from_value(v),
223 "funding" => b.funding = FromValueOpt::from_value(v),
224 "iin" => b.iin = FromValueOpt::from_value(v),
225 "issuer" => b.issuer = FromValueOpt::from_value(v),
226 "last4" => b.last4 = FromValueOpt::from_value(v),
227 "name" => b.name = FromValueOpt::from_value(v),
228 "three_d_secure" => b.three_d_secure = FromValueOpt::from_value(v),
229 "tokenization_method" => b.tokenization_method = FromValueOpt::from_value(v),
230 _ => {}
231 }
232 }
233 b.take_out()
234 }
235 }
236};