1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct AccountRequirementsError {
5 pub code: AccountRequirementsErrorCode,
7 pub reason: String,
9 pub requirement: String,
11}
12#[doc(hidden)]
13pub struct AccountRequirementsErrorBuilder {
14 code: Option<AccountRequirementsErrorCode>,
15 reason: Option<String>,
16 requirement: Option<String>,
17}
18
19#[allow(
20 unused_variables,
21 irrefutable_let_patterns,
22 clippy::let_unit_value,
23 clippy::match_single_binding,
24 clippy::single_match
25)]
26const _: () = {
27 use miniserde::de::{Map, Visitor};
28 use miniserde::json::Value;
29 use miniserde::{Deserialize, Result, make_place};
30 use stripe_types::miniserde_helpers::FromValueOpt;
31 use stripe_types::{MapBuilder, ObjectDeser};
32
33 make_place!(Place);
34
35 impl Deserialize for AccountRequirementsError {
36 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
37 Place::new(out)
38 }
39 }
40
41 struct Builder<'a> {
42 out: &'a mut Option<AccountRequirementsError>,
43 builder: AccountRequirementsErrorBuilder,
44 }
45
46 impl Visitor for Place<AccountRequirementsError> {
47 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
48 Ok(Box::new(Builder {
49 out: &mut self.out,
50 builder: AccountRequirementsErrorBuilder::deser_default(),
51 }))
52 }
53 }
54
55 impl MapBuilder for AccountRequirementsErrorBuilder {
56 type Out = AccountRequirementsError;
57 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
58 Ok(match k {
59 "code" => Deserialize::begin(&mut self.code),
60 "reason" => Deserialize::begin(&mut self.reason),
61 "requirement" => Deserialize::begin(&mut self.requirement),
62
63 _ => <dyn Visitor>::ignore(),
64 })
65 }
66
67 fn deser_default() -> Self {
68 Self {
69 code: Deserialize::default(),
70 reason: Deserialize::default(),
71 requirement: Deserialize::default(),
72 }
73 }
74
75 fn take_out(&mut self) -> Option<Self::Out> {
76 let (Some(code), Some(reason), Some(requirement)) =
77 (self.code.take(), self.reason.take(), self.requirement.take())
78 else {
79 return None;
80 };
81 Some(Self::Out { code, reason, requirement })
82 }
83 }
84
85 impl Map for Builder<'_> {
86 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
87 self.builder.key(k)
88 }
89
90 fn finish(&mut self) -> Result<()> {
91 *self.out = self.builder.take_out();
92 Ok(())
93 }
94 }
95
96 impl ObjectDeser for AccountRequirementsError {
97 type Builder = AccountRequirementsErrorBuilder;
98 }
99
100 impl FromValueOpt for AccountRequirementsError {
101 fn from_value(v: Value) -> Option<Self> {
102 let Value::Object(obj) = v else {
103 return None;
104 };
105 let mut b = AccountRequirementsErrorBuilder::deser_default();
106 for (k, v) in obj {
107 match k.as_str() {
108 "code" => b.code = FromValueOpt::from_value(v),
109 "reason" => b.reason = FromValueOpt::from_value(v),
110 "requirement" => b.requirement = FromValueOpt::from_value(v),
111
112 _ => {}
113 }
114 }
115 b.take_out()
116 }
117 }
118};
119#[derive(Clone, Eq, PartialEq)]
121#[non_exhaustive]
122pub enum AccountRequirementsErrorCode {
123 ExternalRequest,
124 InformationMissing,
125 InvalidAddressCityStatePostalCode,
126 InvalidAddressHighwayContractBox,
127 InvalidAddressPrivateMailbox,
128 InvalidBusinessProfileName,
129 InvalidBusinessProfileNameDenylisted,
130 InvalidCompanyNameDenylisted,
131 InvalidDobAgeOverMaximum,
132 InvalidDobAgeUnder18,
133 InvalidDobAgeUnderMinimum,
134 InvalidProductDescriptionLength,
135 InvalidProductDescriptionUrlMatch,
136 InvalidRepresentativeCountry,
137 InvalidSignator,
138 InvalidStatementDescriptorBusinessMismatch,
139 InvalidStatementDescriptorDenylisted,
140 InvalidStatementDescriptorLength,
141 InvalidStatementDescriptorPrefixDenylisted,
142 InvalidStatementDescriptorPrefixMismatch,
143 InvalidStreetAddress,
144 InvalidTaxId,
145 InvalidTaxIdFormat,
146 InvalidTosAcceptance,
147 InvalidUrlDenylisted,
148 InvalidUrlFormat,
149 InvalidUrlLength,
150 InvalidUrlWebPresenceDetected,
151 InvalidUrlWebsiteBusinessInformationMismatch,
152 InvalidUrlWebsiteEmpty,
153 InvalidUrlWebsiteInaccessible,
154 InvalidUrlWebsiteInaccessibleGeoblocked,
155 InvalidUrlWebsiteInaccessiblePasswordProtected,
156 InvalidUrlWebsiteIncomplete,
157 InvalidUrlWebsiteIncompleteCancellationPolicy,
158 InvalidUrlWebsiteIncompleteCustomerServiceDetails,
159 InvalidUrlWebsiteIncompleteLegalRestrictions,
160 InvalidUrlWebsiteIncompleteRefundPolicy,
161 InvalidUrlWebsiteIncompleteReturnPolicy,
162 InvalidUrlWebsiteIncompleteTermsAndConditions,
163 InvalidUrlWebsiteIncompleteUnderConstruction,
164 InvalidUrlWebsiteOther,
165 InvalidValueOther,
166 UnsupportedBusinessType,
167 VerificationDirectorsMismatch,
168 VerificationDocumentAddressMismatch,
169 VerificationDocumentAddressMissing,
170 VerificationDocumentCorrupt,
171 VerificationDocumentCountryNotSupported,
172 VerificationDocumentDirectorsMismatch,
173 VerificationDocumentDobMismatch,
174 VerificationDocumentDuplicateType,
175 VerificationDocumentExpired,
176 VerificationDocumentFailedCopy,
177 VerificationDocumentFailedGreyscale,
178 VerificationDocumentFailedOther,
179 VerificationDocumentFailedTestMode,
180 VerificationDocumentFraudulent,
181 VerificationDocumentIdNumberMismatch,
182 VerificationDocumentIdNumberMissing,
183 VerificationDocumentIncomplete,
184 VerificationDocumentInvalid,
185 VerificationDocumentIssueOrExpiryDateMissing,
186 VerificationDocumentManipulated,
187 VerificationDocumentMissingBack,
188 VerificationDocumentMissingFront,
189 VerificationDocumentNameMismatch,
190 VerificationDocumentNameMissing,
191 VerificationDocumentNationalityMismatch,
192 VerificationDocumentNotReadable,
193 VerificationDocumentNotSigned,
194 VerificationDocumentNotUploaded,
195 VerificationDocumentPhotoMismatch,
196 VerificationDocumentTooLarge,
197 VerificationDocumentTypeNotSupported,
198 VerificationExtraneousDirectors,
199 VerificationFailedAddressMatch,
200 VerificationFailedAuthorizerAuthority,
201 VerificationFailedBusinessIecNumber,
202 VerificationFailedDocumentMatch,
203 VerificationFailedIdNumberMatch,
204 VerificationFailedKeyedIdentity,
205 VerificationFailedKeyedMatch,
206 VerificationFailedNameMatch,
207 VerificationFailedOther,
208 VerificationFailedRepresentativeAuthority,
209 VerificationFailedResidentialAddress,
210 VerificationFailedTaxIdMatch,
211 VerificationFailedTaxIdNotIssued,
212 VerificationLegalEntityStructureMismatch,
213 VerificationMissingDirectors,
214 VerificationMissingExecutives,
215 VerificationMissingOwners,
216 VerificationRejectedOwnershipExemptionReason,
217 VerificationRequiresAdditionalMemorandumOfAssociations,
218 VerificationRequiresAdditionalProofOfRegistration,
219 VerificationSupportability,
220 Unknown(String),
222}
223impl AccountRequirementsErrorCode {
224 pub fn as_str(&self) -> &str {
225 use AccountRequirementsErrorCode::*;
226 match self {
227 ExternalRequest => "external_request",
228 InformationMissing => "information_missing",
229 InvalidAddressCityStatePostalCode => "invalid_address_city_state_postal_code",
230 InvalidAddressHighwayContractBox => "invalid_address_highway_contract_box",
231 InvalidAddressPrivateMailbox => "invalid_address_private_mailbox",
232 InvalidBusinessProfileName => "invalid_business_profile_name",
233 InvalidBusinessProfileNameDenylisted => "invalid_business_profile_name_denylisted",
234 InvalidCompanyNameDenylisted => "invalid_company_name_denylisted",
235 InvalidDobAgeOverMaximum => "invalid_dob_age_over_maximum",
236 InvalidDobAgeUnder18 => "invalid_dob_age_under_18",
237 InvalidDobAgeUnderMinimum => "invalid_dob_age_under_minimum",
238 InvalidProductDescriptionLength => "invalid_product_description_length",
239 InvalidProductDescriptionUrlMatch => "invalid_product_description_url_match",
240 InvalidRepresentativeCountry => "invalid_representative_country",
241 InvalidSignator => "invalid_signator",
242 InvalidStatementDescriptorBusinessMismatch => {
243 "invalid_statement_descriptor_business_mismatch"
244 }
245 InvalidStatementDescriptorDenylisted => "invalid_statement_descriptor_denylisted",
246 InvalidStatementDescriptorLength => "invalid_statement_descriptor_length",
247 InvalidStatementDescriptorPrefixDenylisted => {
248 "invalid_statement_descriptor_prefix_denylisted"
249 }
250 InvalidStatementDescriptorPrefixMismatch => {
251 "invalid_statement_descriptor_prefix_mismatch"
252 }
253 InvalidStreetAddress => "invalid_street_address",
254 InvalidTaxId => "invalid_tax_id",
255 InvalidTaxIdFormat => "invalid_tax_id_format",
256 InvalidTosAcceptance => "invalid_tos_acceptance",
257 InvalidUrlDenylisted => "invalid_url_denylisted",
258 InvalidUrlFormat => "invalid_url_format",
259 InvalidUrlLength => "invalid_url_length",
260 InvalidUrlWebPresenceDetected => "invalid_url_web_presence_detected",
261 InvalidUrlWebsiteBusinessInformationMismatch => {
262 "invalid_url_website_business_information_mismatch"
263 }
264 InvalidUrlWebsiteEmpty => "invalid_url_website_empty",
265 InvalidUrlWebsiteInaccessible => "invalid_url_website_inaccessible",
266 InvalidUrlWebsiteInaccessibleGeoblocked => {
267 "invalid_url_website_inaccessible_geoblocked"
268 }
269 InvalidUrlWebsiteInaccessiblePasswordProtected => {
270 "invalid_url_website_inaccessible_password_protected"
271 }
272 InvalidUrlWebsiteIncomplete => "invalid_url_website_incomplete",
273 InvalidUrlWebsiteIncompleteCancellationPolicy => {
274 "invalid_url_website_incomplete_cancellation_policy"
275 }
276 InvalidUrlWebsiteIncompleteCustomerServiceDetails => {
277 "invalid_url_website_incomplete_customer_service_details"
278 }
279 InvalidUrlWebsiteIncompleteLegalRestrictions => {
280 "invalid_url_website_incomplete_legal_restrictions"
281 }
282 InvalidUrlWebsiteIncompleteRefundPolicy => {
283 "invalid_url_website_incomplete_refund_policy"
284 }
285 InvalidUrlWebsiteIncompleteReturnPolicy => {
286 "invalid_url_website_incomplete_return_policy"
287 }
288 InvalidUrlWebsiteIncompleteTermsAndConditions => {
289 "invalid_url_website_incomplete_terms_and_conditions"
290 }
291 InvalidUrlWebsiteIncompleteUnderConstruction => {
292 "invalid_url_website_incomplete_under_construction"
293 }
294 InvalidUrlWebsiteOther => "invalid_url_website_other",
295 InvalidValueOther => "invalid_value_other",
296 UnsupportedBusinessType => "unsupported_business_type",
297 VerificationDirectorsMismatch => "verification_directors_mismatch",
298 VerificationDocumentAddressMismatch => "verification_document_address_mismatch",
299 VerificationDocumentAddressMissing => "verification_document_address_missing",
300 VerificationDocumentCorrupt => "verification_document_corrupt",
301 VerificationDocumentCountryNotSupported => {
302 "verification_document_country_not_supported"
303 }
304 VerificationDocumentDirectorsMismatch => "verification_document_directors_mismatch",
305 VerificationDocumentDobMismatch => "verification_document_dob_mismatch",
306 VerificationDocumentDuplicateType => "verification_document_duplicate_type",
307 VerificationDocumentExpired => "verification_document_expired",
308 VerificationDocumentFailedCopy => "verification_document_failed_copy",
309 VerificationDocumentFailedGreyscale => "verification_document_failed_greyscale",
310 VerificationDocumentFailedOther => "verification_document_failed_other",
311 VerificationDocumentFailedTestMode => "verification_document_failed_test_mode",
312 VerificationDocumentFraudulent => "verification_document_fraudulent",
313 VerificationDocumentIdNumberMismatch => "verification_document_id_number_mismatch",
314 VerificationDocumentIdNumberMissing => "verification_document_id_number_missing",
315 VerificationDocumentIncomplete => "verification_document_incomplete",
316 VerificationDocumentInvalid => "verification_document_invalid",
317 VerificationDocumentIssueOrExpiryDateMissing => {
318 "verification_document_issue_or_expiry_date_missing"
319 }
320 VerificationDocumentManipulated => "verification_document_manipulated",
321 VerificationDocumentMissingBack => "verification_document_missing_back",
322 VerificationDocumentMissingFront => "verification_document_missing_front",
323 VerificationDocumentNameMismatch => "verification_document_name_mismatch",
324 VerificationDocumentNameMissing => "verification_document_name_missing",
325 VerificationDocumentNationalityMismatch => "verification_document_nationality_mismatch",
326 VerificationDocumentNotReadable => "verification_document_not_readable",
327 VerificationDocumentNotSigned => "verification_document_not_signed",
328 VerificationDocumentNotUploaded => "verification_document_not_uploaded",
329 VerificationDocumentPhotoMismatch => "verification_document_photo_mismatch",
330 VerificationDocumentTooLarge => "verification_document_too_large",
331 VerificationDocumentTypeNotSupported => "verification_document_type_not_supported",
332 VerificationExtraneousDirectors => "verification_extraneous_directors",
333 VerificationFailedAddressMatch => "verification_failed_address_match",
334 VerificationFailedAuthorizerAuthority => "verification_failed_authorizer_authority",
335 VerificationFailedBusinessIecNumber => "verification_failed_business_iec_number",
336 VerificationFailedDocumentMatch => "verification_failed_document_match",
337 VerificationFailedIdNumberMatch => "verification_failed_id_number_match",
338 VerificationFailedKeyedIdentity => "verification_failed_keyed_identity",
339 VerificationFailedKeyedMatch => "verification_failed_keyed_match",
340 VerificationFailedNameMatch => "verification_failed_name_match",
341 VerificationFailedOther => "verification_failed_other",
342 VerificationFailedRepresentativeAuthority => {
343 "verification_failed_representative_authority"
344 }
345 VerificationFailedResidentialAddress => "verification_failed_residential_address",
346 VerificationFailedTaxIdMatch => "verification_failed_tax_id_match",
347 VerificationFailedTaxIdNotIssued => "verification_failed_tax_id_not_issued",
348 VerificationLegalEntityStructureMismatch => {
349 "verification_legal_entity_structure_mismatch"
350 }
351 VerificationMissingDirectors => "verification_missing_directors",
352 VerificationMissingExecutives => "verification_missing_executives",
353 VerificationMissingOwners => "verification_missing_owners",
354 VerificationRejectedOwnershipExemptionReason => {
355 "verification_rejected_ownership_exemption_reason"
356 }
357 VerificationRequiresAdditionalMemorandumOfAssociations => {
358 "verification_requires_additional_memorandum_of_associations"
359 }
360 VerificationRequiresAdditionalProofOfRegistration => {
361 "verification_requires_additional_proof_of_registration"
362 }
363 VerificationSupportability => "verification_supportability",
364 Unknown(v) => v,
365 }
366 }
367}
368
369impl std::str::FromStr for AccountRequirementsErrorCode {
370 type Err = std::convert::Infallible;
371 fn from_str(s: &str) -> Result<Self, Self::Err> {
372 use AccountRequirementsErrorCode::*;
373 match s {
374 "external_request" => Ok(ExternalRequest),
375 "information_missing" => Ok(InformationMissing),
376 "invalid_address_city_state_postal_code" => Ok(InvalidAddressCityStatePostalCode),
377 "invalid_address_highway_contract_box" => Ok(InvalidAddressHighwayContractBox),
378 "invalid_address_private_mailbox" => Ok(InvalidAddressPrivateMailbox),
379 "invalid_business_profile_name" => Ok(InvalidBusinessProfileName),
380 "invalid_business_profile_name_denylisted" => Ok(InvalidBusinessProfileNameDenylisted),
381 "invalid_company_name_denylisted" => Ok(InvalidCompanyNameDenylisted),
382 "invalid_dob_age_over_maximum" => Ok(InvalidDobAgeOverMaximum),
383 "invalid_dob_age_under_18" => Ok(InvalidDobAgeUnder18),
384 "invalid_dob_age_under_minimum" => Ok(InvalidDobAgeUnderMinimum),
385 "invalid_product_description_length" => Ok(InvalidProductDescriptionLength),
386 "invalid_product_description_url_match" => Ok(InvalidProductDescriptionUrlMatch),
387 "invalid_representative_country" => Ok(InvalidRepresentativeCountry),
388 "invalid_signator" => Ok(InvalidSignator),
389 "invalid_statement_descriptor_business_mismatch" => {
390 Ok(InvalidStatementDescriptorBusinessMismatch)
391 }
392 "invalid_statement_descriptor_denylisted" => Ok(InvalidStatementDescriptorDenylisted),
393 "invalid_statement_descriptor_length" => Ok(InvalidStatementDescriptorLength),
394 "invalid_statement_descriptor_prefix_denylisted" => {
395 Ok(InvalidStatementDescriptorPrefixDenylisted)
396 }
397 "invalid_statement_descriptor_prefix_mismatch" => {
398 Ok(InvalidStatementDescriptorPrefixMismatch)
399 }
400 "invalid_street_address" => Ok(InvalidStreetAddress),
401 "invalid_tax_id" => Ok(InvalidTaxId),
402 "invalid_tax_id_format" => Ok(InvalidTaxIdFormat),
403 "invalid_tos_acceptance" => Ok(InvalidTosAcceptance),
404 "invalid_url_denylisted" => Ok(InvalidUrlDenylisted),
405 "invalid_url_format" => Ok(InvalidUrlFormat),
406 "invalid_url_length" => Ok(InvalidUrlLength),
407 "invalid_url_web_presence_detected" => Ok(InvalidUrlWebPresenceDetected),
408 "invalid_url_website_business_information_mismatch" => {
409 Ok(InvalidUrlWebsiteBusinessInformationMismatch)
410 }
411 "invalid_url_website_empty" => Ok(InvalidUrlWebsiteEmpty),
412 "invalid_url_website_inaccessible" => Ok(InvalidUrlWebsiteInaccessible),
413 "invalid_url_website_inaccessible_geoblocked" => {
414 Ok(InvalidUrlWebsiteInaccessibleGeoblocked)
415 }
416 "invalid_url_website_inaccessible_password_protected" => {
417 Ok(InvalidUrlWebsiteInaccessiblePasswordProtected)
418 }
419 "invalid_url_website_incomplete" => Ok(InvalidUrlWebsiteIncomplete),
420 "invalid_url_website_incomplete_cancellation_policy" => {
421 Ok(InvalidUrlWebsiteIncompleteCancellationPolicy)
422 }
423 "invalid_url_website_incomplete_customer_service_details" => {
424 Ok(InvalidUrlWebsiteIncompleteCustomerServiceDetails)
425 }
426 "invalid_url_website_incomplete_legal_restrictions" => {
427 Ok(InvalidUrlWebsiteIncompleteLegalRestrictions)
428 }
429 "invalid_url_website_incomplete_refund_policy" => {
430 Ok(InvalidUrlWebsiteIncompleteRefundPolicy)
431 }
432 "invalid_url_website_incomplete_return_policy" => {
433 Ok(InvalidUrlWebsiteIncompleteReturnPolicy)
434 }
435 "invalid_url_website_incomplete_terms_and_conditions" => {
436 Ok(InvalidUrlWebsiteIncompleteTermsAndConditions)
437 }
438 "invalid_url_website_incomplete_under_construction" => {
439 Ok(InvalidUrlWebsiteIncompleteUnderConstruction)
440 }
441 "invalid_url_website_other" => Ok(InvalidUrlWebsiteOther),
442 "invalid_value_other" => Ok(InvalidValueOther),
443 "unsupported_business_type" => Ok(UnsupportedBusinessType),
444 "verification_directors_mismatch" => Ok(VerificationDirectorsMismatch),
445 "verification_document_address_mismatch" => Ok(VerificationDocumentAddressMismatch),
446 "verification_document_address_missing" => Ok(VerificationDocumentAddressMissing),
447 "verification_document_corrupt" => Ok(VerificationDocumentCorrupt),
448 "verification_document_country_not_supported" => {
449 Ok(VerificationDocumentCountryNotSupported)
450 }
451 "verification_document_directors_mismatch" => Ok(VerificationDocumentDirectorsMismatch),
452 "verification_document_dob_mismatch" => Ok(VerificationDocumentDobMismatch),
453 "verification_document_duplicate_type" => Ok(VerificationDocumentDuplicateType),
454 "verification_document_expired" => Ok(VerificationDocumentExpired),
455 "verification_document_failed_copy" => Ok(VerificationDocumentFailedCopy),
456 "verification_document_failed_greyscale" => Ok(VerificationDocumentFailedGreyscale),
457 "verification_document_failed_other" => Ok(VerificationDocumentFailedOther),
458 "verification_document_failed_test_mode" => Ok(VerificationDocumentFailedTestMode),
459 "verification_document_fraudulent" => Ok(VerificationDocumentFraudulent),
460 "verification_document_id_number_mismatch" => Ok(VerificationDocumentIdNumberMismatch),
461 "verification_document_id_number_missing" => Ok(VerificationDocumentIdNumberMissing),
462 "verification_document_incomplete" => Ok(VerificationDocumentIncomplete),
463 "verification_document_invalid" => Ok(VerificationDocumentInvalid),
464 "verification_document_issue_or_expiry_date_missing" => {
465 Ok(VerificationDocumentIssueOrExpiryDateMissing)
466 }
467 "verification_document_manipulated" => Ok(VerificationDocumentManipulated),
468 "verification_document_missing_back" => Ok(VerificationDocumentMissingBack),
469 "verification_document_missing_front" => Ok(VerificationDocumentMissingFront),
470 "verification_document_name_mismatch" => Ok(VerificationDocumentNameMismatch),
471 "verification_document_name_missing" => Ok(VerificationDocumentNameMissing),
472 "verification_document_nationality_mismatch" => {
473 Ok(VerificationDocumentNationalityMismatch)
474 }
475 "verification_document_not_readable" => Ok(VerificationDocumentNotReadable),
476 "verification_document_not_signed" => Ok(VerificationDocumentNotSigned),
477 "verification_document_not_uploaded" => Ok(VerificationDocumentNotUploaded),
478 "verification_document_photo_mismatch" => Ok(VerificationDocumentPhotoMismatch),
479 "verification_document_too_large" => Ok(VerificationDocumentTooLarge),
480 "verification_document_type_not_supported" => Ok(VerificationDocumentTypeNotSupported),
481 "verification_extraneous_directors" => Ok(VerificationExtraneousDirectors),
482 "verification_failed_address_match" => Ok(VerificationFailedAddressMatch),
483 "verification_failed_authorizer_authority" => Ok(VerificationFailedAuthorizerAuthority),
484 "verification_failed_business_iec_number" => Ok(VerificationFailedBusinessIecNumber),
485 "verification_failed_document_match" => Ok(VerificationFailedDocumentMatch),
486 "verification_failed_id_number_match" => Ok(VerificationFailedIdNumberMatch),
487 "verification_failed_keyed_identity" => Ok(VerificationFailedKeyedIdentity),
488 "verification_failed_keyed_match" => Ok(VerificationFailedKeyedMatch),
489 "verification_failed_name_match" => Ok(VerificationFailedNameMatch),
490 "verification_failed_other" => Ok(VerificationFailedOther),
491 "verification_failed_representative_authority" => {
492 Ok(VerificationFailedRepresentativeAuthority)
493 }
494 "verification_failed_residential_address" => Ok(VerificationFailedResidentialAddress),
495 "verification_failed_tax_id_match" => Ok(VerificationFailedTaxIdMatch),
496 "verification_failed_tax_id_not_issued" => Ok(VerificationFailedTaxIdNotIssued),
497 "verification_legal_entity_structure_mismatch" => {
498 Ok(VerificationLegalEntityStructureMismatch)
499 }
500 "verification_missing_directors" => Ok(VerificationMissingDirectors),
501 "verification_missing_executives" => Ok(VerificationMissingExecutives),
502 "verification_missing_owners" => Ok(VerificationMissingOwners),
503 "verification_rejected_ownership_exemption_reason" => {
504 Ok(VerificationRejectedOwnershipExemptionReason)
505 }
506 "verification_requires_additional_memorandum_of_associations" => {
507 Ok(VerificationRequiresAdditionalMemorandumOfAssociations)
508 }
509 "verification_requires_additional_proof_of_registration" => {
510 Ok(VerificationRequiresAdditionalProofOfRegistration)
511 }
512 "verification_supportability" => Ok(VerificationSupportability),
513 v => Ok(Unknown(v.to_owned())),
514 }
515 }
516}
517impl std::fmt::Display for AccountRequirementsErrorCode {
518 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
519 f.write_str(self.as_str())
520 }
521}
522
523impl std::fmt::Debug for AccountRequirementsErrorCode {
524 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
525 f.write_str(self.as_str())
526 }
527}
528#[cfg(feature = "serialize")]
529impl serde::Serialize for AccountRequirementsErrorCode {
530 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
531 where
532 S: serde::Serializer,
533 {
534 serializer.serialize_str(self.as_str())
535 }
536}
537impl miniserde::Deserialize for AccountRequirementsErrorCode {
538 fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
539 crate::Place::new(out)
540 }
541}
542
543impl miniserde::de::Visitor for crate::Place<AccountRequirementsErrorCode> {
544 fn string(&mut self, s: &str) -> miniserde::Result<()> {
545 use std::str::FromStr;
546 self.out = Some(AccountRequirementsErrorCode::from_str(s).unwrap());
547 Ok(())
548 }
549}
550
551stripe_types::impl_from_val_with_from_str!(AccountRequirementsErrorCode);
552#[cfg(feature = "deserialize")]
553impl<'de> serde::Deserialize<'de> for AccountRequirementsErrorCode {
554 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
555 use std::str::FromStr;
556 let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
557 Ok(Self::from_str(&s).unwrap())
558 }
559}