stripe_shared/
account_future_requirements.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct AccountFutureRequirements {
5    /// Fields that are due and can be resolved by providing the corresponding alternative fields instead.
6    /// Many alternatives can list the same `original_fields_due`, and any of these alternatives can serve as a pathway for attempting to resolve the fields again.
7    /// Re-providing `original_fields_due` also serves as a pathway for attempting to resolve the fields again.
8    pub alternatives: Option<Vec<stripe_shared::AccountRequirementsAlternative>>,
9    /// Date on which `future_requirements` becomes the main `requirements` hash and `future_requirements` becomes empty.
10    /// After the transition, `currently_due` requirements may immediately become `past_due`, but the account may also be given a grace period depending on its enablement state prior to transitioning.
11    pub current_deadline: Option<stripe_types::Timestamp>,
12    /// Fields that need to be resolved to keep the account enabled.
13    /// If not resolved by `future_requirements[current_deadline]`, these fields will transition to the main `requirements` hash.
14    pub currently_due: Option<Vec<String>>,
15    /// This is typed as an enum for consistency with `requirements.disabled_reason`.
16    pub disabled_reason: Option<AccountFutureRequirementsDisabledReason>,
17    /// Details about validation and verification failures for `due` requirements that must be resolved.
18    pub errors: Option<Vec<stripe_shared::AccountRequirementsError>>,
19    /// Fields you must collect when all thresholds are reached.
20    /// As they become required, they appear in `currently_due` as well.
21    pub eventually_due: Option<Vec<String>>,
22    /// Fields that haven't been resolved by `requirements.current_deadline`.
23    /// These fields need to be resolved to enable the capability on the account.
24    /// `future_requirements.past_due` is a subset of `requirements.past_due`.
25    pub past_due: Option<Vec<String>>,
26    /// Fields that are being reviewed, or might become required depending on the results of a review.
27    /// If the review fails, these fields can move to `eventually_due`, `currently_due`, `past_due` or `alternatives`.
28    /// Fields might appear in `eventually_due`, `currently_due`, `past_due` or `alternatives` and in `pending_verification` if one verification fails but another is still pending.
29    pub pending_verification: Option<Vec<String>>,
30}
31#[doc(hidden)]
32pub struct AccountFutureRequirementsBuilder {
33    alternatives: Option<Option<Vec<stripe_shared::AccountRequirementsAlternative>>>,
34    current_deadline: Option<Option<stripe_types::Timestamp>>,
35    currently_due: Option<Option<Vec<String>>>,
36    disabled_reason: Option<Option<AccountFutureRequirementsDisabledReason>>,
37    errors: Option<Option<Vec<stripe_shared::AccountRequirementsError>>>,
38    eventually_due: Option<Option<Vec<String>>>,
39    past_due: Option<Option<Vec<String>>>,
40    pending_verification: Option<Option<Vec<String>>>,
41}
42
43#[allow(
44    unused_variables,
45    irrefutable_let_patterns,
46    clippy::let_unit_value,
47    clippy::match_single_binding,
48    clippy::single_match
49)]
50const _: () = {
51    use miniserde::de::{Map, Visitor};
52    use miniserde::json::Value;
53    use miniserde::{Deserialize, Result, make_place};
54    use stripe_types::miniserde_helpers::FromValueOpt;
55    use stripe_types::{MapBuilder, ObjectDeser};
56
57    make_place!(Place);
58
59    impl Deserialize for AccountFutureRequirements {
60        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
61            Place::new(out)
62        }
63    }
64
65    struct Builder<'a> {
66        out: &'a mut Option<AccountFutureRequirements>,
67        builder: AccountFutureRequirementsBuilder,
68    }
69
70    impl Visitor for Place<AccountFutureRequirements> {
71        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
72            Ok(Box::new(Builder {
73                out: &mut self.out,
74                builder: AccountFutureRequirementsBuilder::deser_default(),
75            }))
76        }
77    }
78
79    impl MapBuilder for AccountFutureRequirementsBuilder {
80        type Out = AccountFutureRequirements;
81        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
82            Ok(match k {
83                "alternatives" => Deserialize::begin(&mut self.alternatives),
84                "current_deadline" => Deserialize::begin(&mut self.current_deadline),
85                "currently_due" => Deserialize::begin(&mut self.currently_due),
86                "disabled_reason" => Deserialize::begin(&mut self.disabled_reason),
87                "errors" => Deserialize::begin(&mut self.errors),
88                "eventually_due" => Deserialize::begin(&mut self.eventually_due),
89                "past_due" => Deserialize::begin(&mut self.past_due),
90                "pending_verification" => Deserialize::begin(&mut self.pending_verification),
91                _ => <dyn Visitor>::ignore(),
92            })
93        }
94
95        fn deser_default() -> Self {
96            Self {
97                alternatives: Deserialize::default(),
98                current_deadline: Deserialize::default(),
99                currently_due: Deserialize::default(),
100                disabled_reason: Deserialize::default(),
101                errors: Deserialize::default(),
102                eventually_due: Deserialize::default(),
103                past_due: Deserialize::default(),
104                pending_verification: Deserialize::default(),
105            }
106        }
107
108        fn take_out(&mut self) -> Option<Self::Out> {
109            let (
110                Some(alternatives),
111                Some(current_deadline),
112                Some(currently_due),
113                Some(disabled_reason),
114                Some(errors),
115                Some(eventually_due),
116                Some(past_due),
117                Some(pending_verification),
118            ) = (
119                self.alternatives.take(),
120                self.current_deadline,
121                self.currently_due.take(),
122                self.disabled_reason.take(),
123                self.errors.take(),
124                self.eventually_due.take(),
125                self.past_due.take(),
126                self.pending_verification.take(),
127            )
128            else {
129                return None;
130            };
131            Some(Self::Out {
132                alternatives,
133                current_deadline,
134                currently_due,
135                disabled_reason,
136                errors,
137                eventually_due,
138                past_due,
139                pending_verification,
140            })
141        }
142    }
143
144    impl Map for Builder<'_> {
145        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
146            self.builder.key(k)
147        }
148
149        fn finish(&mut self) -> Result<()> {
150            *self.out = self.builder.take_out();
151            Ok(())
152        }
153    }
154
155    impl ObjectDeser for AccountFutureRequirements {
156        type Builder = AccountFutureRequirementsBuilder;
157    }
158
159    impl FromValueOpt for AccountFutureRequirements {
160        fn from_value(v: Value) -> Option<Self> {
161            let Value::Object(obj) = v else {
162                return None;
163            };
164            let mut b = AccountFutureRequirementsBuilder::deser_default();
165            for (k, v) in obj {
166                match k.as_str() {
167                    "alternatives" => b.alternatives = FromValueOpt::from_value(v),
168                    "current_deadline" => b.current_deadline = FromValueOpt::from_value(v),
169                    "currently_due" => b.currently_due = FromValueOpt::from_value(v),
170                    "disabled_reason" => b.disabled_reason = FromValueOpt::from_value(v),
171                    "errors" => b.errors = FromValueOpt::from_value(v),
172                    "eventually_due" => b.eventually_due = FromValueOpt::from_value(v),
173                    "past_due" => b.past_due = FromValueOpt::from_value(v),
174                    "pending_verification" => b.pending_verification = FromValueOpt::from_value(v),
175                    _ => {}
176                }
177            }
178            b.take_out()
179        }
180    }
181};
182/// This is typed as an enum for consistency with `requirements.disabled_reason`.
183#[derive(Clone, Eq, PartialEq)]
184#[non_exhaustive]
185pub enum AccountFutureRequirementsDisabledReason {
186    ActionRequiredRequestedCapabilities,
187    Listed,
188    Other,
189    PlatformPaused,
190    RejectedFraud,
191    RejectedIncompleteVerification,
192    RejectedListed,
193    RejectedOther,
194    RejectedPlatformFraud,
195    RejectedPlatformOther,
196    RejectedPlatformTermsOfService,
197    RejectedTermsOfService,
198    RequirementsPastDue,
199    RequirementsPendingVerification,
200    UnderReview,
201    /// An unrecognized value from Stripe. Should not be used as a request parameter.
202    Unknown(String),
203}
204impl AccountFutureRequirementsDisabledReason {
205    pub fn as_str(&self) -> &str {
206        use AccountFutureRequirementsDisabledReason::*;
207        match self {
208            ActionRequiredRequestedCapabilities => "action_required.requested_capabilities",
209            Listed => "listed",
210            Other => "other",
211            PlatformPaused => "platform_paused",
212            RejectedFraud => "rejected.fraud",
213            RejectedIncompleteVerification => "rejected.incomplete_verification",
214            RejectedListed => "rejected.listed",
215            RejectedOther => "rejected.other",
216            RejectedPlatformFraud => "rejected.platform_fraud",
217            RejectedPlatformOther => "rejected.platform_other",
218            RejectedPlatformTermsOfService => "rejected.platform_terms_of_service",
219            RejectedTermsOfService => "rejected.terms_of_service",
220            RequirementsPastDue => "requirements.past_due",
221            RequirementsPendingVerification => "requirements.pending_verification",
222            UnderReview => "under_review",
223            Unknown(v) => v,
224        }
225    }
226}
227
228impl std::str::FromStr for AccountFutureRequirementsDisabledReason {
229    type Err = std::convert::Infallible;
230    fn from_str(s: &str) -> Result<Self, Self::Err> {
231        use AccountFutureRequirementsDisabledReason::*;
232        match s {
233            "action_required.requested_capabilities" => Ok(ActionRequiredRequestedCapabilities),
234            "listed" => Ok(Listed),
235            "other" => Ok(Other),
236            "platform_paused" => Ok(PlatformPaused),
237            "rejected.fraud" => Ok(RejectedFraud),
238            "rejected.incomplete_verification" => Ok(RejectedIncompleteVerification),
239            "rejected.listed" => Ok(RejectedListed),
240            "rejected.other" => Ok(RejectedOther),
241            "rejected.platform_fraud" => Ok(RejectedPlatformFraud),
242            "rejected.platform_other" => Ok(RejectedPlatformOther),
243            "rejected.platform_terms_of_service" => Ok(RejectedPlatformTermsOfService),
244            "rejected.terms_of_service" => Ok(RejectedTermsOfService),
245            "requirements.past_due" => Ok(RequirementsPastDue),
246            "requirements.pending_verification" => Ok(RequirementsPendingVerification),
247            "under_review" => Ok(UnderReview),
248            v => {
249                tracing::warn!(
250                    "Unknown value '{}' for enum '{}'",
251                    v,
252                    "AccountFutureRequirementsDisabledReason"
253                );
254                Ok(Unknown(v.to_owned()))
255            }
256        }
257    }
258}
259impl std::fmt::Display for AccountFutureRequirementsDisabledReason {
260    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
261        f.write_str(self.as_str())
262    }
263}
264
265impl std::fmt::Debug for AccountFutureRequirementsDisabledReason {
266    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
267        f.write_str(self.as_str())
268    }
269}
270#[cfg(feature = "serialize")]
271impl serde::Serialize for AccountFutureRequirementsDisabledReason {
272    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
273    where
274        S: serde::Serializer,
275    {
276        serializer.serialize_str(self.as_str())
277    }
278}
279impl miniserde::Deserialize for AccountFutureRequirementsDisabledReason {
280    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
281        crate::Place::new(out)
282    }
283}
284
285impl miniserde::de::Visitor for crate::Place<AccountFutureRequirementsDisabledReason> {
286    fn string(&mut self, s: &str) -> miniserde::Result<()> {
287        use std::str::FromStr;
288        self.out = Some(AccountFutureRequirementsDisabledReason::from_str(s).expect("infallible"));
289        Ok(())
290    }
291}
292
293stripe_types::impl_from_val_with_from_str!(AccountFutureRequirementsDisabledReason);
294#[cfg(feature = "deserialize")]
295impl<'de> serde::Deserialize<'de> for AccountFutureRequirementsDisabledReason {
296    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
297        use std::str::FromStr;
298        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
299        Ok(Self::from_str(&s).expect("infallible"))
300    }
301}
stripe_shared/account_future_requirements.rs

stripe_shared/
account_future_requirements.rs
