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