stripe_shared/
payment_method_details_fpx.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct PaymentMethodDetailsFpx {
5    /// Account holder type, if provided. Can be one of `individual` or `company`.
6    pub account_holder_type: Option<PaymentMethodDetailsFpxAccountHolderType>,
7    /// The customer's bank.
8    /// Can be one of `affin_bank`, `agrobank`, `alliance_bank`, `ambank`, `bank_islam`, `bank_muamalat`, `bank_rakyat`, `bsn`, `cimb`, `hong_leong_bank`, `hsbc`, `kfh`, `maybank2u`, `ocbc`, `public_bank`, `rhb`, `standard_chartered`, `uob`, `deutsche_bank`, `maybank2e`, `pb_enterprise`, or `bank_of_china`.
9    pub bank: PaymentMethodDetailsFpxBank,
10    /// Unique transaction id generated by FPX for every request from the merchant
11    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/// Account holder type, if provided. Can be one of `individual` or `company`.
121#[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/// The customer's bank.
195/// Can be one of `affin_bank`, `agrobank`, `alliance_bank`, `ambank`, `bank_islam`, `bank_muamalat`, `bank_rakyat`, `bsn`, `cimb`, `hong_leong_bank`, `hsbc`, `kfh`, `maybank2u`, `ocbc`, `public_bank`, `rhb`, `standard_chartered`, `uob`, `deutsche_bank`, `maybank2e`, `pb_enterprise`, or `bank_of_china`.
196#[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    /// An unrecognized value from Stripe. Should not be used as a request parameter.
222    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}