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

stripe_shared/
issuing_network_token_wallet_provider.rs
