stripe_shared/
issuing_network_token_wallet_provider.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct IssuingNetworkTokenWalletProvider {
5    /// The wallet provider-given account ID of the digital wallet the token belongs to.
6    pub account_id: Option<String>,
7    /// An evaluation on the trustworthiness of the wallet account between 1 and 5.
8    /// A higher score indicates more trustworthy.
9    pub account_trust_score: Option<i64>,
10    /// The method used for tokenizing a card.
11    pub card_number_source: Option<IssuingNetworkTokenWalletProviderCardNumberSource>,
12    pub cardholder_address: Option<stripe_shared::IssuingNetworkTokenAddress>,
13    /// The name of the cardholder tokenizing the card.
14    pub cardholder_name: Option<String>,
15    /// An evaluation on the trustworthiness of the device. A higher score indicates more trustworthy.
16    pub device_trust_score: Option<i64>,
17    /// The hashed email address of the cardholder's account with the wallet provider.
18    pub hashed_account_email_address: Option<String>,
19    /// The reasons for suggested tokenization given by the card network.
20    pub reason_codes: Option<Vec<IssuingNetworkTokenWalletProviderReasonCodes>>,
21    /// The recommendation on responding to the tokenization request.
22    pub suggested_decision: Option<IssuingNetworkTokenWalletProviderSuggestedDecision>,
23    /// The version of the standard for mapping reason codes followed by the wallet provider.
24    pub suggested_decision_version: Option<String>,
25}
26#[doc(hidden)]
27pub struct IssuingNetworkTokenWalletProviderBuilder {
28    account_id: Option<Option<String>>,
29    account_trust_score: Option<Option<i64>>,
30    card_number_source: Option<Option<IssuingNetworkTokenWalletProviderCardNumberSource>>,
31    cardholder_address: Option<Option<stripe_shared::IssuingNetworkTokenAddress>>,
32    cardholder_name: Option<Option<String>>,
33    device_trust_score: Option<Option<i64>>,
34    hashed_account_email_address: Option<Option<String>>,
35    reason_codes: Option<Option<Vec<IssuingNetworkTokenWalletProviderReasonCodes>>>,
36    suggested_decision: Option<Option<IssuingNetworkTokenWalletProviderSuggestedDecision>>,
37    suggested_decision_version: Option<Option<String>>,
38}
39
40#[allow(
41    unused_variables,
42    irrefutable_let_patterns,
43    clippy::let_unit_value,
44    clippy::match_single_binding,
45    clippy::single_match
46)]
47const _: () = {
48    use miniserde::de::{Map, Visitor};
49    use miniserde::json::Value;
50    use miniserde::{make_place, Deserialize, Result};
51    use stripe_types::miniserde_helpers::FromValueOpt;
52    use stripe_types::{MapBuilder, ObjectDeser};
53
54    make_place!(Place);
55
56    impl Deserialize for IssuingNetworkTokenWalletProvider {
57        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
58            Place::new(out)
59        }
60    }
61
62    struct Builder<'a> {
63        out: &'a mut Option<IssuingNetworkTokenWalletProvider>,
64        builder: IssuingNetworkTokenWalletProviderBuilder,
65    }
66
67    impl Visitor for Place<IssuingNetworkTokenWalletProvider> {
68        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
69            Ok(Box::new(Builder {
70                out: &mut self.out,
71                builder: IssuingNetworkTokenWalletProviderBuilder::deser_default(),
72            }))
73        }
74    }
75
76    impl MapBuilder for IssuingNetworkTokenWalletProviderBuilder {
77        type Out = IssuingNetworkTokenWalletProvider;
78        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
79            Ok(match k {
80                "account_id" => Deserialize::begin(&mut self.account_id),
81                "account_trust_score" => Deserialize::begin(&mut self.account_trust_score),
82                "card_number_source" => Deserialize::begin(&mut self.card_number_source),
83                "cardholder_address" => Deserialize::begin(&mut self.cardholder_address),
84                "cardholder_name" => Deserialize::begin(&mut self.cardholder_name),
85                "device_trust_score" => Deserialize::begin(&mut self.device_trust_score),
86                "hashed_account_email_address" => {
87                    Deserialize::begin(&mut self.hashed_account_email_address)
88                }
89                "reason_codes" => Deserialize::begin(&mut self.reason_codes),
90                "suggested_decision" => Deserialize::begin(&mut self.suggested_decision),
91                "suggested_decision_version" => {
92                    Deserialize::begin(&mut self.suggested_decision_version)
93                }
94
95                _ => <dyn Visitor>::ignore(),
96            })
97        }
98
99        fn deser_default() -> Self {
100            Self {
101                account_id: Deserialize::default(),
102                account_trust_score: Deserialize::default(),
103                card_number_source: Deserialize::default(),
104                cardholder_address: Deserialize::default(),
105                cardholder_name: Deserialize::default(),
106                device_trust_score: Deserialize::default(),
107                hashed_account_email_address: Deserialize::default(),
108                reason_codes: Deserialize::default(),
109                suggested_decision: Deserialize::default(),
110                suggested_decision_version: Deserialize::default(),
111            }
112        }
113
114        fn take_out(&mut self) -> Option<Self::Out> {
115            let (
116                Some(account_id),
117                Some(account_trust_score),
118                Some(card_number_source),
119                Some(cardholder_address),
120                Some(cardholder_name),
121                Some(device_trust_score),
122                Some(hashed_account_email_address),
123                Some(reason_codes),
124                Some(suggested_decision),
125                Some(suggested_decision_version),
126            ) = (
127                self.account_id.take(),
128                self.account_trust_score,
129                self.card_number_source,
130                self.cardholder_address.take(),
131                self.cardholder_name.take(),
132                self.device_trust_score,
133                self.hashed_account_email_address.take(),
134                self.reason_codes.take(),
135                self.suggested_decision,
136                self.suggested_decision_version.take(),
137            )
138            else {
139                return None;
140            };
141            Some(Self::Out {
142                account_id,
143                account_trust_score,
144                card_number_source,
145                cardholder_address,
146                cardholder_name,
147                device_trust_score,
148                hashed_account_email_address,
149                reason_codes,
150                suggested_decision,
151                suggested_decision_version,
152            })
153        }
154    }
155
156    impl Map for Builder<'_> {
157        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
158            self.builder.key(k)
159        }
160
161        fn finish(&mut self) -> Result<()> {
162            *self.out = self.builder.take_out();
163            Ok(())
164        }
165    }
166
167    impl ObjectDeser for IssuingNetworkTokenWalletProvider {
168        type Builder = IssuingNetworkTokenWalletProviderBuilder;
169    }
170
171    impl FromValueOpt for IssuingNetworkTokenWalletProvider {
172        fn from_value(v: Value) -> Option<Self> {
173            let Value::Object(obj) = v else {
174                return None;
175            };
176            let mut b = IssuingNetworkTokenWalletProviderBuilder::deser_default();
177            for (k, v) in obj {
178                match k.as_str() {
179                    "account_id" => b.account_id = FromValueOpt::from_value(v),
180                    "account_trust_score" => b.account_trust_score = FromValueOpt::from_value(v),
181                    "card_number_source" => b.card_number_source = FromValueOpt::from_value(v),
182                    "cardholder_address" => b.cardholder_address = FromValueOpt::from_value(v),
183                    "cardholder_name" => b.cardholder_name = FromValueOpt::from_value(v),
184                    "device_trust_score" => b.device_trust_score = FromValueOpt::from_value(v),
185                    "hashed_account_email_address" => {
186                        b.hashed_account_email_address = FromValueOpt::from_value(v)
187                    }
188                    "reason_codes" => b.reason_codes = FromValueOpt::from_value(v),
189                    "suggested_decision" => b.suggested_decision = FromValueOpt::from_value(v),
190                    "suggested_decision_version" => {
191                        b.suggested_decision_version = FromValueOpt::from_value(v)
192                    }
193
194                    _ => {}
195                }
196            }
197            b.take_out()
198        }
199    }
200};
201/// The method used for tokenizing a card.
202#[derive(Copy, Clone, Eq, PartialEq)]
203pub enum IssuingNetworkTokenWalletProviderCardNumberSource {
204    App,
205    Manual,
206    OnFile,
207    Other,
208}
209impl IssuingNetworkTokenWalletProviderCardNumberSource {
210    pub fn as_str(self) -> &'static str {
211        use IssuingNetworkTokenWalletProviderCardNumberSource::*;
212        match self {
213            App => "app",
214            Manual => "manual",
215            OnFile => "on_file",
216            Other => "other",
217        }
218    }
219}
220
221impl std::str::FromStr for IssuingNetworkTokenWalletProviderCardNumberSource {
222    type Err = stripe_types::StripeParseError;
223    fn from_str(s: &str) -> Result<Self, Self::Err> {
224        use IssuingNetworkTokenWalletProviderCardNumberSource::*;
225        match s {
226            "app" => Ok(App),
227            "manual" => Ok(Manual),
228            "on_file" => Ok(OnFile),
229            "other" => Ok(Other),
230            _ => Err(stripe_types::StripeParseError),
231        }
232    }
233}
234impl std::fmt::Display for IssuingNetworkTokenWalletProviderCardNumberSource {
235    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
236        f.write_str(self.as_str())
237    }
238}
239
240impl std::fmt::Debug for IssuingNetworkTokenWalletProviderCardNumberSource {
241    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
242        f.write_str(self.as_str())
243    }
244}
245#[cfg(feature = "serialize")]
246impl serde::Serialize for IssuingNetworkTokenWalletProviderCardNumberSource {
247    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
248    where
249        S: serde::Serializer,
250    {
251        serializer.serialize_str(self.as_str())
252    }
253}
254impl miniserde::Deserialize for IssuingNetworkTokenWalletProviderCardNumberSource {
255    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
256        crate::Place::new(out)
257    }
258}
259
260impl miniserde::de::Visitor for crate::Place<IssuingNetworkTokenWalletProviderCardNumberSource> {
261    fn string(&mut self, s: &str) -> miniserde::Result<()> {
262        use std::str::FromStr;
263        self.out = Some(
264            IssuingNetworkTokenWalletProviderCardNumberSource::from_str(s)
265                .map_err(|_| miniserde::Error)?,
266        );
267        Ok(())
268    }
269}
270
271stripe_types::impl_from_val_with_from_str!(IssuingNetworkTokenWalletProviderCardNumberSource);
272#[cfg(feature = "deserialize")]
273impl<'de> serde::Deserialize<'de> for IssuingNetworkTokenWalletProviderCardNumberSource {
274    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
275        use std::str::FromStr;
276        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
277        Self::from_str(&s).map_err(|_| {
278            serde::de::Error::custom(
279                "Unknown value for IssuingNetworkTokenWalletProviderCardNumberSource",
280            )
281        })
282    }
283}
284/// The reasons for suggested tokenization given by the card network.
285#[derive(Clone, Eq, PartialEq)]
286#[non_exhaustive]
287pub enum IssuingNetworkTokenWalletProviderReasonCodes {
288    AccountCardTooNew,
289    AccountRecentlyChanged,
290    AccountTooNew,
291    AccountTooNewSinceLaunch,
292    AdditionalDevice,
293    DataExpired,
294    DeferIdVDecision,
295    DeviceRecentlyLost,
296    GoodActivityHistory,
297    HasSuspendedTokens,
298    HighRisk,
299    InactiveAccount,
300    LongAccountTenure,
301    LowAccountScore,
302    LowDeviceScore,
303    LowPhoneNumberScore,
304    NetworkServiceError,
305    OutsideHomeTerritory,
306    ProvisioningCardholderMismatch,
307    ProvisioningDeviceAndCardholderMismatch,
308    ProvisioningDeviceMismatch,
309    SameDeviceNoPriorAuthentication,
310    SameDeviceSuccessfulPriorAuthentication,
311    SoftwareUpdate,
312    SuspiciousActivity,
313    TooManyDifferentCardholders,
314    TooManyRecentAttempts,
315    TooManyRecentTokens,
316    /// An unrecognized value from Stripe. Should not be used as a request parameter.
317    Unknown(String),
318}
319impl IssuingNetworkTokenWalletProviderReasonCodes {
320    pub fn as_str(&self) -> &str {
321        use IssuingNetworkTokenWalletProviderReasonCodes::*;
322        match self {
323            AccountCardTooNew => "account_card_too_new",
324            AccountRecentlyChanged => "account_recently_changed",
325            AccountTooNew => "account_too_new",
326            AccountTooNewSinceLaunch => "account_too_new_since_launch",
327            AdditionalDevice => "additional_device",
328            DataExpired => "data_expired",
329            DeferIdVDecision => "defer_id_v_decision",
330            DeviceRecentlyLost => "device_recently_lost",
331            GoodActivityHistory => "good_activity_history",
332            HasSuspendedTokens => "has_suspended_tokens",
333            HighRisk => "high_risk",
334            InactiveAccount => "inactive_account",
335            LongAccountTenure => "long_account_tenure",
336            LowAccountScore => "low_account_score",
337            LowDeviceScore => "low_device_score",
338            LowPhoneNumberScore => "low_phone_number_score",
339            NetworkServiceError => "network_service_error",
340            OutsideHomeTerritory => "outside_home_territory",
341            ProvisioningCardholderMismatch => "provisioning_cardholder_mismatch",
342            ProvisioningDeviceAndCardholderMismatch => {
343                "provisioning_device_and_cardholder_mismatch"
344            }
345            ProvisioningDeviceMismatch => "provisioning_device_mismatch",
346            SameDeviceNoPriorAuthentication => "same_device_no_prior_authentication",
347            SameDeviceSuccessfulPriorAuthentication => {
348                "same_device_successful_prior_authentication"
349            }
350            SoftwareUpdate => "software_update",
351            SuspiciousActivity => "suspicious_activity",
352            TooManyDifferentCardholders => "too_many_different_cardholders",
353            TooManyRecentAttempts => "too_many_recent_attempts",
354            TooManyRecentTokens => "too_many_recent_tokens",
355            Unknown(v) => v,
356        }
357    }
358}
359
360impl std::str::FromStr for IssuingNetworkTokenWalletProviderReasonCodes {
361    type Err = std::convert::Infallible;
362    fn from_str(s: &str) -> Result<Self, Self::Err> {
363        use IssuingNetworkTokenWalletProviderReasonCodes::*;
364        match s {
365            "account_card_too_new" => Ok(AccountCardTooNew),
366            "account_recently_changed" => Ok(AccountRecentlyChanged),
367            "account_too_new" => Ok(AccountTooNew),
368            "account_too_new_since_launch" => Ok(AccountTooNewSinceLaunch),
369            "additional_device" => Ok(AdditionalDevice),
370            "data_expired" => Ok(DataExpired),
371            "defer_id_v_decision" => Ok(DeferIdVDecision),
372            "device_recently_lost" => Ok(DeviceRecentlyLost),
373            "good_activity_history" => Ok(GoodActivityHistory),
374            "has_suspended_tokens" => Ok(HasSuspendedTokens),
375            "high_risk" => Ok(HighRisk),
376            "inactive_account" => Ok(InactiveAccount),
377            "long_account_tenure" => Ok(LongAccountTenure),
378            "low_account_score" => Ok(LowAccountScore),
379            "low_device_score" => Ok(LowDeviceScore),
380            "low_phone_number_score" => Ok(LowPhoneNumberScore),
381            "network_service_error" => Ok(NetworkServiceError),
382            "outside_home_territory" => Ok(OutsideHomeTerritory),
383            "provisioning_cardholder_mismatch" => Ok(ProvisioningCardholderMismatch),
384            "provisioning_device_and_cardholder_mismatch" => {
385                Ok(ProvisioningDeviceAndCardholderMismatch)
386            }
387            "provisioning_device_mismatch" => Ok(ProvisioningDeviceMismatch),
388            "same_device_no_prior_authentication" => Ok(SameDeviceNoPriorAuthentication),
389            "same_device_successful_prior_authentication" => {
390                Ok(SameDeviceSuccessfulPriorAuthentication)
391            }
392            "software_update" => Ok(SoftwareUpdate),
393            "suspicious_activity" => Ok(SuspiciousActivity),
394            "too_many_different_cardholders" => Ok(TooManyDifferentCardholders),
395            "too_many_recent_attempts" => Ok(TooManyRecentAttempts),
396            "too_many_recent_tokens" => Ok(TooManyRecentTokens),
397            v => Ok(Unknown(v.to_owned())),
398        }
399    }
400}
401impl std::fmt::Display for IssuingNetworkTokenWalletProviderReasonCodes {
402    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
403        f.write_str(self.as_str())
404    }
405}
406
407impl std::fmt::Debug for IssuingNetworkTokenWalletProviderReasonCodes {
408    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
409        f.write_str(self.as_str())
410    }
411}
412#[cfg(feature = "serialize")]
413impl serde::Serialize for IssuingNetworkTokenWalletProviderReasonCodes {
414    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
415    where
416        S: serde::Serializer,
417    {
418        serializer.serialize_str(self.as_str())
419    }
420}
421impl miniserde::Deserialize for IssuingNetworkTokenWalletProviderReasonCodes {
422    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
423        crate::Place::new(out)
424    }
425}
426
427impl miniserde::de::Visitor for crate::Place<IssuingNetworkTokenWalletProviderReasonCodes> {
428    fn string(&mut self, s: &str) -> miniserde::Result<()> {
429        use std::str::FromStr;
430        self.out = Some(IssuingNetworkTokenWalletProviderReasonCodes::from_str(s).unwrap());
431        Ok(())
432    }
433}
434
435stripe_types::impl_from_val_with_from_str!(IssuingNetworkTokenWalletProviderReasonCodes);
436#[cfg(feature = "deserialize")]
437impl<'de> serde::Deserialize<'de> for IssuingNetworkTokenWalletProviderReasonCodes {
438    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
439        use std::str::FromStr;
440        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
441        Ok(Self::from_str(&s).unwrap())
442    }
443}
444/// The recommendation on responding to the tokenization request.
445#[derive(Copy, Clone, Eq, PartialEq)]
446pub enum IssuingNetworkTokenWalletProviderSuggestedDecision {
447    Approve,
448    Decline,
449    RequireAuth,
450}
451impl IssuingNetworkTokenWalletProviderSuggestedDecision {
452    pub fn as_str(self) -> &'static str {
453        use IssuingNetworkTokenWalletProviderSuggestedDecision::*;
454        match self {
455            Approve => "approve",
456            Decline => "decline",
457            RequireAuth => "require_auth",
458        }
459    }
460}
461
462impl std::str::FromStr for IssuingNetworkTokenWalletProviderSuggestedDecision {
463    type Err = stripe_types::StripeParseError;
464    fn from_str(s: &str) -> Result<Self, Self::Err> {
465        use IssuingNetworkTokenWalletProviderSuggestedDecision::*;
466        match s {
467            "approve" => Ok(Approve),
468            "decline" => Ok(Decline),
469            "require_auth" => Ok(RequireAuth),
470            _ => Err(stripe_types::StripeParseError),
471        }
472    }
473}
474impl std::fmt::Display for IssuingNetworkTokenWalletProviderSuggestedDecision {
475    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
476        f.write_str(self.as_str())
477    }
478}
479
480impl std::fmt::Debug for IssuingNetworkTokenWalletProviderSuggestedDecision {
481    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
482        f.write_str(self.as_str())
483    }
484}
485#[cfg(feature = "serialize")]
486impl serde::Serialize for IssuingNetworkTokenWalletProviderSuggestedDecision {
487    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
488    where
489        S: serde::Serializer,
490    {
491        serializer.serialize_str(self.as_str())
492    }
493}
494impl miniserde::Deserialize for IssuingNetworkTokenWalletProviderSuggestedDecision {
495    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
496        crate::Place::new(out)
497    }
498}
499
500impl miniserde::de::Visitor for crate::Place<IssuingNetworkTokenWalletProviderSuggestedDecision> {
501    fn string(&mut self, s: &str) -> miniserde::Result<()> {
502        use std::str::FromStr;
503        self.out = Some(
504            IssuingNetworkTokenWalletProviderSuggestedDecision::from_str(s)
505                .map_err(|_| miniserde::Error)?,
506        );
507        Ok(())
508    }
509}
510
511stripe_types::impl_from_val_with_from_str!(IssuingNetworkTokenWalletProviderSuggestedDecision);
512#[cfg(feature = "deserialize")]
513impl<'de> serde::Deserialize<'de> for IssuingNetworkTokenWalletProviderSuggestedDecision {
514    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
515        use std::str::FromStr;
516        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
517        Self::from_str(&s).map_err(|_| {
518            serde::de::Error::custom(
519                "Unknown value for IssuingNetworkTokenWalletProviderSuggestedDecision",
520            )
521        })
522    }
523}
stripe_shared/issuing_network_token_wallet_provider.rs

stripe_shared/
issuing_network_token_wallet_provider.rs
