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 satisfied by providing the corresponding alternative fields instead.
6    pub alternatives: Option<Vec<stripe_shared::AccountRequirementsAlternative>>,
7    /// Date on which `future_requirements` becomes the main `requirements` hash and `future_requirements` becomes empty.
8    /// 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.
9    pub current_deadline: Option<stripe_types::Timestamp>,
10    /// Fields that need to be collected to keep the account enabled.
11    /// If not collected by `future_requirements[current_deadline]`, these fields will transition to the main `requirements` hash.
12    pub currently_due: Option<Vec<String>>,
13    /// This is typed as an enum for consistency with `requirements.disabled_reason`.
14    pub disabled_reason: Option<AccountFutureRequirementsDisabledReason>,
15    /// Fields that are `currently_due` and need to be collected again because validation or verification failed.
16    pub errors: Option<Vec<stripe_shared::AccountRequirementsError>>,
17    /// Fields you must collect when all thresholds are reached.
18    /// As they become required, they appear in `currently_due` as well.
19    pub eventually_due: Option<Vec<String>>,
20    /// Fields that weren't collected by `requirements.current_deadline`.
21    /// These fields need to be collected to enable the capability on the account.
22    /// New fields will never appear here; `future_requirements.past_due` will always be a subset of `requirements.past_due`.
23    pub past_due: Option<Vec<String>>,
24    /// Fields that might become required depending on the results of verification or review.
25    /// It's an empty array unless an asynchronous verification is pending.
26    /// If verification fails, these fields move to `eventually_due` or `currently_due`.
27    /// Fields might appear in `eventually_due` or `currently_due` and in `pending_verification` if verification fails but another verification is still pending.
28    pub pending_verification: Option<Vec<String>>,
29}
30#[doc(hidden)]
31pub struct AccountFutureRequirementsBuilder {
32    alternatives: Option<Option<Vec<stripe_shared::AccountRequirementsAlternative>>>,
33    current_deadline: Option<Option<stripe_types::Timestamp>>,
34    currently_due: Option<Option<Vec<String>>>,
35    disabled_reason: Option<Option<AccountFutureRequirementsDisabledReason>>,
36    errors: Option<Option<Vec<stripe_shared::AccountRequirementsError>>>,
37    eventually_due: Option<Option<Vec<String>>>,
38    past_due: Option<Option<Vec<String>>>,
39    pending_verification: Option<Option<Vec<String>>>,
40}
41
42#[allow(
43    unused_variables,
44    irrefutable_let_patterns,
45    clippy::let_unit_value,
46    clippy::match_single_binding,
47    clippy::single_match
48)]
49const _: () = {
50    use miniserde::de::{Map, Visitor};
51    use miniserde::json::Value;
52    use miniserde::{make_place, Deserialize, Result};
53    use stripe_types::miniserde_helpers::FromValueOpt;
54    use stripe_types::{MapBuilder, ObjectDeser};
55
56    make_place!(Place);
57
58    impl Deserialize for AccountFutureRequirements {
59        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
60            Place::new(out)
61        }
62    }
63
64    struct Builder<'a> {
65        out: &'a mut Option<AccountFutureRequirements>,
66        builder: AccountFutureRequirementsBuilder,
67    }
68
69    impl Visitor for Place<AccountFutureRequirements> {
70        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
71            Ok(Box::new(Builder {
72                out: &mut self.out,
73                builder: AccountFutureRequirementsBuilder::deser_default(),
74            }))
75        }
76    }
77
78    impl MapBuilder for AccountFutureRequirementsBuilder {
79        type Out = AccountFutureRequirements;
80        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
81            Ok(match k {
82                "alternatives" => Deserialize::begin(&mut self.alternatives),
83                "current_deadline" => Deserialize::begin(&mut self.current_deadline),
84                "currently_due" => Deserialize::begin(&mut self.currently_due),
85                "disabled_reason" => Deserialize::begin(&mut self.disabled_reason),
86                "errors" => Deserialize::begin(&mut self.errors),
87                "eventually_due" => Deserialize::begin(&mut self.eventually_due),
88                "past_due" => Deserialize::begin(&mut self.past_due),
89                "pending_verification" => Deserialize::begin(&mut self.pending_verification),
90
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<'a> Map for Builder<'a> {
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            }
179            b.take_out()
180        }
181    }
182};
183/// This is typed as an enum for consistency with `requirements.disabled_reason`.
184#[derive(Clone, Eq, PartialEq)]
185#[non_exhaustive]
186pub enum AccountFutureRequirementsDisabledReason {
187    ActionRequiredRequestedCapabilities,
188    Listed,
189    Other,
190    PlatformPaused,
191    RejectedFraud,
192    RejectedIncompleteVerification,
193    RejectedListed,
194    RejectedOther,
195    RejectedPlatformFraud,
196    RejectedPlatformOther,
197    RejectedPlatformTermsOfService,
198    RejectedTermsOfService,
199    RequirementsPastDue,
200    RequirementsPendingVerification,
201    UnderReview,
202    /// An unrecognized value from Stripe. Should not be used as a request parameter.
203    Unknown(String),
204}
205impl AccountFutureRequirementsDisabledReason {
206    pub fn as_str(&self) -> &str {
207        use AccountFutureRequirementsDisabledReason::*;
208        match self {
209            ActionRequiredRequestedCapabilities => "action_required.requested_capabilities",
210            Listed => "listed",
211            Other => "other",
212            PlatformPaused => "platform_paused",
213            RejectedFraud => "rejected.fraud",
214            RejectedIncompleteVerification => "rejected.incomplete_verification",
215            RejectedListed => "rejected.listed",
216            RejectedOther => "rejected.other",
217            RejectedPlatformFraud => "rejected.platform_fraud",
218            RejectedPlatformOther => "rejected.platform_other",
219            RejectedPlatformTermsOfService => "rejected.platform_terms_of_service",
220            RejectedTermsOfService => "rejected.terms_of_service",
221            RequirementsPastDue => "requirements.past_due",
222            RequirementsPendingVerification => "requirements.pending_verification",
223            UnderReview => "under_review",
224            Unknown(v) => v,
225        }
226    }
227}
228
229impl std::str::FromStr for AccountFutureRequirementsDisabledReason {
230    type Err = std::convert::Infallible;
231    fn from_str(s: &str) -> Result<Self, Self::Err> {
232        use AccountFutureRequirementsDisabledReason::*;
233        match s {
234            "action_required.requested_capabilities" => Ok(ActionRequiredRequestedCapabilities),
235            "listed" => Ok(Listed),
236            "other" => Ok(Other),
237            "platform_paused" => Ok(PlatformPaused),
238            "rejected.fraud" => Ok(RejectedFraud),
239            "rejected.incomplete_verification" => Ok(RejectedIncompleteVerification),
240            "rejected.listed" => Ok(RejectedListed),
241            "rejected.other" => Ok(RejectedOther),
242            "rejected.platform_fraud" => Ok(RejectedPlatformFraud),
243            "rejected.platform_other" => Ok(RejectedPlatformOther),
244            "rejected.platform_terms_of_service" => Ok(RejectedPlatformTermsOfService),
245            "rejected.terms_of_service" => Ok(RejectedTermsOfService),
246            "requirements.past_due" => Ok(RequirementsPastDue),
247            "requirements.pending_verification" => Ok(RequirementsPendingVerification),
248            "under_review" => Ok(UnderReview),
249            v => Ok(Unknown(v.to_owned())),
250        }
251    }
252}
253impl std::fmt::Display for AccountFutureRequirementsDisabledReason {
254    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
255        f.write_str(self.as_str())
256    }
257}
258
259impl std::fmt::Debug for AccountFutureRequirementsDisabledReason {
260    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
261        f.write_str(self.as_str())
262    }
263}
264#[cfg(feature = "serialize")]
265impl serde::Serialize for AccountFutureRequirementsDisabledReason {
266    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
267    where
268        S: serde::Serializer,
269    {
270        serializer.serialize_str(self.as_str())
271    }
272}
273impl miniserde::Deserialize for AccountFutureRequirementsDisabledReason {
274    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
275        crate::Place::new(out)
276    }
277}
278
279impl miniserde::de::Visitor for crate::Place<AccountFutureRequirementsDisabledReason> {
280    fn string(&mut self, s: &str) -> miniserde::Result<()> {
281        use std::str::FromStr;
282        self.out = Some(AccountFutureRequirementsDisabledReason::from_str(s).unwrap());
283        Ok(())
284    }
285}
286
287stripe_types::impl_from_val_with_from_str!(AccountFutureRequirementsDisabledReason);
288#[cfg(feature = "deserialize")]
289impl<'de> serde::Deserialize<'de> for AccountFutureRequirementsDisabledReason {
290    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
291        use std::str::FromStr;
292        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
293        Ok(Self::from_str(&s).unwrap())
294    }
295}
stripe_shared/account_future_requirements.rs

stripe_shared/
account_future_requirements.rs
