stripe_shared/
payment_method_ideal.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct PaymentMethodIdeal {
5    /// The customer's bank, if provided.
6    /// Can be one of `abn_amro`, `asn_bank`, `bunq`, `buut`, `finom`, `handelsbanken`, `ing`, `knab`, `mollie`, `moneyou`, `n26`, `nn`, `rabobank`, `regiobank`, `revolut`, `sns_bank`, `triodos_bank`, `van_lanschot`, or `yoursafe`.
7    pub bank: Option<PaymentMethodIdealBank>,
8    /// The Bank Identifier Code of the customer's bank, if the bank was provided.
9    pub bic: Option<PaymentMethodIdealBic>,
10}
11#[doc(hidden)]
12pub struct PaymentMethodIdealBuilder {
13    bank: Option<Option<PaymentMethodIdealBank>>,
14    bic: Option<Option<PaymentMethodIdealBic>>,
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 PaymentMethodIdeal {
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<PaymentMethodIdeal>,
41        builder: PaymentMethodIdealBuilder,
42    }
43
44    impl Visitor for Place<PaymentMethodIdeal> {
45        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
46            Ok(Box::new(Builder {
47                out: &mut self.out,
48                builder: PaymentMethodIdealBuilder::deser_default(),
49            }))
50        }
51    }
52
53    impl MapBuilder for PaymentMethodIdealBuilder {
54        type Out = PaymentMethodIdeal;
55        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
56            Ok(match k {
57                "bank" => Deserialize::begin(&mut self.bank),
58                "bic" => Deserialize::begin(&mut self.bic),
59                _ => <dyn Visitor>::ignore(),
60            })
61        }
62
63        fn deser_default() -> Self {
64            Self { bank: Deserialize::default(), bic: Deserialize::default() }
65        }
66
67        fn take_out(&mut self) -> Option<Self::Out> {
68            let (Some(bank), Some(bic)) = (self.bank.take(), self.bic.take()) else {
69                return None;
70            };
71            Some(Self::Out { bank, bic })
72        }
73    }
74
75    impl Map for Builder<'_> {
76        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
77            self.builder.key(k)
78        }
79
80        fn finish(&mut self) -> Result<()> {
81            *self.out = self.builder.take_out();
82            Ok(())
83        }
84    }
85
86    impl ObjectDeser for PaymentMethodIdeal {
87        type Builder = PaymentMethodIdealBuilder;
88    }
89
90    impl FromValueOpt for PaymentMethodIdeal {
91        fn from_value(v: Value) -> Option<Self> {
92            let Value::Object(obj) = v else {
93                return None;
94            };
95            let mut b = PaymentMethodIdealBuilder::deser_default();
96            for (k, v) in obj {
97                match k.as_str() {
98                    "bank" => b.bank = FromValueOpt::from_value(v),
99                    "bic" => b.bic = FromValueOpt::from_value(v),
100                    _ => {}
101                }
102            }
103            b.take_out()
104        }
105    }
106};
107/// The customer's bank, if provided.
108/// Can be one of `abn_amro`, `asn_bank`, `bunq`, `buut`, `finom`, `handelsbanken`, `ing`, `knab`, `mollie`, `moneyou`, `n26`, `nn`, `rabobank`, `regiobank`, `revolut`, `sns_bank`, `triodos_bank`, `van_lanschot`, or `yoursafe`.
109#[derive(Clone, Eq, PartialEq)]
110#[non_exhaustive]
111pub enum PaymentMethodIdealBank {
112    AbnAmro,
113    AsnBank,
114    Bunq,
115    Buut,
116    Finom,
117    Handelsbanken,
118    Ing,
119    Knab,
120    Mollie,
121    Moneyou,
122    N26,
123    Nn,
124    Rabobank,
125    Regiobank,
126    Revolut,
127    SnsBank,
128    TriodosBank,
129    VanLanschot,
130    Yoursafe,
131    /// An unrecognized value from Stripe. Should not be used as a request parameter.
132    Unknown(String),
133}
134impl PaymentMethodIdealBank {
135    pub fn as_str(&self) -> &str {
136        use PaymentMethodIdealBank::*;
137        match self {
138            AbnAmro => "abn_amro",
139            AsnBank => "asn_bank",
140            Bunq => "bunq",
141            Buut => "buut",
142            Finom => "finom",
143            Handelsbanken => "handelsbanken",
144            Ing => "ing",
145            Knab => "knab",
146            Mollie => "mollie",
147            Moneyou => "moneyou",
148            N26 => "n26",
149            Nn => "nn",
150            Rabobank => "rabobank",
151            Regiobank => "regiobank",
152            Revolut => "revolut",
153            SnsBank => "sns_bank",
154            TriodosBank => "triodos_bank",
155            VanLanschot => "van_lanschot",
156            Yoursafe => "yoursafe",
157            Unknown(v) => v,
158        }
159    }
160}
161
162impl std::str::FromStr for PaymentMethodIdealBank {
163    type Err = std::convert::Infallible;
164    fn from_str(s: &str) -> Result<Self, Self::Err> {
165        use PaymentMethodIdealBank::*;
166        match s {
167            "abn_amro" => Ok(AbnAmro),
168            "asn_bank" => Ok(AsnBank),
169            "bunq" => Ok(Bunq),
170            "buut" => Ok(Buut),
171            "finom" => Ok(Finom),
172            "handelsbanken" => Ok(Handelsbanken),
173            "ing" => Ok(Ing),
174            "knab" => Ok(Knab),
175            "mollie" => Ok(Mollie),
176            "moneyou" => Ok(Moneyou),
177            "n26" => Ok(N26),
178            "nn" => Ok(Nn),
179            "rabobank" => Ok(Rabobank),
180            "regiobank" => Ok(Regiobank),
181            "revolut" => Ok(Revolut),
182            "sns_bank" => Ok(SnsBank),
183            "triodos_bank" => Ok(TriodosBank),
184            "van_lanschot" => Ok(VanLanschot),
185            "yoursafe" => Ok(Yoursafe),
186            v => {
187                tracing::warn!("Unknown value '{}' for enum '{}'", v, "PaymentMethodIdealBank");
188                Ok(Unknown(v.to_owned()))
189            }
190        }
191    }
192}
193impl std::fmt::Display for PaymentMethodIdealBank {
194    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
195        f.write_str(self.as_str())
196    }
197}
198
199impl std::fmt::Debug for PaymentMethodIdealBank {
200    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
201        f.write_str(self.as_str())
202    }
203}
204#[cfg(feature = "serialize")]
205impl serde::Serialize for PaymentMethodIdealBank {
206    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
207    where
208        S: serde::Serializer,
209    {
210        serializer.serialize_str(self.as_str())
211    }
212}
213impl miniserde::Deserialize for PaymentMethodIdealBank {
214    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
215        crate::Place::new(out)
216    }
217}
218
219impl miniserde::de::Visitor for crate::Place<PaymentMethodIdealBank> {
220    fn string(&mut self, s: &str) -> miniserde::Result<()> {
221        use std::str::FromStr;
222        self.out = Some(PaymentMethodIdealBank::from_str(s).expect("infallible"));
223        Ok(())
224    }
225}
226
227stripe_types::impl_from_val_with_from_str!(PaymentMethodIdealBank);
228#[cfg(feature = "deserialize")]
229impl<'de> serde::Deserialize<'de> for PaymentMethodIdealBank {
230    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
231        use std::str::FromStr;
232        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
233        Ok(Self::from_str(&s).expect("infallible"))
234    }
235}
236/// The Bank Identifier Code of the customer's bank, if the bank was provided.
237#[derive(Clone, Eq, PartialEq)]
238#[non_exhaustive]
239pub enum PaymentMethodIdealBic {
240    Abnanl2a,
241    Asnbnl21,
242    Bitsnl2a,
243    Bunqnl2a,
244    Buutnl2a,
245    Fnomnl22,
246    Fvlbnl22,
247    Handnl2a,
248    Ingbnl2a,
249    Knabnl2h,
250    Mllenl2a,
251    Moyonl21,
252    Nnbanl2g,
253    Ntsbdeb1,
254    Rabonl2u,
255    Rbrbnl21,
256    Revoie23,
257    Revolt21,
258    Snsbnl2a,
259    Trionl2u,
260    /// An unrecognized value from Stripe. Should not be used as a request parameter.
261    Unknown(String),
262}
263impl PaymentMethodIdealBic {
264    pub fn as_str(&self) -> &str {
265        use PaymentMethodIdealBic::*;
266        match self {
267            Abnanl2a => "ABNANL2A",
268            Asnbnl21 => "ASNBNL21",
269            Bitsnl2a => "BITSNL2A",
270            Bunqnl2a => "BUNQNL2A",
271            Buutnl2a => "BUUTNL2A",
272            Fnomnl22 => "FNOMNL22",
273            Fvlbnl22 => "FVLBNL22",
274            Handnl2a => "HANDNL2A",
275            Ingbnl2a => "INGBNL2A",
276            Knabnl2h => "KNABNL2H",
277            Mllenl2a => "MLLENL2A",
278            Moyonl21 => "MOYONL21",
279            Nnbanl2g => "NNBANL2G",
280            Ntsbdeb1 => "NTSBDEB1",
281            Rabonl2u => "RABONL2U",
282            Rbrbnl21 => "RBRBNL21",
283            Revoie23 => "REVOIE23",
284            Revolt21 => "REVOLT21",
285            Snsbnl2a => "SNSBNL2A",
286            Trionl2u => "TRIONL2U",
287            Unknown(v) => v,
288        }
289    }
290}
291
292impl std::str::FromStr for PaymentMethodIdealBic {
293    type Err = std::convert::Infallible;
294    fn from_str(s: &str) -> Result<Self, Self::Err> {
295        use PaymentMethodIdealBic::*;
296        match s {
297            "ABNANL2A" => Ok(Abnanl2a),
298            "ASNBNL21" => Ok(Asnbnl21),
299            "BITSNL2A" => Ok(Bitsnl2a),
300            "BUNQNL2A" => Ok(Bunqnl2a),
301            "BUUTNL2A" => Ok(Buutnl2a),
302            "FNOMNL22" => Ok(Fnomnl22),
303            "FVLBNL22" => Ok(Fvlbnl22),
304            "HANDNL2A" => Ok(Handnl2a),
305            "INGBNL2A" => Ok(Ingbnl2a),
306            "KNABNL2H" => Ok(Knabnl2h),
307            "MLLENL2A" => Ok(Mllenl2a),
308            "MOYONL21" => Ok(Moyonl21),
309            "NNBANL2G" => Ok(Nnbanl2g),
310            "NTSBDEB1" => Ok(Ntsbdeb1),
311            "RABONL2U" => Ok(Rabonl2u),
312            "RBRBNL21" => Ok(Rbrbnl21),
313            "REVOIE23" => Ok(Revoie23),
314            "REVOLT21" => Ok(Revolt21),
315            "SNSBNL2A" => Ok(Snsbnl2a),
316            "TRIONL2U" => Ok(Trionl2u),
317            v => {
318                tracing::warn!("Unknown value '{}' for enum '{}'", v, "PaymentMethodIdealBic");
319                Ok(Unknown(v.to_owned()))
320            }
321        }
322    }
323}
324impl std::fmt::Display for PaymentMethodIdealBic {
325    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
326        f.write_str(self.as_str())
327    }
328}
329
330impl std::fmt::Debug for PaymentMethodIdealBic {
331    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
332        f.write_str(self.as_str())
333    }
334}
335#[cfg(feature = "serialize")]
336impl serde::Serialize for PaymentMethodIdealBic {
337    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
338    where
339        S: serde::Serializer,
340    {
341        serializer.serialize_str(self.as_str())
342    }
343}
344impl miniserde::Deserialize for PaymentMethodIdealBic {
345    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
346        crate::Place::new(out)
347    }
348}
349
350impl miniserde::de::Visitor for crate::Place<PaymentMethodIdealBic> {
351    fn string(&mut self, s: &str) -> miniserde::Result<()> {
352        use std::str::FromStr;
353        self.out = Some(PaymentMethodIdealBic::from_str(s).expect("infallible"));
354        Ok(())
355    }
356}
357
358stripe_types::impl_from_val_with_from_str!(PaymentMethodIdealBic);
359#[cfg(feature = "deserialize")]
360impl<'de> serde::Deserialize<'de> for PaymentMethodIdealBic {
361    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
362        use std::str::FromStr;
363        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
364        Ok(Self::from_str(&s).expect("infallible"))
365    }
366}
stripe_shared/payment_method_ideal.rs

stripe_shared/
payment_method_ideal.rs
