stripe_shared/
three_d_secure_details.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct ThreeDSecureDetails {
5    /// For authenticated transactions: how the customer was authenticated by
6    /// the issuing bank.
7    pub authentication_flow: Option<ThreeDSecureDetailsAuthenticationFlow>,
8    /// The Electronic Commerce Indicator (ECI). A protocol-level field
9    /// indicating what degree of authentication was performed.
10    pub electronic_commerce_indicator: Option<ThreeDSecureDetailsElectronicCommerceIndicator>,
11    /// Indicates the outcome of 3D Secure authentication.
12    pub result: Option<ThreeDSecureDetailsResult>,
13    /// Additional information about why 3D Secure succeeded or failed based
14    /// on the `result`.
15    pub result_reason: Option<ThreeDSecureDetailsResultReason>,
16    /// The 3D Secure 1 XID or 3D Secure 2 Directory Server Transaction ID
17    /// (dsTransId) for this payment.
18    pub transaction_id: Option<String>,
19    /// The version of 3D Secure that was used.
20    pub version: Option<ThreeDSecureDetailsVersion>,
21}
22#[doc(hidden)]
23pub struct ThreeDSecureDetailsBuilder {
24    authentication_flow: Option<Option<ThreeDSecureDetailsAuthenticationFlow>>,
25    electronic_commerce_indicator: Option<Option<ThreeDSecureDetailsElectronicCommerceIndicator>>,
26    result: Option<Option<ThreeDSecureDetailsResult>>,
27    result_reason: Option<Option<ThreeDSecureDetailsResultReason>>,
28    transaction_id: Option<Option<String>>,
29    version: Option<Option<ThreeDSecureDetailsVersion>>,
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 ThreeDSecureDetails {
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<ThreeDSecureDetails>,
56        builder: ThreeDSecureDetailsBuilder,
57    }
58
59    impl Visitor for Place<ThreeDSecureDetails> {
60        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
61            Ok(Box::new(Builder {
62                out: &mut self.out,
63                builder: ThreeDSecureDetailsBuilder::deser_default(),
64            }))
65        }
66    }
67
68    impl MapBuilder for ThreeDSecureDetailsBuilder {
69        type Out = ThreeDSecureDetails;
70        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
71            Ok(match k {
72                "authentication_flow" => Deserialize::begin(&mut self.authentication_flow),
73                "electronic_commerce_indicator" => {
74                    Deserialize::begin(&mut self.electronic_commerce_indicator)
75                }
76                "result" => Deserialize::begin(&mut self.result),
77                "result_reason" => Deserialize::begin(&mut self.result_reason),
78                "transaction_id" => Deserialize::begin(&mut self.transaction_id),
79                "version" => Deserialize::begin(&mut self.version),
80                _ => <dyn Visitor>::ignore(),
81            })
82        }
83
84        fn deser_default() -> Self {
85            Self {
86                authentication_flow: Deserialize::default(),
87                electronic_commerce_indicator: Deserialize::default(),
88                result: Deserialize::default(),
89                result_reason: Deserialize::default(),
90                transaction_id: Deserialize::default(),
91                version: Deserialize::default(),
92            }
93        }
94
95        fn take_out(&mut self) -> Option<Self::Out> {
96            let (
97                Some(authentication_flow),
98                Some(electronic_commerce_indicator),
99                Some(result),
100                Some(result_reason),
101                Some(transaction_id),
102                Some(version),
103            ) = (
104                self.authentication_flow,
105                self.electronic_commerce_indicator,
106                self.result,
107                self.result_reason,
108                self.transaction_id.take(),
109                self.version,
110            )
111            else {
112                return None;
113            };
114            Some(Self::Out {
115                authentication_flow,
116                electronic_commerce_indicator,
117                result,
118                result_reason,
119                transaction_id,
120                version,
121            })
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 ThreeDSecureDetails {
137        type Builder = ThreeDSecureDetailsBuilder;
138    }
139
140    impl FromValueOpt for ThreeDSecureDetails {
141        fn from_value(v: Value) -> Option<Self> {
142            let Value::Object(obj) = v else {
143                return None;
144            };
145            let mut b = ThreeDSecureDetailsBuilder::deser_default();
146            for (k, v) in obj {
147                match k.as_str() {
148                    "authentication_flow" => b.authentication_flow = FromValueOpt::from_value(v),
149                    "electronic_commerce_indicator" => {
150                        b.electronic_commerce_indicator = FromValueOpt::from_value(v)
151                    }
152                    "result" => b.result = FromValueOpt::from_value(v),
153                    "result_reason" => b.result_reason = FromValueOpt::from_value(v),
154                    "transaction_id" => b.transaction_id = FromValueOpt::from_value(v),
155                    "version" => b.version = FromValueOpt::from_value(v),
156                    _ => {}
157                }
158            }
159            b.take_out()
160        }
161    }
162};
163/// For authenticated transactions: how the customer was authenticated by
164/// the issuing bank.
165#[derive(Copy, Clone, Eq, PartialEq)]
166pub enum ThreeDSecureDetailsAuthenticationFlow {
167    Challenge,
168    Frictionless,
169}
170impl ThreeDSecureDetailsAuthenticationFlow {
171    pub fn as_str(self) -> &'static str {
172        use ThreeDSecureDetailsAuthenticationFlow::*;
173        match self {
174            Challenge => "challenge",
175            Frictionless => "frictionless",
176        }
177    }
178}
179
180impl std::str::FromStr for ThreeDSecureDetailsAuthenticationFlow {
181    type Err = stripe_types::StripeParseError;
182    fn from_str(s: &str) -> Result<Self, Self::Err> {
183        use ThreeDSecureDetailsAuthenticationFlow::*;
184        match s {
185            "challenge" => Ok(Challenge),
186            "frictionless" => Ok(Frictionless),
187            _ => Err(stripe_types::StripeParseError),
188        }
189    }
190}
191impl std::fmt::Display for ThreeDSecureDetailsAuthenticationFlow {
192    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
193        f.write_str(self.as_str())
194    }
195}
196
197impl std::fmt::Debug for ThreeDSecureDetailsAuthenticationFlow {
198    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
199        f.write_str(self.as_str())
200    }
201}
202#[cfg(feature = "serialize")]
203impl serde::Serialize for ThreeDSecureDetailsAuthenticationFlow {
204    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
205    where
206        S: serde::Serializer,
207    {
208        serializer.serialize_str(self.as_str())
209    }
210}
211impl miniserde::Deserialize for ThreeDSecureDetailsAuthenticationFlow {
212    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
213        crate::Place::new(out)
214    }
215}
216
217impl miniserde::de::Visitor for crate::Place<ThreeDSecureDetailsAuthenticationFlow> {
218    fn string(&mut self, s: &str) -> miniserde::Result<()> {
219        use std::str::FromStr;
220        self.out =
221            Some(ThreeDSecureDetailsAuthenticationFlow::from_str(s).map_err(|_| miniserde::Error)?);
222        Ok(())
223    }
224}
225
226stripe_types::impl_from_val_with_from_str!(ThreeDSecureDetailsAuthenticationFlow);
227#[cfg(feature = "deserialize")]
228impl<'de> serde::Deserialize<'de> for ThreeDSecureDetailsAuthenticationFlow {
229    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
230        use std::str::FromStr;
231        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
232        Self::from_str(&s).map_err(|_| {
233            serde::de::Error::custom("Unknown value for ThreeDSecureDetailsAuthenticationFlow")
234        })
235    }
236}
237/// The Electronic Commerce Indicator (ECI). A protocol-level field
238/// indicating what degree of authentication was performed.
239#[derive(Copy, Clone, Eq, PartialEq)]
240pub enum ThreeDSecureDetailsElectronicCommerceIndicator {
241    V01,
242    V02,
243    V05,
244    V06,
245    V07,
246}
247impl ThreeDSecureDetailsElectronicCommerceIndicator {
248    pub fn as_str(self) -> &'static str {
249        use ThreeDSecureDetailsElectronicCommerceIndicator::*;
250        match self {
251            V01 => "01",
252            V02 => "02",
253            V05 => "05",
254            V06 => "06",
255            V07 => "07",
256        }
257    }
258}
259
260impl std::str::FromStr for ThreeDSecureDetailsElectronicCommerceIndicator {
261    type Err = stripe_types::StripeParseError;
262    fn from_str(s: &str) -> Result<Self, Self::Err> {
263        use ThreeDSecureDetailsElectronicCommerceIndicator::*;
264        match s {
265            "01" => Ok(V01),
266            "02" => Ok(V02),
267            "05" => Ok(V05),
268            "06" => Ok(V06),
269            "07" => Ok(V07),
270            _ => Err(stripe_types::StripeParseError),
271        }
272    }
273}
274impl std::fmt::Display for ThreeDSecureDetailsElectronicCommerceIndicator {
275    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
276        f.write_str(self.as_str())
277    }
278}
279
280impl std::fmt::Debug for ThreeDSecureDetailsElectronicCommerceIndicator {
281    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
282        f.write_str(self.as_str())
283    }
284}
285#[cfg(feature = "serialize")]
286impl serde::Serialize for ThreeDSecureDetailsElectronicCommerceIndicator {
287    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
288    where
289        S: serde::Serializer,
290    {
291        serializer.serialize_str(self.as_str())
292    }
293}
294impl miniserde::Deserialize for ThreeDSecureDetailsElectronicCommerceIndicator {
295    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
296        crate::Place::new(out)
297    }
298}
299
300impl miniserde::de::Visitor for crate::Place<ThreeDSecureDetailsElectronicCommerceIndicator> {
301    fn string(&mut self, s: &str) -> miniserde::Result<()> {
302        use std::str::FromStr;
303        self.out = Some(
304            ThreeDSecureDetailsElectronicCommerceIndicator::from_str(s)
305                .map_err(|_| miniserde::Error)?,
306        );
307        Ok(())
308    }
309}
310
311stripe_types::impl_from_val_with_from_str!(ThreeDSecureDetailsElectronicCommerceIndicator);
312#[cfg(feature = "deserialize")]
313impl<'de> serde::Deserialize<'de> for ThreeDSecureDetailsElectronicCommerceIndicator {
314    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
315        use std::str::FromStr;
316        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
317        Self::from_str(&s).map_err(|_| {
318            serde::de::Error::custom(
319                "Unknown value for ThreeDSecureDetailsElectronicCommerceIndicator",
320            )
321        })
322    }
323}
324/// Indicates the outcome of 3D Secure authentication.
325#[derive(Copy, Clone, Eq, PartialEq)]
326pub enum ThreeDSecureDetailsResult {
327    AttemptAcknowledged,
328    Authenticated,
329    Exempted,
330    Failed,
331    NotSupported,
332    ProcessingError,
333}
334impl ThreeDSecureDetailsResult {
335    pub fn as_str(self) -> &'static str {
336        use ThreeDSecureDetailsResult::*;
337        match self {
338            AttemptAcknowledged => "attempt_acknowledged",
339            Authenticated => "authenticated",
340            Exempted => "exempted",
341            Failed => "failed",
342            NotSupported => "not_supported",
343            ProcessingError => "processing_error",
344        }
345    }
346}
347
348impl std::str::FromStr for ThreeDSecureDetailsResult {
349    type Err = stripe_types::StripeParseError;
350    fn from_str(s: &str) -> Result<Self, Self::Err> {
351        use ThreeDSecureDetailsResult::*;
352        match s {
353            "attempt_acknowledged" => Ok(AttemptAcknowledged),
354            "authenticated" => Ok(Authenticated),
355            "exempted" => Ok(Exempted),
356            "failed" => Ok(Failed),
357            "not_supported" => Ok(NotSupported),
358            "processing_error" => Ok(ProcessingError),
359            _ => Err(stripe_types::StripeParseError),
360        }
361    }
362}
363impl std::fmt::Display for ThreeDSecureDetailsResult {
364    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
365        f.write_str(self.as_str())
366    }
367}
368
369impl std::fmt::Debug for ThreeDSecureDetailsResult {
370    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
371        f.write_str(self.as_str())
372    }
373}
374#[cfg(feature = "serialize")]
375impl serde::Serialize for ThreeDSecureDetailsResult {
376    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
377    where
378        S: serde::Serializer,
379    {
380        serializer.serialize_str(self.as_str())
381    }
382}
383impl miniserde::Deserialize for ThreeDSecureDetailsResult {
384    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
385        crate::Place::new(out)
386    }
387}
388
389impl miniserde::de::Visitor for crate::Place<ThreeDSecureDetailsResult> {
390    fn string(&mut self, s: &str) -> miniserde::Result<()> {
391        use std::str::FromStr;
392        self.out = Some(ThreeDSecureDetailsResult::from_str(s).map_err(|_| miniserde::Error)?);
393        Ok(())
394    }
395}
396
397stripe_types::impl_from_val_with_from_str!(ThreeDSecureDetailsResult);
398#[cfg(feature = "deserialize")]
399impl<'de> serde::Deserialize<'de> for ThreeDSecureDetailsResult {
400    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
401        use std::str::FromStr;
402        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
403        Self::from_str(&s)
404            .map_err(|_| serde::de::Error::custom("Unknown value for ThreeDSecureDetailsResult"))
405    }
406}
407/// Additional information about why 3D Secure succeeded or failed based
408/// on the `result`.
409#[derive(Copy, Clone, Eq, PartialEq)]
410pub enum ThreeDSecureDetailsResultReason {
411    Abandoned,
412    Bypassed,
413    Canceled,
414    CardNotEnrolled,
415    NetworkNotSupported,
416    ProtocolError,
417    Rejected,
418}
419impl ThreeDSecureDetailsResultReason {
420    pub fn as_str(self) -> &'static str {
421        use ThreeDSecureDetailsResultReason::*;
422        match self {
423            Abandoned => "abandoned",
424            Bypassed => "bypassed",
425            Canceled => "canceled",
426            CardNotEnrolled => "card_not_enrolled",
427            NetworkNotSupported => "network_not_supported",
428            ProtocolError => "protocol_error",
429            Rejected => "rejected",
430        }
431    }
432}
433
434impl std::str::FromStr for ThreeDSecureDetailsResultReason {
435    type Err = stripe_types::StripeParseError;
436    fn from_str(s: &str) -> Result<Self, Self::Err> {
437        use ThreeDSecureDetailsResultReason::*;
438        match s {
439            "abandoned" => Ok(Abandoned),
440            "bypassed" => Ok(Bypassed),
441            "canceled" => Ok(Canceled),
442            "card_not_enrolled" => Ok(CardNotEnrolled),
443            "network_not_supported" => Ok(NetworkNotSupported),
444            "protocol_error" => Ok(ProtocolError),
445            "rejected" => Ok(Rejected),
446            _ => Err(stripe_types::StripeParseError),
447        }
448    }
449}
450impl std::fmt::Display for ThreeDSecureDetailsResultReason {
451    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
452        f.write_str(self.as_str())
453    }
454}
455
456impl std::fmt::Debug for ThreeDSecureDetailsResultReason {
457    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
458        f.write_str(self.as_str())
459    }
460}
461#[cfg(feature = "serialize")]
462impl serde::Serialize for ThreeDSecureDetailsResultReason {
463    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
464    where
465        S: serde::Serializer,
466    {
467        serializer.serialize_str(self.as_str())
468    }
469}
470impl miniserde::Deserialize for ThreeDSecureDetailsResultReason {
471    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
472        crate::Place::new(out)
473    }
474}
475
476impl miniserde::de::Visitor for crate::Place<ThreeDSecureDetailsResultReason> {
477    fn string(&mut self, s: &str) -> miniserde::Result<()> {
478        use std::str::FromStr;
479        self.out =
480            Some(ThreeDSecureDetailsResultReason::from_str(s).map_err(|_| miniserde::Error)?);
481        Ok(())
482    }
483}
484
485stripe_types::impl_from_val_with_from_str!(ThreeDSecureDetailsResultReason);
486#[cfg(feature = "deserialize")]
487impl<'de> serde::Deserialize<'de> for ThreeDSecureDetailsResultReason {
488    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
489        use std::str::FromStr;
490        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
491        Self::from_str(&s).map_err(|_| {
492            serde::de::Error::custom("Unknown value for ThreeDSecureDetailsResultReason")
493        })
494    }
495}
496/// The version of 3D Secure that was used.
497#[derive(Copy, Clone, Eq, PartialEq)]
498pub enum ThreeDSecureDetailsVersion {
499    V1_0_2,
500    V2_1_0,
501    V2_2_0,
502}
503impl ThreeDSecureDetailsVersion {
504    pub fn as_str(self) -> &'static str {
505        use ThreeDSecureDetailsVersion::*;
506        match self {
507            V1_0_2 => "1.0.2",
508            V2_1_0 => "2.1.0",
509            V2_2_0 => "2.2.0",
510        }
511    }
512}
513
514impl std::str::FromStr for ThreeDSecureDetailsVersion {
515    type Err = stripe_types::StripeParseError;
516    fn from_str(s: &str) -> Result<Self, Self::Err> {
517        use ThreeDSecureDetailsVersion::*;
518        match s {
519            "1.0.2" => Ok(V1_0_2),
520            "2.1.0" => Ok(V2_1_0),
521            "2.2.0" => Ok(V2_2_0),
522            _ => Err(stripe_types::StripeParseError),
523        }
524    }
525}
526impl std::fmt::Display for ThreeDSecureDetailsVersion {
527    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
528        f.write_str(self.as_str())
529    }
530}
531
532impl std::fmt::Debug for ThreeDSecureDetailsVersion {
533    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
534        f.write_str(self.as_str())
535    }
536}
537#[cfg(feature = "serialize")]
538impl serde::Serialize for ThreeDSecureDetailsVersion {
539    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
540    where
541        S: serde::Serializer,
542    {
543        serializer.serialize_str(self.as_str())
544    }
545}
546impl miniserde::Deserialize for ThreeDSecureDetailsVersion {
547    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
548        crate::Place::new(out)
549    }
550}
551
552impl miniserde::de::Visitor for crate::Place<ThreeDSecureDetailsVersion> {
553    fn string(&mut self, s: &str) -> miniserde::Result<()> {
554        use std::str::FromStr;
555        self.out = Some(ThreeDSecureDetailsVersion::from_str(s).map_err(|_| miniserde::Error)?);
556        Ok(())
557    }
558}
559
560stripe_types::impl_from_val_with_from_str!(ThreeDSecureDetailsVersion);
561#[cfg(feature = "deserialize")]
562impl<'de> serde::Deserialize<'de> for ThreeDSecureDetailsVersion {
563    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
564        use std::str::FromStr;
565        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
566        Self::from_str(&s)
567            .map_err(|_| serde::de::Error::custom("Unknown value for ThreeDSecureDetailsVersion"))
568    }
569}
stripe_shared/three_d_secure_details.rs

stripe_shared/
three_d_secure_details.rs
