stripe_shared/
payment_method_p24.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct PaymentMethodP24 {
5    /// The customer's bank, if provided.
6    pub bank: Option<PaymentMethodP24Bank>,
7}
8#[doc(hidden)]
9pub struct PaymentMethodP24Builder {
10    bank: Option<Option<PaymentMethodP24Bank>>,
11}
12
13#[allow(
14    unused_variables,
15    irrefutable_let_patterns,
16    clippy::let_unit_value,
17    clippy::match_single_binding,
18    clippy::single_match
19)]
20const _: () = {
21    use miniserde::de::{Map, Visitor};
22    use miniserde::json::Value;
23    use miniserde::{Deserialize, Result, make_place};
24    use stripe_types::miniserde_helpers::FromValueOpt;
25    use stripe_types::{MapBuilder, ObjectDeser};
26
27    make_place!(Place);
28
29    impl Deserialize for PaymentMethodP24 {
30        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
31            Place::new(out)
32        }
33    }
34
35    struct Builder<'a> {
36        out: &'a mut Option<PaymentMethodP24>,
37        builder: PaymentMethodP24Builder,
38    }
39
40    impl Visitor for Place<PaymentMethodP24> {
41        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
42            Ok(Box::new(Builder {
43                out: &mut self.out,
44                builder: PaymentMethodP24Builder::deser_default(),
45            }))
46        }
47    }
48
49    impl MapBuilder for PaymentMethodP24Builder {
50        type Out = PaymentMethodP24;
51        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
52            Ok(match k {
53                "bank" => Deserialize::begin(&mut self.bank),
54                _ => <dyn Visitor>::ignore(),
55            })
56        }
57
58        fn deser_default() -> Self {
59            Self { bank: Deserialize::default() }
60        }
61
62        fn take_out(&mut self) -> Option<Self::Out> {
63            let (Some(bank),) = (self.bank.take(),) else {
64                return None;
65            };
66            Some(Self::Out { bank })
67        }
68    }
69
70    impl Map for Builder<'_> {
71        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
72            self.builder.key(k)
73        }
74
75        fn finish(&mut self) -> Result<()> {
76            *self.out = self.builder.take_out();
77            Ok(())
78        }
79    }
80
81    impl ObjectDeser for PaymentMethodP24 {
82        type Builder = PaymentMethodP24Builder;
83    }
84
85    impl FromValueOpt for PaymentMethodP24 {
86        fn from_value(v: Value) -> Option<Self> {
87            let Value::Object(obj) = v else {
88                return None;
89            };
90            let mut b = PaymentMethodP24Builder::deser_default();
91            for (k, v) in obj {
92                match k.as_str() {
93                    "bank" => b.bank = FromValueOpt::from_value(v),
94                    _ => {}
95                }
96            }
97            b.take_out()
98        }
99    }
100};
101/// The customer's bank, if provided.
102#[derive(Clone, Eq, PartialEq)]
103#[non_exhaustive]
104pub enum PaymentMethodP24Bank {
105    AliorBank,
106    BankMillennium,
107    BankNowyBfgSa,
108    BankPekaoSa,
109    BankiSpbdzielcze,
110    Blik,
111    BnpParibas,
112    Boz,
113    CitiHandlowy,
114    CreditAgricole,
115    Envelobank,
116    EtransferPocztowy24,
117    GetinBank,
118    Ideabank,
119    Ing,
120    Inteligo,
121    MbankMtransfer,
122    NestPrzelew,
123    NoblePay,
124    PbacZIpko,
125    PlusBank,
126    SantanderPrzelew24,
127    TmobileUsbugiBankowe,
128    ToyotaBank,
129    Velobank,
130    VolkswagenBank,
131    /// An unrecognized value from Stripe. Should not be used as a request parameter.
132    Unknown(String),
133}
134impl PaymentMethodP24Bank {
135    pub fn as_str(&self) -> &str {
136        use PaymentMethodP24Bank::*;
137        match self {
138            AliorBank => "alior_bank",
139            BankMillennium => "bank_millennium",
140            BankNowyBfgSa => "bank_nowy_bfg_sa",
141            BankPekaoSa => "bank_pekao_sa",
142            BankiSpbdzielcze => "banki_spbdzielcze",
143            Blik => "blik",
144            BnpParibas => "bnp_paribas",
145            Boz => "boz",
146            CitiHandlowy => "citi_handlowy",
147            CreditAgricole => "credit_agricole",
148            Envelobank => "envelobank",
149            EtransferPocztowy24 => "etransfer_pocztowy24",
150            GetinBank => "getin_bank",
151            Ideabank => "ideabank",
152            Ing => "ing",
153            Inteligo => "inteligo",
154            MbankMtransfer => "mbank_mtransfer",
155            NestPrzelew => "nest_przelew",
156            NoblePay => "noble_pay",
157            PbacZIpko => "pbac_z_ipko",
158            PlusBank => "plus_bank",
159            SantanderPrzelew24 => "santander_przelew24",
160            TmobileUsbugiBankowe => "tmobile_usbugi_bankowe",
161            ToyotaBank => "toyota_bank",
162            Velobank => "velobank",
163            VolkswagenBank => "volkswagen_bank",
164            Unknown(v) => v,
165        }
166    }
167}
168
169impl std::str::FromStr for PaymentMethodP24Bank {
170    type Err = std::convert::Infallible;
171    fn from_str(s: &str) -> Result<Self, Self::Err> {
172        use PaymentMethodP24Bank::*;
173        match s {
174            "alior_bank" => Ok(AliorBank),
175            "bank_millennium" => Ok(BankMillennium),
176            "bank_nowy_bfg_sa" => Ok(BankNowyBfgSa),
177            "bank_pekao_sa" => Ok(BankPekaoSa),
178            "banki_spbdzielcze" => Ok(BankiSpbdzielcze),
179            "blik" => Ok(Blik),
180            "bnp_paribas" => Ok(BnpParibas),
181            "boz" => Ok(Boz),
182            "citi_handlowy" => Ok(CitiHandlowy),
183            "credit_agricole" => Ok(CreditAgricole),
184            "envelobank" => Ok(Envelobank),
185            "etransfer_pocztowy24" => Ok(EtransferPocztowy24),
186            "getin_bank" => Ok(GetinBank),
187            "ideabank" => Ok(Ideabank),
188            "ing" => Ok(Ing),
189            "inteligo" => Ok(Inteligo),
190            "mbank_mtransfer" => Ok(MbankMtransfer),
191            "nest_przelew" => Ok(NestPrzelew),
192            "noble_pay" => Ok(NoblePay),
193            "pbac_z_ipko" => Ok(PbacZIpko),
194            "plus_bank" => Ok(PlusBank),
195            "santander_przelew24" => Ok(SantanderPrzelew24),
196            "tmobile_usbugi_bankowe" => Ok(TmobileUsbugiBankowe),
197            "toyota_bank" => Ok(ToyotaBank),
198            "velobank" => Ok(Velobank),
199            "volkswagen_bank" => Ok(VolkswagenBank),
200            v => Ok(Unknown(v.to_owned())),
201        }
202    }
203}
204impl std::fmt::Display for PaymentMethodP24Bank {
205    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
206        f.write_str(self.as_str())
207    }
208}
209
210impl std::fmt::Debug for PaymentMethodP24Bank {
211    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
212        f.write_str(self.as_str())
213    }
214}
215#[cfg(feature = "serialize")]
216impl serde::Serialize for PaymentMethodP24Bank {
217    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
218    where
219        S: serde::Serializer,
220    {
221        serializer.serialize_str(self.as_str())
222    }
223}
224impl miniserde::Deserialize for PaymentMethodP24Bank {
225    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
226        crate::Place::new(out)
227    }
228}
229
230impl miniserde::de::Visitor for crate::Place<PaymentMethodP24Bank> {
231    fn string(&mut self, s: &str) -> miniserde::Result<()> {
232        use std::str::FromStr;
233        self.out = Some(PaymentMethodP24Bank::from_str(s).unwrap());
234        Ok(())
235    }
236}
237
238stripe_types::impl_from_val_with_from_str!(PaymentMethodP24Bank);
239#[cfg(feature = "deserialize")]
240impl<'de> serde::Deserialize<'de> for PaymentMethodP24Bank {
241    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
242        use std::str::FromStr;
243        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
244        Ok(Self::from_str(&s).unwrap())
245    }
246}
stripe_shared/payment_method_p24.rs

stripe_shared/
payment_method_p24.rs
