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_.take(),
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(Clone, Eq, PartialEq)]
164#[non_exhaustive]
165pub enum FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
166    Ach,
167    Bacs,
168    DomesticWireUs,
169    Fps,
170    Sepa,
171    Spei,
172    Swift,
173    Zengin,
174    /// An unrecognized value from Stripe. Should not be used as a request parameter.
175    Unknown(String),
176}
177impl FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
178    pub fn as_str(&self) -> &str {
179        use FundingInstructionsBankTransferFinancialAddressSupportedNetworks::*;
180        match self {
181            Ach => "ach",
182            Bacs => "bacs",
183            DomesticWireUs => "domestic_wire_us",
184            Fps => "fps",
185            Sepa => "sepa",
186            Spei => "spei",
187            Swift => "swift",
188            Zengin => "zengin",
189            Unknown(v) => v,
190        }
191    }
192}
193
194impl std::str::FromStr for FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
195    type Err = std::convert::Infallible;
196    fn from_str(s: &str) -> Result<Self, Self::Err> {
197        use FundingInstructionsBankTransferFinancialAddressSupportedNetworks::*;
198        match s {
199            "ach" => Ok(Ach),
200            "bacs" => Ok(Bacs),
201            "domestic_wire_us" => Ok(DomesticWireUs),
202            "fps" => Ok(Fps),
203            "sepa" => Ok(Sepa),
204            "spei" => Ok(Spei),
205            "swift" => Ok(Swift),
206            "zengin" => Ok(Zengin),
207            v => {
208                tracing::warn!(
209                    "Unknown value '{}' for enum '{}'",
210                    v,
211                    "FundingInstructionsBankTransferFinancialAddressSupportedNetworks"
212                );
213                Ok(Unknown(v.to_owned()))
214            }
215        }
216    }
217}
218impl std::fmt::Display for FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
219    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
220        f.write_str(self.as_str())
221    }
222}
223
224impl std::fmt::Debug for FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
225    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
226        f.write_str(self.as_str())
227    }
228}
229#[cfg(feature = "serialize")]
230impl serde::Serialize for FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
231    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
232    where
233        S: serde::Serializer,
234    {
235        serializer.serialize_str(self.as_str())
236    }
237}
238impl miniserde::Deserialize for FundingInstructionsBankTransferFinancialAddressSupportedNetworks {
239    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
240        crate::Place::new(out)
241    }
242}
243
244impl miniserde::de::Visitor
245    for crate::Place<FundingInstructionsBankTransferFinancialAddressSupportedNetworks>
246{
247    fn string(&mut self, s: &str) -> miniserde::Result<()> {
248        use std::str::FromStr;
249        self.out = Some(
250            FundingInstructionsBankTransferFinancialAddressSupportedNetworks::from_str(s)
251                .expect("infallible"),
252        );
253        Ok(())
254    }
255}
256
257stripe_types::impl_from_val_with_from_str!(
258    FundingInstructionsBankTransferFinancialAddressSupportedNetworks
259);
260#[cfg(feature = "deserialize")]
261impl<'de> serde::Deserialize<'de>
262    for FundingInstructionsBankTransferFinancialAddressSupportedNetworks
263{
264    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
265        use std::str::FromStr;
266        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
267        Ok(Self::from_str(&s).expect("infallible"))
268    }
269}
270/// The type of financial address
271#[derive(Clone, Eq, PartialEq)]
272#[non_exhaustive]
273pub enum FundingInstructionsBankTransferFinancialAddressType {
274    Aba,
275    Iban,
276    SortCode,
277    Spei,
278    Swift,
279    Zengin,
280    /// An unrecognized value from Stripe. Should not be used as a request parameter.
281    Unknown(String),
282}
283impl FundingInstructionsBankTransferFinancialAddressType {
284    pub fn as_str(&self) -> &str {
285        use FundingInstructionsBankTransferFinancialAddressType::*;
286        match self {
287            Aba => "aba",
288            Iban => "iban",
289            SortCode => "sort_code",
290            Spei => "spei",
291            Swift => "swift",
292            Zengin => "zengin",
293            Unknown(v) => v,
294        }
295    }
296}
297
298impl std::str::FromStr for FundingInstructionsBankTransferFinancialAddressType {
299    type Err = std::convert::Infallible;
300    fn from_str(s: &str) -> Result<Self, Self::Err> {
301        use FundingInstructionsBankTransferFinancialAddressType::*;
302        match s {
303            "aba" => Ok(Aba),
304            "iban" => Ok(Iban),
305            "sort_code" => Ok(SortCode),
306            "spei" => Ok(Spei),
307            "swift" => Ok(Swift),
308            "zengin" => Ok(Zengin),
309            v => {
310                tracing::warn!(
311                    "Unknown value '{}' for enum '{}'",
312                    v,
313                    "FundingInstructionsBankTransferFinancialAddressType"
314                );
315                Ok(Unknown(v.to_owned()))
316            }
317        }
318    }
319}
320impl std::fmt::Display for FundingInstructionsBankTransferFinancialAddressType {
321    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
322        f.write_str(self.as_str())
323    }
324}
325
326impl std::fmt::Debug for FundingInstructionsBankTransferFinancialAddressType {
327    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
328        f.write_str(self.as_str())
329    }
330}
331#[cfg(feature = "serialize")]
332impl serde::Serialize for FundingInstructionsBankTransferFinancialAddressType {
333    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
334    where
335        S: serde::Serializer,
336    {
337        serializer.serialize_str(self.as_str())
338    }
339}
340impl miniserde::Deserialize for FundingInstructionsBankTransferFinancialAddressType {
341    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
342        crate::Place::new(out)
343    }
344}
345
346impl miniserde::de::Visitor for crate::Place<FundingInstructionsBankTransferFinancialAddressType> {
347    fn string(&mut self, s: &str) -> miniserde::Result<()> {
348        use std::str::FromStr;
349        self.out = Some(
350            FundingInstructionsBankTransferFinancialAddressType::from_str(s).expect("infallible"),
351        );
352        Ok(())
353    }
354}
355
356stripe_types::impl_from_val_with_from_str!(FundingInstructionsBankTransferFinancialAddressType);
357#[cfg(feature = "deserialize")]
358impl<'de> serde::Deserialize<'de> for FundingInstructionsBankTransferFinancialAddressType {
359    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
360        use std::str::FromStr;
361        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
362        Ok(Self::from_str(&s).expect("infallible"))
363    }
364}
stripe_shared/funding_instructions_bank_transfer_financial_address.rs

stripe_shared/
funding_instructions_bank_transfer_financial_address.rs
