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 satisfied by providing the corresponding alternative fields instead.
6    pub alternatives: Option<Vec<stripe_shared::AccountRequirementsAlternative>>,
7    /// Date by which the fields in `currently_due` must be collected to keep the account enabled.
8    /// These fields may disable the account sooner if the next threshold is reached before they are collected.
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 `current_deadline`, these fields appear in `past_due` as well, and the account is disabled.
12    pub currently_due: Option<Vec<String>>,
13    /// If the account is disabled, this enum describes why.
14    /// [Learn more about handling verification issues](https://stripe.com/docs/connect/handling-api-verification).
15    pub disabled_reason: Option<AccountRequirementsDisabledReason>,
16    /// Fields that are `currently_due` and need to be collected again because validation or verification failed.
17    pub errors: Option<Vec<stripe_shared::AccountRequirementsError>>,
18    /// Fields you must collect when all thresholds are reached.
19    /// As they become required, they appear in `currently_due` as well, and `current_deadline` becomes set.
20    pub eventually_due: Option<Vec<String>>,
21    /// Fields that weren't collected by `current_deadline`.
22    /// These fields need to be collected to enable the account.
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`, `currently_due`, or `past_due`.
27    /// Fields might appear in `eventually_due`, `currently_due`, or `past_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 AccountRequirementsBuilder {
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<AccountRequirementsDisabledReason>>,
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 AccountRequirements {
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<AccountRequirements>,
66        builder: AccountRequirementsBuilder,
67    }
68
69    impl Visitor for Place<AccountRequirements> {
70        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
71            Ok(Box::new(Builder {
72                out: &mut self.out,
73                builder: AccountRequirementsBuilder::deser_default(),
74            }))
75        }
76    }
77
78    impl MapBuilder for AccountRequirementsBuilder {
79        type Out = AccountRequirements;
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 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            }
179            b.take_out()
180        }
181    }
182};
183/// If the account is disabled, this enum describes why.
184/// [Learn more about handling verification issues](https://stripe.com/docs/connect/handling-api-verification).
185#[derive(Clone, Eq, PartialEq)]
186#[non_exhaustive]
187pub enum AccountRequirementsDisabledReason {
188    ActionRequiredRequestedCapabilities,
189    Listed,
190    Other,
191    PlatformPaused,
192    RejectedFraud,
193    RejectedIncompleteVerification,
194    RejectedListed,
195    RejectedOther,
196    RejectedPlatformFraud,
197    RejectedPlatformOther,
198    RejectedPlatformTermsOfService,
199    RejectedTermsOfService,
200    RequirementsPastDue,
201    RequirementsPendingVerification,
202    UnderReview,
203    /// An unrecognized value from Stripe. Should not be used as a request parameter.
204    Unknown(String),
205}
206impl AccountRequirementsDisabledReason {
207    pub fn as_str(&self) -> &str {
208        use AccountRequirementsDisabledReason::*;
209        match self {
210            ActionRequiredRequestedCapabilities => "action_required.requested_capabilities",
211            Listed => "listed",
212            Other => "other",
213            PlatformPaused => "platform_paused",
214            RejectedFraud => "rejected.fraud",
215            RejectedIncompleteVerification => "rejected.incomplete_verification",
216            RejectedListed => "rejected.listed",
217            RejectedOther => "rejected.other",
218            RejectedPlatformFraud => "rejected.platform_fraud",
219            RejectedPlatformOther => "rejected.platform_other",
220            RejectedPlatformTermsOfService => "rejected.platform_terms_of_service",
221            RejectedTermsOfService => "rejected.terms_of_service",
222            RequirementsPastDue => "requirements.past_due",
223            RequirementsPendingVerification => "requirements.pending_verification",
224            UnderReview => "under_review",
225            Unknown(v) => v,
226        }
227    }
228}
229
230impl std::str::FromStr for AccountRequirementsDisabledReason {
231    type Err = std::convert::Infallible;
232    fn from_str(s: &str) -> Result<Self, Self::Err> {
233        use AccountRequirementsDisabledReason::*;
234        match s {
235            "action_required.requested_capabilities" => Ok(ActionRequiredRequestedCapabilities),
236            "listed" => Ok(Listed),
237            "other" => Ok(Other),
238            "platform_paused" => Ok(PlatformPaused),
239            "rejected.fraud" => Ok(RejectedFraud),
240            "rejected.incomplete_verification" => Ok(RejectedIncompleteVerification),
241            "rejected.listed" => Ok(RejectedListed),
242            "rejected.other" => Ok(RejectedOther),
243            "rejected.platform_fraud" => Ok(RejectedPlatformFraud),
244            "rejected.platform_other" => Ok(RejectedPlatformOther),
245            "rejected.platform_terms_of_service" => Ok(RejectedPlatformTermsOfService),
246            "rejected.terms_of_service" => Ok(RejectedTermsOfService),
247            "requirements.past_due" => Ok(RequirementsPastDue),
248            "requirements.pending_verification" => Ok(RequirementsPendingVerification),
249            "under_review" => Ok(UnderReview),
250            v => Ok(Unknown(v.to_owned())),
251        }
252    }
253}
254impl std::fmt::Display for AccountRequirementsDisabledReason {
255    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
256        f.write_str(self.as_str())
257    }
258}
259
260impl std::fmt::Debug for AccountRequirementsDisabledReason {
261    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
262        f.write_str(self.as_str())
263    }
264}
265#[cfg(feature = "serialize")]
266impl serde::Serialize for AccountRequirementsDisabledReason {
267    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
268    where
269        S: serde::Serializer,
270    {
271        serializer.serialize_str(self.as_str())
272    }
273}
274impl miniserde::Deserialize for AccountRequirementsDisabledReason {
275    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
276        crate::Place::new(out)
277    }
278}
279
280impl miniserde::de::Visitor for crate::Place<AccountRequirementsDisabledReason> {
281    fn string(&mut self, s: &str) -> miniserde::Result<()> {
282        use std::str::FromStr;
283        self.out = Some(AccountRequirementsDisabledReason::from_str(s).unwrap());
284        Ok(())
285    }
286}
287
288stripe_types::impl_from_val_with_from_str!(AccountRequirementsDisabledReason);
289#[cfg(feature = "deserialize")]
290impl<'de> serde::Deserialize<'de> for AccountRequirementsDisabledReason {
291    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
292        use std::str::FromStr;
293        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
294        Ok(Self::from_str(&s).unwrap())
295    }
296}
stripe_shared/account_requirements.rs

stripe_shared/
account_requirements.rs
