stripe_shared/
payment_method_fpx.rs

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

stripe_shared/
payment_method_fpx.rs
