1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct PaymentMethodDetailsFpx {
5 pub account_holder_type: Option<PaymentMethodDetailsFpxAccountHolderType>,
7 pub bank: PaymentMethodDetailsFpxBank,
10 pub transaction_id: Option<String>,
12}
13#[doc(hidden)]
14pub struct PaymentMethodDetailsFpxBuilder {
15 account_holder_type: Option<Option<PaymentMethodDetailsFpxAccountHolderType>>,
16 bank: Option<PaymentMethodDetailsFpxBank>,
17 transaction_id: Option<Option<String>>,
18}
19
20#[allow(
21 unused_variables,
22 irrefutable_let_patterns,
23 clippy::let_unit_value,
24 clippy::match_single_binding,
25 clippy::single_match
26)]
27const _: () = {
28 use miniserde::de::{Map, Visitor};
29 use miniserde::json::Value;
30 use miniserde::{Deserialize, Result, make_place};
31 use stripe_types::miniserde_helpers::FromValueOpt;
32 use stripe_types::{MapBuilder, ObjectDeser};
33
34 make_place!(Place);
35
36 impl Deserialize for PaymentMethodDetailsFpx {
37 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
38 Place::new(out)
39 }
40 }
41
42 struct Builder<'a> {
43 out: &'a mut Option<PaymentMethodDetailsFpx>,
44 builder: PaymentMethodDetailsFpxBuilder,
45 }
46
47 impl Visitor for Place<PaymentMethodDetailsFpx> {
48 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
49 Ok(Box::new(Builder {
50 out: &mut self.out,
51 builder: PaymentMethodDetailsFpxBuilder::deser_default(),
52 }))
53 }
54 }
55
56 impl MapBuilder for PaymentMethodDetailsFpxBuilder {
57 type Out = PaymentMethodDetailsFpx;
58 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
59 Ok(match k {
60 "account_holder_type" => Deserialize::begin(&mut self.account_holder_type),
61 "bank" => Deserialize::begin(&mut self.bank),
62 "transaction_id" => Deserialize::begin(&mut self.transaction_id),
63
64 _ => <dyn Visitor>::ignore(),
65 })
66 }
67
68 fn deser_default() -> Self {
69 Self {
70 account_holder_type: Deserialize::default(),
71 bank: Deserialize::default(),
72 transaction_id: Deserialize::default(),
73 }
74 }
75
76 fn take_out(&mut self) -> Option<Self::Out> {
77 let (Some(account_holder_type), Some(bank), Some(transaction_id)) =
78 (self.account_holder_type, self.bank.take(), self.transaction_id.take())
79 else {
80 return None;
81 };
82 Some(Self::Out { account_holder_type, bank, transaction_id })
83 }
84 }
85
86 impl Map for Builder<'_> {
87 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
88 self.builder.key(k)
89 }
90
91 fn finish(&mut self) -> Result<()> {
92 *self.out = self.builder.take_out();
93 Ok(())
94 }
95 }
96
97 impl ObjectDeser for PaymentMethodDetailsFpx {
98 type Builder = PaymentMethodDetailsFpxBuilder;
99 }
100
101 impl FromValueOpt for PaymentMethodDetailsFpx {
102 fn from_value(v: Value) -> Option<Self> {
103 let Value::Object(obj) = v else {
104 return None;
105 };
106 let mut b = PaymentMethodDetailsFpxBuilder::deser_default();
107 for (k, v) in obj {
108 match k.as_str() {
109 "account_holder_type" => b.account_holder_type = FromValueOpt::from_value(v),
110 "bank" => b.bank = FromValueOpt::from_value(v),
111 "transaction_id" => b.transaction_id = FromValueOpt::from_value(v),
112
113 _ => {}
114 }
115 }
116 b.take_out()
117 }
118 }
119};
120#[derive(Copy, Clone, Eq, PartialEq)]
122pub enum PaymentMethodDetailsFpxAccountHolderType {
123 Company,
124 Individual,
125}
126impl PaymentMethodDetailsFpxAccountHolderType {
127 pub fn as_str(self) -> &'static str {
128 use PaymentMethodDetailsFpxAccountHolderType::*;
129 match self {
130 Company => "company",
131 Individual => "individual",
132 }
133 }
134}
135
136impl std::str::FromStr for PaymentMethodDetailsFpxAccountHolderType {
137 type Err = stripe_types::StripeParseError;
138 fn from_str(s: &str) -> Result<Self, Self::Err> {
139 use PaymentMethodDetailsFpxAccountHolderType::*;
140 match s {
141 "company" => Ok(Company),
142 "individual" => Ok(Individual),
143 _ => Err(stripe_types::StripeParseError),
144 }
145 }
146}
147impl std::fmt::Display for PaymentMethodDetailsFpxAccountHolderType {
148 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
149 f.write_str(self.as_str())
150 }
151}
152
153impl std::fmt::Debug for PaymentMethodDetailsFpxAccountHolderType {
154 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
155 f.write_str(self.as_str())
156 }
157}
158#[cfg(feature = "serialize")]
159impl serde::Serialize for PaymentMethodDetailsFpxAccountHolderType {
160 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
161 where
162 S: serde::Serializer,
163 {
164 serializer.serialize_str(self.as_str())
165 }
166}
167impl miniserde::Deserialize for PaymentMethodDetailsFpxAccountHolderType {
168 fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
169 crate::Place::new(out)
170 }
171}
172
173impl miniserde::de::Visitor for crate::Place<PaymentMethodDetailsFpxAccountHolderType> {
174 fn string(&mut self, s: &str) -> miniserde::Result<()> {
175 use std::str::FromStr;
176 self.out = Some(
177 PaymentMethodDetailsFpxAccountHolderType::from_str(s).map_err(|_| miniserde::Error)?,
178 );
179 Ok(())
180 }
181}
182
183stripe_types::impl_from_val_with_from_str!(PaymentMethodDetailsFpxAccountHolderType);
184#[cfg(feature = "deserialize")]
185impl<'de> serde::Deserialize<'de> for PaymentMethodDetailsFpxAccountHolderType {
186 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
187 use std::str::FromStr;
188 let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
189 Self::from_str(&s).map_err(|_| {
190 serde::de::Error::custom("Unknown value for PaymentMethodDetailsFpxAccountHolderType")
191 })
192 }
193}
194#[derive(Clone, Eq, PartialEq)]
197#[non_exhaustive]
198pub enum PaymentMethodDetailsFpxBank {
199 AffinBank,
200 Agrobank,
201 AllianceBank,
202 Ambank,
203 BankIslam,
204 BankMuamalat,
205 BankOfChina,
206 BankRakyat,
207 Bsn,
208 Cimb,
209 DeutscheBank,
210 HongLeongBank,
211 Hsbc,
212 Kfh,
213 Maybank2e,
214 Maybank2u,
215 Ocbc,
216 PbEnterprise,
217 PublicBank,
218 Rhb,
219 StandardChartered,
220 Uob,
221 Unknown(String),
223}
224impl PaymentMethodDetailsFpxBank {
225 pub fn as_str(&self) -> &str {
226 use PaymentMethodDetailsFpxBank::*;
227 match self {
228 AffinBank => "affin_bank",
229 Agrobank => "agrobank",
230 AllianceBank => "alliance_bank",
231 Ambank => "ambank",
232 BankIslam => "bank_islam",
233 BankMuamalat => "bank_muamalat",
234 BankOfChina => "bank_of_china",
235 BankRakyat => "bank_rakyat",
236 Bsn => "bsn",
237 Cimb => "cimb",
238 DeutscheBank => "deutsche_bank",
239 HongLeongBank => "hong_leong_bank",
240 Hsbc => "hsbc",
241 Kfh => "kfh",
242 Maybank2e => "maybank2e",
243 Maybank2u => "maybank2u",
244 Ocbc => "ocbc",
245 PbEnterprise => "pb_enterprise",
246 PublicBank => "public_bank",
247 Rhb => "rhb",
248 StandardChartered => "standard_chartered",
249 Uob => "uob",
250 Unknown(v) => v,
251 }
252 }
253}
254
255impl std::str::FromStr for PaymentMethodDetailsFpxBank {
256 type Err = std::convert::Infallible;
257 fn from_str(s: &str) -> Result<Self, Self::Err> {
258 use PaymentMethodDetailsFpxBank::*;
259 match s {
260 "affin_bank" => Ok(AffinBank),
261 "agrobank" => Ok(Agrobank),
262 "alliance_bank" => Ok(AllianceBank),
263 "ambank" => Ok(Ambank),
264 "bank_islam" => Ok(BankIslam),
265 "bank_muamalat" => Ok(BankMuamalat),
266 "bank_of_china" => Ok(BankOfChina),
267 "bank_rakyat" => Ok(BankRakyat),
268 "bsn" => Ok(Bsn),
269 "cimb" => Ok(Cimb),
270 "deutsche_bank" => Ok(DeutscheBank),
271 "hong_leong_bank" => Ok(HongLeongBank),
272 "hsbc" => Ok(Hsbc),
273 "kfh" => Ok(Kfh),
274 "maybank2e" => Ok(Maybank2e),
275 "maybank2u" => Ok(Maybank2u),
276 "ocbc" => Ok(Ocbc),
277 "pb_enterprise" => Ok(PbEnterprise),
278 "public_bank" => Ok(PublicBank),
279 "rhb" => Ok(Rhb),
280 "standard_chartered" => Ok(StandardChartered),
281 "uob" => Ok(Uob),
282 v => Ok(Unknown(v.to_owned())),
283 }
284 }
285}
286impl std::fmt::Display for PaymentMethodDetailsFpxBank {
287 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
288 f.write_str(self.as_str())
289 }
290}
291
292impl std::fmt::Debug for PaymentMethodDetailsFpxBank {
293 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
294 f.write_str(self.as_str())
295 }
296}
297#[cfg(feature = "serialize")]
298impl serde::Serialize for PaymentMethodDetailsFpxBank {
299 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
300 where
301 S: serde::Serializer,
302 {
303 serializer.serialize_str(self.as_str())
304 }
305}
306impl miniserde::Deserialize for PaymentMethodDetailsFpxBank {
307 fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
308 crate::Place::new(out)
309 }
310}
311
312impl miniserde::de::Visitor for crate::Place<PaymentMethodDetailsFpxBank> {
313 fn string(&mut self, s: &str) -> miniserde::Result<()> {
314 use std::str::FromStr;
315 self.out = Some(PaymentMethodDetailsFpxBank::from_str(s).unwrap());
316 Ok(())
317 }
318}
319
320stripe_types::impl_from_val_with_from_str!(PaymentMethodDetailsFpxBank);
321#[cfg(feature = "deserialize")]
322impl<'de> serde::Deserialize<'de> for PaymentMethodDetailsFpxBank {
323 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
324 use std::str::FromStr;
325 let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
326 Ok(Self::from_str(&s).unwrap())
327 }
328}