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

stripe_shared/
payment_method_p24.rs
