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.take(),
88                self.status.take(),
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(Clone, Eq, PartialEq)]
134#[non_exhaustive]
135pub enum BankConnectionsResourceAccountNumberDetailsIdentifierType {
136    AccountNumber,
137    TokenizedAccountNumber,
138    /// An unrecognized value from Stripe. Should not be used as a request parameter.
139    Unknown(String),
140}
141impl BankConnectionsResourceAccountNumberDetailsIdentifierType {
142    pub fn as_str(&self) -> &str {
143        use BankConnectionsResourceAccountNumberDetailsIdentifierType::*;
144        match self {
145            AccountNumber => "account_number",
146            TokenizedAccountNumber => "tokenized_account_number",
147            Unknown(v) => v,
148        }
149    }
150}
151
152impl std::str::FromStr for BankConnectionsResourceAccountNumberDetailsIdentifierType {
153    type Err = std::convert::Infallible;
154    fn from_str(s: &str) -> Result<Self, Self::Err> {
155        use BankConnectionsResourceAccountNumberDetailsIdentifierType::*;
156        match s {
157            "account_number" => Ok(AccountNumber),
158            "tokenized_account_number" => Ok(TokenizedAccountNumber),
159            v => {
160                tracing::warn!(
161                    "Unknown value '{}' for enum '{}'",
162                    v,
163                    "BankConnectionsResourceAccountNumberDetailsIdentifierType"
164                );
165                Ok(Unknown(v.to_owned()))
166            }
167        }
168    }
169}
170impl std::fmt::Display for BankConnectionsResourceAccountNumberDetailsIdentifierType {
171    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
172        f.write_str(self.as_str())
173    }
174}
175
176impl std::fmt::Debug for BankConnectionsResourceAccountNumberDetailsIdentifierType {
177    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
178        f.write_str(self.as_str())
179    }
180}
181#[cfg(feature = "serialize")]
182impl serde::Serialize for BankConnectionsResourceAccountNumberDetailsIdentifierType {
183    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
184    where
185        S: serde::Serializer,
186    {
187        serializer.serialize_str(self.as_str())
188    }
189}
190impl miniserde::Deserialize for BankConnectionsResourceAccountNumberDetailsIdentifierType {
191    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
192        crate::Place::new(out)
193    }
194}
195
196impl miniserde::de::Visitor
197    for crate::Place<BankConnectionsResourceAccountNumberDetailsIdentifierType>
198{
199    fn string(&mut self, s: &str) -> miniserde::Result<()> {
200        use std::str::FromStr;
201        self.out = Some(
202            BankConnectionsResourceAccountNumberDetailsIdentifierType::from_str(s)
203                .expect("infallible"),
204        );
205        Ok(())
206    }
207}
208
209stripe_types::impl_from_val_with_from_str!(
210    BankConnectionsResourceAccountNumberDetailsIdentifierType
211);
212#[cfg(feature = "deserialize")]
213impl<'de> serde::Deserialize<'de> for BankConnectionsResourceAccountNumberDetailsIdentifierType {
214    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
215        use std::str::FromStr;
216        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
217        Ok(Self::from_str(&s).expect("infallible"))
218    }
219}
220/// Whether the account number is currently active and usable for transactions.
221#[derive(Clone, Eq, PartialEq)]
222#[non_exhaustive]
223pub enum BankConnectionsResourceAccountNumberDetailsStatus {
224    Deactivated,
225    Transactable,
226    /// An unrecognized value from Stripe. Should not be used as a request parameter.
227    Unknown(String),
228}
229impl BankConnectionsResourceAccountNumberDetailsStatus {
230    pub fn as_str(&self) -> &str {
231        use BankConnectionsResourceAccountNumberDetailsStatus::*;
232        match self {
233            Deactivated => "deactivated",
234            Transactable => "transactable",
235            Unknown(v) => v,
236        }
237    }
238}
239
240impl std::str::FromStr for BankConnectionsResourceAccountNumberDetailsStatus {
241    type Err = std::convert::Infallible;
242    fn from_str(s: &str) -> Result<Self, Self::Err> {
243        use BankConnectionsResourceAccountNumberDetailsStatus::*;
244        match s {
245            "deactivated" => Ok(Deactivated),
246            "transactable" => Ok(Transactable),
247            v => {
248                tracing::warn!(
249                    "Unknown value '{}' for enum '{}'",
250                    v,
251                    "BankConnectionsResourceAccountNumberDetailsStatus"
252                );
253                Ok(Unknown(v.to_owned()))
254            }
255        }
256    }
257}
258impl std::fmt::Display for BankConnectionsResourceAccountNumberDetailsStatus {
259    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
260        f.write_str(self.as_str())
261    }
262}
263
264impl std::fmt::Debug for BankConnectionsResourceAccountNumberDetailsStatus {
265    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
266        f.write_str(self.as_str())
267    }
268}
269#[cfg(feature = "serialize")]
270impl serde::Serialize for BankConnectionsResourceAccountNumberDetailsStatus {
271    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
272    where
273        S: serde::Serializer,
274    {
275        serializer.serialize_str(self.as_str())
276    }
277}
278impl miniserde::Deserialize for BankConnectionsResourceAccountNumberDetailsStatus {
279    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
280        crate::Place::new(out)
281    }
282}
283
284impl miniserde::de::Visitor for crate::Place<BankConnectionsResourceAccountNumberDetailsStatus> {
285    fn string(&mut self, s: &str) -> miniserde::Result<()> {
286        use std::str::FromStr;
287        self.out = Some(
288            BankConnectionsResourceAccountNumberDetailsStatus::from_str(s).expect("infallible"),
289        );
290        Ok(())
291    }
292}
293
294stripe_types::impl_from_val_with_from_str!(BankConnectionsResourceAccountNumberDetailsStatus);
295#[cfg(feature = "deserialize")]
296impl<'de> serde::Deserialize<'de> for BankConnectionsResourceAccountNumberDetailsStatus {
297    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
298        use std::str::FromStr;
299        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
300        Ok(Self::from_str(&s).expect("infallible"))
301    }
302}
303/// The payment networks that the account number can be used for.
304#[derive(Clone, Eq, PartialEq)]
305#[non_exhaustive]
306pub enum BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
307    Ach,
308    /// An unrecognized value from Stripe. Should not be used as a request parameter.
309    Unknown(String),
310}
311impl BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
312    pub fn as_str(&self) -> &str {
313        use BankConnectionsResourceAccountNumberDetailsSupportedNetworks::*;
314        match self {
315            Ach => "ach",
316            Unknown(v) => v,
317        }
318    }
319}
320
321impl std::str::FromStr for BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
322    type Err = std::convert::Infallible;
323    fn from_str(s: &str) -> Result<Self, Self::Err> {
324        use BankConnectionsResourceAccountNumberDetailsSupportedNetworks::*;
325        match s {
326            "ach" => Ok(Ach),
327            v => {
328                tracing::warn!(
329                    "Unknown value '{}' for enum '{}'",
330                    v,
331                    "BankConnectionsResourceAccountNumberDetailsSupportedNetworks"
332                );
333                Ok(Unknown(v.to_owned()))
334            }
335        }
336    }
337}
338impl std::fmt::Display for BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
339    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
340        f.write_str(self.as_str())
341    }
342}
343
344impl std::fmt::Debug for BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
345    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
346        f.write_str(self.as_str())
347    }
348}
349#[cfg(feature = "serialize")]
350impl serde::Serialize for BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
351    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
352    where
353        S: serde::Serializer,
354    {
355        serializer.serialize_str(self.as_str())
356    }
357}
358impl miniserde::Deserialize for BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
359    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
360        crate::Place::new(out)
361    }
362}
363
364impl miniserde::de::Visitor
365    for crate::Place<BankConnectionsResourceAccountNumberDetailsSupportedNetworks>
366{
367    fn string(&mut self, s: &str) -> miniserde::Result<()> {
368        use std::str::FromStr;
369        self.out = Some(
370            BankConnectionsResourceAccountNumberDetailsSupportedNetworks::from_str(s)
371                .expect("infallible"),
372        );
373        Ok(())
374    }
375}
376
377stripe_types::impl_from_val_with_from_str!(
378    BankConnectionsResourceAccountNumberDetailsSupportedNetworks
379);
380#[cfg(feature = "deserialize")]
381impl<'de> serde::Deserialize<'de> for BankConnectionsResourceAccountNumberDetailsSupportedNetworks {
382    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
383        use std::str::FromStr;
384        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
385        Ok(Self::from_str(&s).expect("infallible"))
386    }
387}
stripe_misc/bank_connections_resource_account_number_details.rs

stripe_misc/
bank_connections_resource_account_number_details.rs
