stripe_shared/
payment_method_options_customer_balance_bank_transfer.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 PaymentMethodOptionsCustomerBalanceBankTransfer {
6    pub eu_bank_transfer: Option<stripe_shared::PaymentMethodOptionsCustomerBalanceEuBankAccount>,
7    /// List of address types that should be returned in the financial_addresses response.
8    /// If not specified, all valid types will be returned.
9    ///
10    /// Permitted values include: `sort_code`, `zengin`, `iban`, or `spei`.
11    pub requested_address_types:
12        Option<Vec<PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes>>,
13    /// The bank transfer type that this PaymentIntent is allowed to use for funding Permitted values include: `eu_bank_transfer`, `gb_bank_transfer`, `jp_bank_transfer`, `mx_bank_transfer`, or `us_bank_transfer`.
14    #[cfg_attr(any(feature = "deserialize", feature = "serialize"), serde(rename = "type"))]
15    pub type_: Option<PaymentMethodOptionsCustomerBalanceBankTransferType>,
16}
17#[cfg(feature = "redact-generated-debug")]
18impl std::fmt::Debug for PaymentMethodOptionsCustomerBalanceBankTransfer {
19    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
20        f.debug_struct("PaymentMethodOptionsCustomerBalanceBankTransfer").finish_non_exhaustive()
21    }
22}
23#[doc(hidden)]
24pub struct PaymentMethodOptionsCustomerBalanceBankTransferBuilder {
25    eu_bank_transfer:
26        Option<Option<stripe_shared::PaymentMethodOptionsCustomerBalanceEuBankAccount>>,
27    requested_address_types:
28        Option<Option<Vec<PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes>>>,
29    type_: Option<Option<PaymentMethodOptionsCustomerBalanceBankTransferType>>,
30}
31
32#[allow(
33    unused_variables,
34    irrefutable_let_patterns,
35    clippy::let_unit_value,
36    clippy::match_single_binding,
37    clippy::single_match
38)]
39const _: () = {
40    use miniserde::de::{Map, Visitor};
41    use miniserde::json::Value;
42    use miniserde::{Deserialize, Result, make_place};
43    use stripe_types::miniserde_helpers::FromValueOpt;
44    use stripe_types::{MapBuilder, ObjectDeser};
45
46    make_place!(Place);
47
48    impl Deserialize for PaymentMethodOptionsCustomerBalanceBankTransfer {
49        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
50            Place::new(out)
51        }
52    }
53
54    struct Builder<'a> {
55        out: &'a mut Option<PaymentMethodOptionsCustomerBalanceBankTransfer>,
56        builder: PaymentMethodOptionsCustomerBalanceBankTransferBuilder,
57    }
58
59    impl Visitor for Place<PaymentMethodOptionsCustomerBalanceBankTransfer> {
60        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
61            Ok(Box::new(Builder {
62                out: &mut self.out,
63                builder: PaymentMethodOptionsCustomerBalanceBankTransferBuilder::deser_default(),
64            }))
65        }
66    }
67
68    impl MapBuilder for PaymentMethodOptionsCustomerBalanceBankTransferBuilder {
69        type Out = PaymentMethodOptionsCustomerBalanceBankTransfer;
70        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
71            Ok(match k {
72                "eu_bank_transfer" => Deserialize::begin(&mut self.eu_bank_transfer),
73                "requested_address_types" => Deserialize::begin(&mut self.requested_address_types),
74                "type" => Deserialize::begin(&mut self.type_),
75                _ => <dyn Visitor>::ignore(),
76            })
77        }
78
79        fn deser_default() -> Self {
80            Self {
81                eu_bank_transfer: Some(None),
82                requested_address_types: Some(None),
83                type_: Some(None),
84            }
85        }
86
87        fn take_out(&mut self) -> Option<Self::Out> {
88            let (Some(eu_bank_transfer), Some(requested_address_types), Some(type_)) = (
89                self.eu_bank_transfer.take(),
90                self.requested_address_types.take(),
91                self.type_.take(),
92            ) else {
93                return None;
94            };
95            Some(Self::Out { eu_bank_transfer, requested_address_types, type_ })
96        }
97    }
98
99    impl Map for Builder<'_> {
100        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
101            self.builder.key(k)
102        }
103
104        fn finish(&mut self) -> Result<()> {
105            *self.out = self.builder.take_out();
106            Ok(())
107        }
108    }
109
110    impl ObjectDeser for PaymentMethodOptionsCustomerBalanceBankTransfer {
111        type Builder = PaymentMethodOptionsCustomerBalanceBankTransferBuilder;
112    }
113
114    impl FromValueOpt for PaymentMethodOptionsCustomerBalanceBankTransfer {
115        fn from_value(v: Value) -> Option<Self> {
116            let Value::Object(obj) = v else {
117                return None;
118            };
119            let mut b = PaymentMethodOptionsCustomerBalanceBankTransferBuilder::deser_default();
120            for (k, v) in obj {
121                match k.as_str() {
122                    "eu_bank_transfer" => b.eu_bank_transfer = FromValueOpt::from_value(v),
123                    "requested_address_types" => {
124                        b.requested_address_types = FromValueOpt::from_value(v)
125                    }
126                    "type" => b.type_ = FromValueOpt::from_value(v),
127                    _ => {}
128                }
129            }
130            b.take_out()
131        }
132    }
133};
134/// List of address types that should be returned in the financial_addresses response.
135/// If not specified, all valid types will be returned.
136///
137/// Permitted values include: `sort_code`, `zengin`, `iban`, or `spei`.
138#[derive(Clone, Eq, PartialEq)]
139#[non_exhaustive]
140pub enum PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes {
141    Aba,
142    Iban,
143    Sepa,
144    SortCode,
145    Spei,
146    Swift,
147    Zengin,
148    /// An unrecognized value from Stripe. Should not be used as a request parameter.
149    Unknown(String),
150}
151impl PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes {
152    pub fn as_str(&self) -> &str {
153        use PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes::*;
154        match self {
155            Aba => "aba",
156            Iban => "iban",
157            Sepa => "sepa",
158            SortCode => "sort_code",
159            Spei => "spei",
160            Swift => "swift",
161            Zengin => "zengin",
162            Unknown(v) => v,
163        }
164    }
165}
166
167impl std::str::FromStr for PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes {
168    type Err = std::convert::Infallible;
169    fn from_str(s: &str) -> Result<Self, Self::Err> {
170        use PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes::*;
171        match s {
172            "aba" => Ok(Aba),
173            "iban" => Ok(Iban),
174            "sepa" => Ok(Sepa),
175            "sort_code" => Ok(SortCode),
176            "spei" => Ok(Spei),
177            "swift" => Ok(Swift),
178            "zengin" => Ok(Zengin),
179            v => {
180                tracing::warn!(
181                    "Unknown value '{}' for enum '{}'",
182                    v,
183                    "PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes"
184                );
185                Ok(Unknown(v.to_owned()))
186            }
187        }
188    }
189}
190impl std::fmt::Display for PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes {
191    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
192        f.write_str(self.as_str())
193    }
194}
195
196#[cfg(not(feature = "redact-generated-debug"))]
197impl std::fmt::Debug for PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes {
198    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
199        f.write_str(self.as_str())
200    }
201}
202#[cfg(feature = "redact-generated-debug")]
203impl std::fmt::Debug for PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes {
204    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
205        f.debug_struct(stringify!(
206            PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes
207        ))
208        .finish_non_exhaustive()
209    }
210}
211#[cfg(feature = "serialize")]
212impl serde::Serialize for PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes {
213    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
214    where
215        S: serde::Serializer,
216    {
217        serializer.serialize_str(self.as_str())
218    }
219}
220impl miniserde::Deserialize
221    for PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes
222{
223    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
224        crate::Place::new(out)
225    }
226}
227
228impl miniserde::de::Visitor
229    for crate::Place<PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes>
230{
231    fn string(&mut self, s: &str) -> miniserde::Result<()> {
232        use std::str::FromStr;
233        self.out = Some(
234            PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes::from_str(s)
235                .expect("infallible"),
236        );
237        Ok(())
238    }
239}
240
241stripe_types::impl_from_val_with_from_str!(
242    PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes
243);
244#[cfg(feature = "deserialize")]
245impl<'de> serde::Deserialize<'de>
246    for PaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes
247{
248    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
249        use std::str::FromStr;
250        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
251        Ok(Self::from_str(&s).expect("infallible"))
252    }
253}
254/// The bank transfer type that this PaymentIntent is allowed to use for funding Permitted values include: `eu_bank_transfer`, `gb_bank_transfer`, `jp_bank_transfer`, `mx_bank_transfer`, or `us_bank_transfer`.
255#[derive(Clone, Eq, PartialEq)]
256#[non_exhaustive]
257pub enum PaymentMethodOptionsCustomerBalanceBankTransferType {
258    EuBankTransfer,
259    GbBankTransfer,
260    JpBankTransfer,
261    MxBankTransfer,
262    UsBankTransfer,
263    /// An unrecognized value from Stripe. Should not be used as a request parameter.
264    Unknown(String),
265}
266impl PaymentMethodOptionsCustomerBalanceBankTransferType {
267    pub fn as_str(&self) -> &str {
268        use PaymentMethodOptionsCustomerBalanceBankTransferType::*;
269        match self {
270            EuBankTransfer => "eu_bank_transfer",
271            GbBankTransfer => "gb_bank_transfer",
272            JpBankTransfer => "jp_bank_transfer",
273            MxBankTransfer => "mx_bank_transfer",
274            UsBankTransfer => "us_bank_transfer",
275            Unknown(v) => v,
276        }
277    }
278}
279
280impl std::str::FromStr for PaymentMethodOptionsCustomerBalanceBankTransferType {
281    type Err = std::convert::Infallible;
282    fn from_str(s: &str) -> Result<Self, Self::Err> {
283        use PaymentMethodOptionsCustomerBalanceBankTransferType::*;
284        match s {
285            "eu_bank_transfer" => Ok(EuBankTransfer),
286            "gb_bank_transfer" => Ok(GbBankTransfer),
287            "jp_bank_transfer" => Ok(JpBankTransfer),
288            "mx_bank_transfer" => Ok(MxBankTransfer),
289            "us_bank_transfer" => Ok(UsBankTransfer),
290            v => {
291                tracing::warn!(
292                    "Unknown value '{}' for enum '{}'",
293                    v,
294                    "PaymentMethodOptionsCustomerBalanceBankTransferType"
295                );
296                Ok(Unknown(v.to_owned()))
297            }
298        }
299    }
300}
301impl std::fmt::Display for PaymentMethodOptionsCustomerBalanceBankTransferType {
302    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
303        f.write_str(self.as_str())
304    }
305}
306
307#[cfg(not(feature = "redact-generated-debug"))]
308impl std::fmt::Debug for PaymentMethodOptionsCustomerBalanceBankTransferType {
309    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
310        f.write_str(self.as_str())
311    }
312}
313#[cfg(feature = "redact-generated-debug")]
314impl std::fmt::Debug for PaymentMethodOptionsCustomerBalanceBankTransferType {
315    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
316        f.debug_struct(stringify!(PaymentMethodOptionsCustomerBalanceBankTransferType))
317            .finish_non_exhaustive()
318    }
319}
320#[cfg(feature = "serialize")]
321impl serde::Serialize for PaymentMethodOptionsCustomerBalanceBankTransferType {
322    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
323    where
324        S: serde::Serializer,
325    {
326        serializer.serialize_str(self.as_str())
327    }
328}
329impl miniserde::Deserialize for PaymentMethodOptionsCustomerBalanceBankTransferType {
330    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
331        crate::Place::new(out)
332    }
333}
334
335impl miniserde::de::Visitor for crate::Place<PaymentMethodOptionsCustomerBalanceBankTransferType> {
336    fn string(&mut self, s: &str) -> miniserde::Result<()> {
337        use std::str::FromStr;
338        self.out = Some(
339            PaymentMethodOptionsCustomerBalanceBankTransferType::from_str(s).expect("infallible"),
340        );
341        Ok(())
342    }
343}
344
345stripe_types::impl_from_val_with_from_str!(PaymentMethodOptionsCustomerBalanceBankTransferType);
346#[cfg(feature = "deserialize")]
347impl<'de> serde::Deserialize<'de> for PaymentMethodOptionsCustomerBalanceBankTransferType {
348    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
349        use std::str::FromStr;
350        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
351        Ok(Self::from_str(&s).expect("infallible"))
352    }
353}
stripe_shared/payment_method_options_customer_balance_bank_transfer.rs

stripe_shared/
payment_method_options_customer_balance_bank_transfer.rs
