stripe_shared/
payment_method_fpx.rs

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

stripe_shared/
payment_method_fpx.rs
