1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct AccountRequirements {
5 pub alternatives: Option<Vec<stripe_shared::AccountRequirementsAlternative>>,
7 pub current_deadline: Option<stripe_types::Timestamp>,
10 pub currently_due: Option<Vec<String>>,
13 pub disabled_reason: Option<AccountRequirementsDisabledReason>,
16 pub errors: Option<Vec<stripe_shared::AccountRequirementsError>>,
18 pub eventually_due: Option<Vec<String>>,
21 pub past_due: Option<Vec<String>>,
24 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<'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 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#[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 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}