stripe_shared/
account_requirements.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct AccountRequirements {
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 by which the fields in `currently_due` must be collected to keep the account enabled.
10    /// These fields may disable the account sooner if the next threshold is reached before they are collected.
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 `current_deadline`, these fields will appear in `past_due` as well, and the account is disabled.
14    pub currently_due: Option<Vec<String>>,
15    /// If the account is disabled, this enum describes why.
16    /// [Learn more about handling verification issues](https://docs.stripe.com/connect/handling-api-verification).
17    pub disabled_reason: Option<AccountRequirementsDisabledReason>,
18    /// Details about validation and verification failures for `due` requirements that must be resolved.
19    pub errors: Option<Vec<stripe_shared::AccountRequirementsError>>,
20    /// Fields you must collect when all thresholds are reached.
21    /// As they become required, they appear in `currently_due` as well, and `current_deadline` becomes set.
22    pub eventually_due: Option<Vec<String>>,
23    /// Fields that haven't been resolved by `current_deadline`.
24    /// These fields need to be resolved to enable the account.
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 AccountRequirementsBuilder {
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<AccountRequirementsDisabledReason>>,
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 AccountRequirements {
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<AccountRequirements>,
67        builder: AccountRequirementsBuilder,
68    }
69
70    impl Visitor for Place<AccountRequirements> {
71        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
72            Ok(Box::new(Builder {
73                out: &mut self.out,
74                builder: AccountRequirementsBuilder::deser_default(),
75            }))
76        }
77    }
78
79    impl MapBuilder for AccountRequirementsBuilder {
80        type Out = AccountRequirements;
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 AccountRequirements {
156        type Builder = AccountRequirementsBuilder;
157    }
158
159    impl FromValueOpt for AccountRequirements {
160        fn from_value(v: Value) -> Option<Self> {
161            let Value::Object(obj) = v else {
162                return None;
163            };
164            let mut b = AccountRequirementsBuilder::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/// If the account is disabled, this enum describes why.
183/// [Learn more about handling verification issues](https://docs.stripe.com/connect/handling-api-verification).
184#[derive(Clone, Eq, PartialEq)]
185#[non_exhaustive]
186pub enum AccountRequirementsDisabledReason {
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 AccountRequirementsDisabledReason {
206    pub fn as_str(&self) -> &str {
207        use AccountRequirementsDisabledReason::*;
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 AccountRequirementsDisabledReason {
230    type Err = std::convert::Infallible;
231    fn from_str(s: &str) -> Result<Self, Self::Err> {
232        use AccountRequirementsDisabledReason::*;
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 => {
250                tracing::warn!(
251                    "Unknown value '{}' for enum '{}'",
252                    v,
253                    "AccountRequirementsDisabledReason"
254                );
255                Ok(Unknown(v.to_owned()))
256            }
257        }
258    }
259}
260impl std::fmt::Display for AccountRequirementsDisabledReason {
261    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
262        f.write_str(self.as_str())
263    }
264}
265
266impl std::fmt::Debug for AccountRequirementsDisabledReason {
267    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
268        f.write_str(self.as_str())
269    }
270}
271#[cfg(feature = "serialize")]
272impl serde::Serialize for AccountRequirementsDisabledReason {
273    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
274    where
275        S: serde::Serializer,
276    {
277        serializer.serialize_str(self.as_str())
278    }
279}
280impl miniserde::Deserialize for AccountRequirementsDisabledReason {
281    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
282        crate::Place::new(out)
283    }
284}
285
286impl miniserde::de::Visitor for crate::Place<AccountRequirementsDisabledReason> {
287    fn string(&mut self, s: &str) -> miniserde::Result<()> {
288        use std::str::FromStr;
289        self.out = Some(AccountRequirementsDisabledReason::from_str(s).expect("infallible"));
290        Ok(())
291    }
292}
293
294stripe_types::impl_from_val_with_from_str!(AccountRequirementsDisabledReason);
295#[cfg(feature = "deserialize")]
296impl<'de> serde::Deserialize<'de> for AccountRequirementsDisabledReason {
297    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
298        use std::str::FromStr;
299        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
300        Ok(Self::from_str(&s).expect("infallible"))
301    }
302}
stripe_shared/account_requirements.rs

stripe_shared/
account_requirements.rs
