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