1#[derive(Clone, Debug)]
6#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
7pub struct SourceTransaction {
8 pub ach_credit_transfer: Option<stripe_shared::SourceTransactionAchCreditTransferData>,
9 pub amount: i64,
11 pub chf_credit_transfer: Option<stripe_shared::SourceTransactionChfCreditTransferData>,
12 pub created: stripe_types::Timestamp,
14 pub currency: stripe_types::Currency,
17 pub gbp_credit_transfer: Option<stripe_shared::SourceTransactionGbpCreditTransferData>,
18 pub id: stripe_shared::SourceTransactionId,
20 pub livemode: bool,
22 pub paper_check: Option<stripe_shared::SourceTransactionPaperCheckData>,
23 pub sepa_credit_transfer: Option<stripe_shared::SourceTransactionSepaCreditTransferData>,
24 pub source: String,
26 pub status: String,
28 #[cfg_attr(feature = "deserialize", serde(rename = "type"))]
30 pub type_: SourceTransactionType,
31}
32#[doc(hidden)]
33pub struct SourceTransactionBuilder {
34 ach_credit_transfer: Option<Option<stripe_shared::SourceTransactionAchCreditTransferData>>,
35 amount: Option<i64>,
36 chf_credit_transfer: Option<Option<stripe_shared::SourceTransactionChfCreditTransferData>>,
37 created: Option<stripe_types::Timestamp>,
38 currency: Option<stripe_types::Currency>,
39 gbp_credit_transfer: Option<Option<stripe_shared::SourceTransactionGbpCreditTransferData>>,
40 id: Option<stripe_shared::SourceTransactionId>,
41 livemode: Option<bool>,
42 paper_check: Option<Option<stripe_shared::SourceTransactionPaperCheckData>>,
43 sepa_credit_transfer: Option<Option<stripe_shared::SourceTransactionSepaCreditTransferData>>,
44 source: Option<String>,
45 status: Option<String>,
46 type_: Option<SourceTransactionType>,
47}
48
49#[allow(
50 unused_variables,
51 irrefutable_let_patterns,
52 clippy::let_unit_value,
53 clippy::match_single_binding,
54 clippy::single_match
55)]
56const _: () = {
57 use miniserde::de::{Map, Visitor};
58 use miniserde::json::Value;
59 use miniserde::{make_place, Deserialize, Result};
60 use stripe_types::miniserde_helpers::FromValueOpt;
61 use stripe_types::{MapBuilder, ObjectDeser};
62
63 make_place!(Place);
64
65 impl Deserialize for SourceTransaction {
66 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
67 Place::new(out)
68 }
69 }
70
71 struct Builder<'a> {
72 out: &'a mut Option<SourceTransaction>,
73 builder: SourceTransactionBuilder,
74 }
75
76 impl Visitor for Place<SourceTransaction> {
77 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
78 Ok(Box::new(Builder {
79 out: &mut self.out,
80 builder: SourceTransactionBuilder::deser_default(),
81 }))
82 }
83 }
84
85 impl MapBuilder for SourceTransactionBuilder {
86 type Out = SourceTransaction;
87 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
88 Ok(match k {
89 "ach_credit_transfer" => Deserialize::begin(&mut self.ach_credit_transfer),
90 "amount" => Deserialize::begin(&mut self.amount),
91 "chf_credit_transfer" => Deserialize::begin(&mut self.chf_credit_transfer),
92 "created" => Deserialize::begin(&mut self.created),
93 "currency" => Deserialize::begin(&mut self.currency),
94 "gbp_credit_transfer" => Deserialize::begin(&mut self.gbp_credit_transfer),
95 "id" => Deserialize::begin(&mut self.id),
96 "livemode" => Deserialize::begin(&mut self.livemode),
97 "paper_check" => Deserialize::begin(&mut self.paper_check),
98 "sepa_credit_transfer" => Deserialize::begin(&mut self.sepa_credit_transfer),
99 "source" => Deserialize::begin(&mut self.source),
100 "status" => Deserialize::begin(&mut self.status),
101 "type" => Deserialize::begin(&mut self.type_),
102
103 _ => <dyn Visitor>::ignore(),
104 })
105 }
106
107 fn deser_default() -> Self {
108 Self {
109 ach_credit_transfer: Deserialize::default(),
110 amount: Deserialize::default(),
111 chf_credit_transfer: Deserialize::default(),
112 created: Deserialize::default(),
113 currency: Deserialize::default(),
114 gbp_credit_transfer: Deserialize::default(),
115 id: Deserialize::default(),
116 livemode: Deserialize::default(),
117 paper_check: Deserialize::default(),
118 sepa_credit_transfer: Deserialize::default(),
119 source: Deserialize::default(),
120 status: Deserialize::default(),
121 type_: Deserialize::default(),
122 }
123 }
124
125 fn take_out(&mut self) -> Option<Self::Out> {
126 let (
127 Some(ach_credit_transfer),
128 Some(amount),
129 Some(chf_credit_transfer),
130 Some(created),
131 Some(currency),
132 Some(gbp_credit_transfer),
133 Some(id),
134 Some(livemode),
135 Some(paper_check),
136 Some(sepa_credit_transfer),
137 Some(source),
138 Some(status),
139 Some(type_),
140 ) = (
141 self.ach_credit_transfer.take(),
142 self.amount,
143 self.chf_credit_transfer.take(),
144 self.created,
145 self.currency,
146 self.gbp_credit_transfer.take(),
147 self.id.take(),
148 self.livemode,
149 self.paper_check.take(),
150 self.sepa_credit_transfer.take(),
151 self.source.take(),
152 self.status.take(),
153 self.type_.take(),
154 )
155 else {
156 return None;
157 };
158 Some(Self::Out {
159 ach_credit_transfer,
160 amount,
161 chf_credit_transfer,
162 created,
163 currency,
164 gbp_credit_transfer,
165 id,
166 livemode,
167 paper_check,
168 sepa_credit_transfer,
169 source,
170 status,
171 type_,
172 })
173 }
174 }
175
176 impl<'a> Map for Builder<'a> {
177 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
178 self.builder.key(k)
179 }
180
181 fn finish(&mut self) -> Result<()> {
182 *self.out = self.builder.take_out();
183 Ok(())
184 }
185 }
186
187 impl ObjectDeser for SourceTransaction {
188 type Builder = SourceTransactionBuilder;
189 }
190
191 impl FromValueOpt for SourceTransaction {
192 fn from_value(v: Value) -> Option<Self> {
193 let Value::Object(obj) = v else {
194 return None;
195 };
196 let mut b = SourceTransactionBuilder::deser_default();
197 for (k, v) in obj {
198 match k.as_str() {
199 "ach_credit_transfer" => b.ach_credit_transfer = FromValueOpt::from_value(v),
200 "amount" => b.amount = FromValueOpt::from_value(v),
201 "chf_credit_transfer" => b.chf_credit_transfer = FromValueOpt::from_value(v),
202 "created" => b.created = FromValueOpt::from_value(v),
203 "currency" => b.currency = FromValueOpt::from_value(v),
204 "gbp_credit_transfer" => b.gbp_credit_transfer = FromValueOpt::from_value(v),
205 "id" => b.id = FromValueOpt::from_value(v),
206 "livemode" => b.livemode = FromValueOpt::from_value(v),
207 "paper_check" => b.paper_check = FromValueOpt::from_value(v),
208 "sepa_credit_transfer" => b.sepa_credit_transfer = FromValueOpt::from_value(v),
209 "source" => b.source = FromValueOpt::from_value(v),
210 "status" => b.status = FromValueOpt::from_value(v),
211 "type" => b.type_ = FromValueOpt::from_value(v),
212
213 _ => {}
214 }
215 }
216 b.take_out()
217 }
218 }
219};
220#[cfg(feature = "serialize")]
221impl serde::Serialize for SourceTransaction {
222 fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
223 use serde::ser::SerializeStruct;
224 let mut s = s.serialize_struct("SourceTransaction", 14)?;
225 s.serialize_field("ach_credit_transfer", &self.ach_credit_transfer)?;
226 s.serialize_field("amount", &self.amount)?;
227 s.serialize_field("chf_credit_transfer", &self.chf_credit_transfer)?;
228 s.serialize_field("created", &self.created)?;
229 s.serialize_field("currency", &self.currency)?;
230 s.serialize_field("gbp_credit_transfer", &self.gbp_credit_transfer)?;
231 s.serialize_field("id", &self.id)?;
232 s.serialize_field("livemode", &self.livemode)?;
233 s.serialize_field("paper_check", &self.paper_check)?;
234 s.serialize_field("sepa_credit_transfer", &self.sepa_credit_transfer)?;
235 s.serialize_field("source", &self.source)?;
236 s.serialize_field("status", &self.status)?;
237 s.serialize_field("type", &self.type_)?;
238
239 s.serialize_field("object", "source_transaction")?;
240 s.end()
241 }
242}
243#[derive(Clone, Eq, PartialEq)]
245#[non_exhaustive]
246pub enum SourceTransactionType {
247 AchCreditTransfer,
248 AchDebit,
249 Alipay,
250 Bancontact,
251 Card,
252 CardPresent,
253 Eps,
254 Giropay,
255 Ideal,
256 Klarna,
257 Multibanco,
258 P24,
259 SepaDebit,
260 Sofort,
261 ThreeDSecure,
262 Wechat,
263 Unknown(String),
265}
266impl SourceTransactionType {
267 pub fn as_str(&self) -> &str {
268 use SourceTransactionType::*;
269 match self {
270 AchCreditTransfer => "ach_credit_transfer",
271 AchDebit => "ach_debit",
272 Alipay => "alipay",
273 Bancontact => "bancontact",
274 Card => "card",
275 CardPresent => "card_present",
276 Eps => "eps",
277 Giropay => "giropay",
278 Ideal => "ideal",
279 Klarna => "klarna",
280 Multibanco => "multibanco",
281 P24 => "p24",
282 SepaDebit => "sepa_debit",
283 Sofort => "sofort",
284 ThreeDSecure => "three_d_secure",
285 Wechat => "wechat",
286 Unknown(v) => v,
287 }
288 }
289}
290
291impl std::str::FromStr for SourceTransactionType {
292 type Err = std::convert::Infallible;
293 fn from_str(s: &str) -> Result<Self, Self::Err> {
294 use SourceTransactionType::*;
295 match s {
296 "ach_credit_transfer" => Ok(AchCreditTransfer),
297 "ach_debit" => Ok(AchDebit),
298 "alipay" => Ok(Alipay),
299 "bancontact" => Ok(Bancontact),
300 "card" => Ok(Card),
301 "card_present" => Ok(CardPresent),
302 "eps" => Ok(Eps),
303 "giropay" => Ok(Giropay),
304 "ideal" => Ok(Ideal),
305 "klarna" => Ok(Klarna),
306 "multibanco" => Ok(Multibanco),
307 "p24" => Ok(P24),
308 "sepa_debit" => Ok(SepaDebit),
309 "sofort" => Ok(Sofort),
310 "three_d_secure" => Ok(ThreeDSecure),
311 "wechat" => Ok(Wechat),
312 v => Ok(Unknown(v.to_owned())),
313 }
314 }
315}
316impl std::fmt::Display for SourceTransactionType {
317 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
318 f.write_str(self.as_str())
319 }
320}
321
322impl std::fmt::Debug for SourceTransactionType {
323 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
324 f.write_str(self.as_str())
325 }
326}
327#[cfg(feature = "serialize")]
328impl serde::Serialize for SourceTransactionType {
329 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
330 where
331 S: serde::Serializer,
332 {
333 serializer.serialize_str(self.as_str())
334 }
335}
336impl miniserde::Deserialize for SourceTransactionType {
337 fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
338 crate::Place::new(out)
339 }
340}
341
342impl miniserde::de::Visitor for crate::Place<SourceTransactionType> {
343 fn string(&mut self, s: &str) -> miniserde::Result<()> {
344 use std::str::FromStr;
345 self.out = Some(SourceTransactionType::from_str(s).unwrap());
346 Ok(())
347 }
348}
349
350stripe_types::impl_from_val_with_from_str!(SourceTransactionType);
351#[cfg(feature = "deserialize")]
352impl<'de> serde::Deserialize<'de> for SourceTransactionType {
353 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
354 use std::str::FromStr;
355 let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
356 Ok(Self::from_str(&s).unwrap())
357 }
358}
359impl stripe_types::Object for SourceTransaction {
360 type Id = stripe_shared::SourceTransactionId;
361 fn id(&self) -> &Self::Id {
362 &self.id
363 }
364
365 fn into_id(self) -> Self::Id {
366 self.id
367 }
368}
369stripe_types::def_id!(SourceTransactionId);