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

stripe_shared/
funding_instructions_bank_transfer_financial_address.rs
