stripe_misc/
bank_connections_resource_account_number_details.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct BankConnectionsResourceAccountNumberDetails {
5    /// When the account number is expected to expire, if applicable.
6    pub expected_expiry_date: Option<stripe_types::Timestamp>,
7    /// The type of account number associated with the account.
8    pub identifier_type: BankConnectionsResourceAccountNumberDetailsIdentifierType,
9    /// Whether the account number is currently active and usable for transactions.
10    pub status: BankConnectionsResourceAccountNumberDetailsStatus,
11    /// The payment networks that the account number can be used for.
12    pub supported_networks: Vec<BankConnectionsResourceAccountNumberDetailsSupportedNetworks>,
13}
14#[doc(hidden)]
15pub struct BankConnectionsResourceAccountNumberDetailsBuilder {
16    expected_expiry_date: Option<Option<stripe_types::Timestamp>>,
17    identifier_type: Option<BankConnectionsResourceAccountNumberDetailsIdentifierType>,
18    status: Option<BankConnectionsResourceAccountNumberDetailsStatus>,
19    supported_networks: Option<Vec<BankConnectionsResourceAccountNumberDetailsSupportedNetworks>>,
20}
21
22#[allow(
23    unused_variables,
24    irrefutable_let_patterns,
25    clippy::let_unit_value,
26    clippy::match_single_binding,
27    clippy::single_match
28)]
29const _: () = {
30    use miniserde::de::{Map, Visitor};
31    use miniserde::json::Value;
32    use miniserde::{Deserialize, Result, make_place};
33    use stripe_types::miniserde_helpers::FromValueOpt;
34    use stripe_types::{MapBuilder, ObjectDeser};
35
36    make_place!(Place);
37
38    impl Deserialize for BankConnectionsResourceAccountNumberDetails {
39        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
40            Place::new(out)
41        }
42    }
43
44    struct Builder<'a> {
45        out: &'a mut Option<BankConnectionsResourceAccountNumberDetails>,
46        builder: BankConnectionsResourceAccountNumberDetailsBuilder,
47    }
48
49    impl Visitor for Place<BankConnectionsResourceAccountNumberDetails> {
50        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
51            Ok(Box::new(Builder {
52                out: &mut self.out,
53                builder: BankConnectionsResourceAccountNumberDetailsBuilder::deser_default(),
54            }))
55        }
56    }
57
58    impl MapBuilder for BankConnectionsResourceAccountNumberDetailsBuilder {
59        type Out = BankConnectionsResourceAccountNumberDetails;
60        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
61            Ok(match k {
62                "expected_expiry_date" => Deserialize::begin(&mut self.expected_expiry_date),
63                "identifier_type" => Deserialize::begin(&mut self.identifier_type),
64                "status" => Deserialize::begin(&mut self.status),
65                "supported_networks" => Deserialize::begin(&mut self.supported_networks),
66                _ => <dyn Visitor>::ignore(),
67            })
68        }
69
70        fn deser_default() -> Self {
71            Self {
72                expected_expiry_date: Deserialize::default(),
73                identifier_type: Deserialize::default(),
74                status: Deserialize::default(),
75                supported_networks: Deserialize::default(),
76            }
77        }
78
79        fn take_out(&mut self) -> Option<Self::Out> {
80            let (
81                Some(expected_expiry_date),
82                Some(identifier_type),
83                Some(status),
84                Some(supported_networks),
85            ) = (
86                self.expected_expiry_date,
87                self.identifier_type,
88                self.status,
89                self.supported_networks.take(),
90            )
91            else {
92                return None;
93            };
94            Some(Self::Out { expected_expiry_date, identifier_type, status, supported_networks })
95        }
96    }
97
98    impl Map for Builder<'_> {
99        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
100            self.builder.key(k)
101        }
102
103        fn finish(&mut self) -> Result<()> {
104            *self.out = self.builder.take_out();
105            Ok(())
106        }
107    }
108
109    impl ObjectDeser for BankConnectionsResourceAccountNumberDetails {
110        type Builder = BankConnectionsResourceAccountNumberDetailsBuilder;
111    }
112
113    impl FromValueOpt for BankConnectionsResourceAccountNumberDetails {
114        fn from_value(v: Value) -> Option<Self> {
115            let Value::Object(obj) = v else {
116                return None;
117            };
118            let mut b = BankConnectionsResourceAccountNumberDetailsBuilder::deser_default();
119            for (k, v) in obj {
120                match k.as_str() {
121                    "expected_expiry_date" => b.expected_expiry_date = FromValueOpt::from_value(v),
122                    "identifier_type" => b.identifier_type = FromValueOpt::from_value(v),
123                    "status" => b.status = FromValueOpt::from_value(v),
124                    "supported_networks" => b.supported_networks = FromValueOpt::from_value(v),
125                    _ => {}
126                }
127            }
128            b.take_out()
129        }
130    }
131};
132/// The type of account number associated with the account.
133#[derive(Copy, Clone, Eq, PartialEq)]
134pub enum BankConnectionsResourceAccountNumberDetailsIdentifierType {
135    AccountNumber,
136    TokenizedAccountNumber,
137}
138impl BankConnectionsResourceAccountNumberDetailsIdentifierType {
139    pub fn as_str(self) -> &'static str {
140        use BankConnectionsResourceAccountNumberDetailsIdentifierType::*;
141        match self {
142            AccountNumber => "account_number",
143            TokenizedAccountNumber => "tokenized_account_number",
144        }
145    }
146}
147
148impl std::str::FromStr for BankConnectionsResourceAccountNumberDetailsIdentifierType {
149    type Err = stripe_types::StripeParseError;
150    fn from_str(s: &str) -> Result<Self, Self::Err> {
151        use BankConnectionsResourceAccountNumberDetailsIdentifierType::*;
152        match s {
153            "account_number" => Ok(AccountNumber),
154            "tokenized_account_number" => Ok(TokenizedAccountNumber),
155            _ => Err(stripe_types::StripeParseError),
156        }
157    }
158}
159impl std::fmt::Display for BankConnectionsResourceAccountNumberDetailsIdentifierType {
160    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
161        f.write_str(self.as_str())
162    }
163}
164
165impl std::fmt::Debug for BankConnectionsResourceAccountNumberDetailsIdentifierType {
166    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
167        f.write_str(self.as_str())
168    }
169}
170#[cfg(feature = "serialize")]
171impl serde::Serialize for BankConnectionsResourceAccountNumberDetailsIdentifierType {
172    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
173    where
174        S: serde::Serializer,
175    {
176        serializer.serialize_str(self.as_str())
177    }
178}
179impl miniserde::Deserialize for BankConnectionsResourceAccountNumberDetailsIdentifierType {
180    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
181        crate::Place::new(out)
182    }
183}
184
185impl miniserde::de::Visitor
186    for crate::Place<BankConnectionsResourceAccountNumberDetailsIdentifierType>
187{
188    fn string(&mut self, s: &str) -> miniserde::Result<()> {
189        use std::str::FromStr;
190        self.out = Some(
191            BankConnectionsResourceAccountNumberDetailsIdentifierType::from_str(s)
192                .map_err(|_| miniserde::Error)?,
193        );
194        Ok(())
195    }
196}
197
198stripe_types::impl_from_val_with_from_str!(
199    BankConnectionsResourceAccountNumberDetailsIdentifierType
200);
201#[cfg(feature = "deserialize")]
202impl<'de> serde::Deserialize<'de> for BankConnectionsResourceAccountNumberDetailsIdentifierType {
203    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
204        use std::str::FromStr;
205        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
206        Self::from_str(&s).map_err(|_| {
207            serde::de::Error::custom(
208                "Unknown value for BankConnectionsResourceAccountNumberDetailsIdentifierType",
209            )
210        })
211    }
212}
213/// Whether the account number is currently active and usable for transactions.
214#[derive(Copy, Clone, Eq, PartialEq)]
215pub enum BankConnectionsResourceAccountNumberDetailsStatus {
216    Deactivated,
217    Transactable,
218}
219impl BankConnectionsResourceAccountNumberDetailsStatus {
220    pub fn as_str(self) -> &'static str {
221        use BankConnectionsResourceAccountNumberDetailsStatus::*;
222        match self {
223            Deactivated => "deactivated",
224            Transactable => "transactable",
225        }
226    }
227}
228
229impl std::str::FromStr for BankConnectionsResourceAccountNumberDetailsStatus {
230    type Err = stripe_types::StripeParseError;
231    fn from_str(s: &str) -> Result<Self, Self::Err> {
232        use BankConnectionsResourceAccountNumberDetailsStatus::*;
233        match s {
234            "deactivated" => Ok(Deactivated),
235            "transactable" => Ok(Transactable),
236            _ => Err(stripe_types::StripeParseError),
237        }
238    }
239}
240impl std::fmt::Display for BankConnectionsResourceAccountNumberDetailsStatus {
241    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
242        f.write_str(self.as_str())
243    }
244}
245
246impl std::fmt::Debug for BankConnectionsResourceAccountNumberDetailsStatus {
247    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
248        f.write_str(self.as_str())
249    }
250}
251#[cfg(feature = "serialize")]
252impl serde::Serialize for BankConnectionsResourceAccountNumberDetailsStatus {
253    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
254    where
255        S: serde::Serializer,
256    {
257        serializer.serialize_str(self.as_str())
258    }
259}
260impl miniserde::Deserialize for BankConnectionsResourceAccountNumberDetailsStatus {
261    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
262        crate::Place::new(out)
263    }
264}
265
266impl miniserde::de::Visitor for crate::Place<BankConnectionsResourceAccountNumberDetailsStatus> {
267    fn string(&mut self, s: &str) -> miniserde::Result<()> {
268        use std::str::FromStr;
269        self.out = Some(
270            BankConnectionsResourceAccountNumberDetailsStatus::from_str(s)
271                .map_err(|_| miniserde::Error)?,
272        );
273        Ok(())
274    }
275}
276
277stripe_types::impl_from_val_with_from_str!(BankConnectionsResourceAccountNumberDetailsStatus);
278#[cfg(feature = "deserialize")]
279impl<'de> serde::Deserialize<'de> for BankConnectionsResourceAccountNumberDetailsStatus {
280    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
281        use std::str::FromStr;
282        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
283        Self::from_str(&s).map_err(|_| {
284            serde::de::Error::custom(
285                "Unknown value for BankConnectionsResourceAccountNumberDetailsStatus",
286            )
287        })
288    }
289}
290/// The payment networks that the account number can be used for.
291#[derive(Copy, Clone, Eq, PartialEq)]
292pub enum BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
293    Ach,
294}
295impl BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
296    pub fn as_str(self) -> &'static str {
297        use BankConnectionsResourceAccountNumberDetailsSupportedNetworks::*;
298        match self {
299            Ach => "ach",
300        }
301    }
302}
303
304impl std::str::FromStr for BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
305    type Err = stripe_types::StripeParseError;
306    fn from_str(s: &str) -> Result<Self, Self::Err> {
307        use BankConnectionsResourceAccountNumberDetailsSupportedNetworks::*;
308        match s {
309            "ach" => Ok(Ach),
310            _ => Err(stripe_types::StripeParseError),
311        }
312    }
313}
314impl std::fmt::Display for BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
315    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
316        f.write_str(self.as_str())
317    }
318}
319
320impl std::fmt::Debug for BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
321    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
322        f.write_str(self.as_str())
323    }
324}
325#[cfg(feature = "serialize")]
326impl serde::Serialize for BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
327    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
328    where
329        S: serde::Serializer,
330    {
331        serializer.serialize_str(self.as_str())
332    }
333}
334impl miniserde::Deserialize for BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
335    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
336        crate::Place::new(out)
337    }
338}
339
340impl miniserde::de::Visitor
341    for crate::Place<BankConnectionsResourceAccountNumberDetailsSupportedNetworks>
342{
343    fn string(&mut self, s: &str) -> miniserde::Result<()> {
344        use std::str::FromStr;
345        self.out = Some(
346            BankConnectionsResourceAccountNumberDetailsSupportedNetworks::from_str(s)
347                .map_err(|_| miniserde::Error)?,
348        );
349        Ok(())
350    }
351}
352
353stripe_types::impl_from_val_with_from_str!(
354    BankConnectionsResourceAccountNumberDetailsSupportedNetworks
355);
356#[cfg(feature = "deserialize")]
357impl<'de> serde::Deserialize<'de> for BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
358    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
359        use std::str::FromStr;
360        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
361        Self::from_str(&s).map_err(|_| {
362            serde::de::Error::custom(
363                "Unknown value for BankConnectionsResourceAccountNumberDetailsSupportedNetworks",
364            )
365        })
366    }
367}
stripe_misc/bank_connections_resource_account_number_details.rs

stripe_misc/
bank_connections_resource_account_number_details.rs
