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

stripe_shared/
payment_method_fpx.rs
