stripe_shared/
funding_instructions_bank_transfer_financial_address.rs

1/// FinancialAddresses contain identifying information that resolves to a FinancialAccount.
2#[derive(Clone, Debug)]
3#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
4#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
5pub struct FundingInstructionsBankTransferFinancialAddress {
6    pub aba: Option<stripe_shared::FundingInstructionsBankTransferAbaRecord>,
7    pub iban: Option<stripe_shared::FundingInstructionsBankTransferIbanRecord>,
8    pub sort_code: Option<stripe_shared::FundingInstructionsBankTransferSortCodeRecord>,
9    pub spei: Option<stripe_shared::FundingInstructionsBankTransferSpeiRecord>,
10    /// The payment networks supported by this FinancialAddress
11    pub supported_networks:
12        Option<Vec<FundingInstructionsBankTransferFinancialAddressSupportedNetworks>>,
13    pub swift: Option<stripe_shared::FundingInstructionsBankTransferSwiftRecord>,
14    /// The type of financial address
15    #[cfg_attr(any(feature = "deserialize", feature = "serialize"), serde(rename = "type"))]
16    pub type_: FundingInstructionsBankTransferFinancialAddressType,
17    pub zengin: Option<stripe_shared::FundingInstructionsBankTransferZenginRecord>,
18}
19#[doc(hidden)]
20pub struct FundingInstructionsBankTransferFinancialAddressBuilder {
21    aba: Option<Option<stripe_shared::FundingInstructionsBankTransferAbaRecord>>,
22    iban: Option<Option<stripe_shared::FundingInstructionsBankTransferIbanRecord>>,
23    sort_code: Option<Option<stripe_shared::FundingInstructionsBankTransferSortCodeRecord>>,
24    spei: Option<Option<stripe_shared::FundingInstructionsBankTransferSpeiRecord>>,
25    supported_networks:
26        Option<Option<Vec<FundingInstructionsBankTransferFinancialAddressSupportedNetworks>>>,
27    swift: Option<Option<stripe_shared::FundingInstructionsBankTransferSwiftRecord>>,
28    type_: Option<FundingInstructionsBankTransferFinancialAddressType>,
29    zengin: Option<Option<stripe_shared::FundingInstructionsBankTransferZenginRecord>>,
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 FundingInstructionsBankTransferFinancialAddress {
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<FundingInstructionsBankTransferFinancialAddress>,
56        builder: FundingInstructionsBankTransferFinancialAddressBuilder,
57    }
58
59    impl Visitor for Place<FundingInstructionsBankTransferFinancialAddress> {
60        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
61            Ok(Box::new(Builder {
62                out: &mut self.out,
63                builder: FundingInstructionsBankTransferFinancialAddressBuilder::deser_default(),
64            }))
65        }
66    }
67
68    impl MapBuilder for FundingInstructionsBankTransferFinancialAddressBuilder {
69        type Out = FundingInstructionsBankTransferFinancialAddress;
70        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
71            Ok(match k {
72                "aba" => Deserialize::begin(&mut self.aba),
73                "iban" => Deserialize::begin(&mut self.iban),
74                "sort_code" => Deserialize::begin(&mut self.sort_code),
75                "spei" => Deserialize::begin(&mut self.spei),
76                "supported_networks" => Deserialize::begin(&mut self.supported_networks),
77                "swift" => Deserialize::begin(&mut self.swift),
78                "type" => Deserialize::begin(&mut self.type_),
79                "zengin" => Deserialize::begin(&mut self.zengin),
80
81                _ => <dyn Visitor>::ignore(),
82            })
83        }
84
85        fn deser_default() -> Self {
86            Self {
87                aba: Deserialize::default(),
88                iban: Deserialize::default(),
89                sort_code: Deserialize::default(),
90                spei: Deserialize::default(),
91                supported_networks: Deserialize::default(),
92                swift: Deserialize::default(),
93                type_: Deserialize::default(),
94                zengin: Deserialize::default(),
95            }
96        }
97
98        fn take_out(&mut self) -> Option<Self::Out> {
99            let (
100                Some(aba),
101                Some(iban),
102                Some(sort_code),
103                Some(spei),
104                Some(supported_networks),
105                Some(swift),
106                Some(type_),
107                Some(zengin),
108            ) = (
109                self.aba.take(),
110                self.iban.take(),
111                self.sort_code.take(),
112                self.spei.take(),
113                self.supported_networks.take(),
114                self.swift.take(),
115                self.type_,
116                self.zengin.take(),
117            )
118            else {
119                return None;
120            };
121            Some(Self::Out { aba, iban, sort_code, spei, supported_networks, swift, type_, zengin })
122        }
123    }
124
125    impl Map for Builder<'_> {
126        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
127            self.builder.key(k)
128        }
129
130        fn finish(&mut self) -> Result<()> {
131            *self.out = self.builder.take_out();
132            Ok(())
133        }
134    }
135
136    impl ObjectDeser for FundingInstructionsBankTransferFinancialAddress {
137        type Builder = FundingInstructionsBankTransferFinancialAddressBuilder;
138    }
139
140    impl FromValueOpt for FundingInstructionsBankTransferFinancialAddress {
141        fn from_value(v: Value) -> Option<Self> {
142            let Value::Object(obj) = v else {
143                return None;
144            };
145            let mut b = FundingInstructionsBankTransferFinancialAddressBuilder::deser_default();
146            for (k, v) in obj {
147                match k.as_str() {
148                    "aba" => b.aba = FromValueOpt::from_value(v),
149                    "iban" => b.iban = FromValueOpt::from_value(v),
150                    "sort_code" => b.sort_code = FromValueOpt::from_value(v),
151                    "spei" => b.spei = FromValueOpt::from_value(v),
152                    "supported_networks" => b.supported_networks = FromValueOpt::from_value(v),
153                    "swift" => b.swift = FromValueOpt::from_value(v),
154                    "type" => b.type_ = FromValueOpt::from_value(v),
155                    "zengin" => b.zengin = FromValueOpt::from_value(v),
156
157                    _ => {}
158                }
159            }
160            b.take_out()
161        }
162    }
163};
164/// The payment networks supported by this FinancialAddress
165#[derive(Copy, Clone, Eq, PartialEq)]
166pub enum FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
167    Ach,
168    Bacs,
169    DomesticWireUs,
170    Fps,
171    Sepa,
172    Spei,
173    Swift,
174    Zengin,
175}
176impl FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
177    pub fn as_str(self) -> &'static str {
178        use FundingInstructionsBankTransferFinancialAddressSupportedNetworks::*;
179        match self {
180            Ach => "ach",
181            Bacs => "bacs",
182            DomesticWireUs => "domestic_wire_us",
183            Fps => "fps",
184            Sepa => "sepa",
185            Spei => "spei",
186            Swift => "swift",
187            Zengin => "zengin",
188        }
189    }
190}
191
192impl std::str::FromStr for FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
193    type Err = stripe_types::StripeParseError;
194    fn from_str(s: &str) -> Result<Self, Self::Err> {
195        use FundingInstructionsBankTransferFinancialAddressSupportedNetworks::*;
196        match s {
197            "ach" => Ok(Ach),
198            "bacs" => Ok(Bacs),
199            "domestic_wire_us" => Ok(DomesticWireUs),
200            "fps" => Ok(Fps),
201            "sepa" => Ok(Sepa),
202            "spei" => Ok(Spei),
203            "swift" => Ok(Swift),
204            "zengin" => Ok(Zengin),
205            _ => Err(stripe_types::StripeParseError),
206        }
207    }
208}
209impl std::fmt::Display for FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
210    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
211        f.write_str(self.as_str())
212    }
213}
214
215impl std::fmt::Debug for FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
216    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
217        f.write_str(self.as_str())
218    }
219}
220#[cfg(feature = "serialize")]
221impl serde::Serialize for FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
222    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
223    where
224        S: serde::Serializer,
225    {
226        serializer.serialize_str(self.as_str())
227    }
228}
229impl miniserde::Deserialize for FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
230    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
231        crate::Place::new(out)
232    }
233}
234
235impl miniserde::de::Visitor
236    for crate::Place<FundingInstructionsBankTransferFinancialAddressSupportedNetworks>
237{
238    fn string(&mut self, s: &str) -> miniserde::Result<()> {
239        use std::str::FromStr;
240        self.out = Some(
241            FundingInstructionsBankTransferFinancialAddressSupportedNetworks::from_str(s)
242                .map_err(|_| miniserde::Error)?,
243        );
244        Ok(())
245    }
246}
247
248stripe_types::impl_from_val_with_from_str!(
249    FundingInstructionsBankTransferFinancialAddressSupportedNetworks
250);
251#[cfg(feature = "deserialize")]
252impl<'de> serde::Deserialize<'de>
253    for FundingInstructionsBankTransferFinancialAddressSupportedNetworks
254{
255    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
256        use std::str::FromStr;
257        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
258        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for FundingInstructionsBankTransferFinancialAddressSupportedNetworks"))
259    }
260}
261/// The type of financial address
262#[derive(Copy, Clone, Eq, PartialEq)]
263pub enum FundingInstructionsBankTransferFinancialAddressType {
264    Aba,
265    Iban,
266    SortCode,
267    Spei,
268    Swift,
269    Zengin,
270}
271impl FundingInstructionsBankTransferFinancialAddressType {
272    pub fn as_str(self) -> &'static str {
273        use FundingInstructionsBankTransferFinancialAddressType::*;
274        match self {
275            Aba => "aba",
276            Iban => "iban",
277            SortCode => "sort_code",
278            Spei => "spei",
279            Swift => "swift",
280            Zengin => "zengin",
281        }
282    }
283}
284
285impl std::str::FromStr for FundingInstructionsBankTransferFinancialAddressType {
286    type Err = stripe_types::StripeParseError;
287    fn from_str(s: &str) -> Result<Self, Self::Err> {
288        use FundingInstructionsBankTransferFinancialAddressType::*;
289        match s {
290            "aba" => Ok(Aba),
291            "iban" => Ok(Iban),
292            "sort_code" => Ok(SortCode),
293            "spei" => Ok(Spei),
294            "swift" => Ok(Swift),
295            "zengin" => Ok(Zengin),
296            _ => Err(stripe_types::StripeParseError),
297        }
298    }
299}
300impl std::fmt::Display for FundingInstructionsBankTransferFinancialAddressType {
301    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
302        f.write_str(self.as_str())
303    }
304}
305
306impl std::fmt::Debug for FundingInstructionsBankTransferFinancialAddressType {
307    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
308        f.write_str(self.as_str())
309    }
310}
311#[cfg(feature = "serialize")]
312impl serde::Serialize for FundingInstructionsBankTransferFinancialAddressType {
313    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
314    where
315        S: serde::Serializer,
316    {
317        serializer.serialize_str(self.as_str())
318    }
319}
320impl miniserde::Deserialize for FundingInstructionsBankTransferFinancialAddressType {
321    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
322        crate::Place::new(out)
323    }
324}
325
326impl miniserde::de::Visitor for crate::Place<FundingInstructionsBankTransferFinancialAddressType> {
327    fn string(&mut self, s: &str) -> miniserde::Result<()> {
328        use std::str::FromStr;
329        self.out = Some(
330            FundingInstructionsBankTransferFinancialAddressType::from_str(s)
331                .map_err(|_| miniserde::Error)?,
332        );
333        Ok(())
334    }
335}
336
337stripe_types::impl_from_val_with_from_str!(FundingInstructionsBankTransferFinancialAddressType);
338#[cfg(feature = "deserialize")]
339impl<'de> serde::Deserialize<'de> for FundingInstructionsBankTransferFinancialAddressType {
340    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
341        use std::str::FromStr;
342        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
343        Self::from_str(&s).map_err(|_| {
344            serde::de::Error::custom(
345                "Unknown value for FundingInstructionsBankTransferFinancialAddressType",
346            )
347        })
348    }
349}
stripe_shared/funding_instructions_bank_transfer_financial_address.rs

stripe_shared/
funding_instructions_bank_transfer_financial_address.rs
