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

stripe_shared/
three_d_secure_details.rs
