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