stripe_shared/
account_requirements_error.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct AccountRequirementsError {
5    /// The code for the type of error.
6    pub code: AccountRequirementsErrorCode,
7    /// An informative message that indicates the error type and provides additional details about the error.
8    pub reason: String,
9    /// The specific user onboarding requirement field (in the requirements hash) that needs to be resolved.
10    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::{make_place, Deserialize, Result};
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<'a> Map for Builder<'a> {
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/// The code for the type of error.
120#[derive(Clone, Eq, PartialEq)]
121#[non_exhaustive]
122pub enum AccountRequirementsErrorCode {
123    InformationMissing,
124    InvalidAddressCityStatePostalCode,
125    InvalidAddressHighwayContractBox,
126    InvalidAddressPrivateMailbox,
127    InvalidBusinessProfileName,
128    InvalidBusinessProfileNameDenylisted,
129    InvalidCompanyNameDenylisted,
130    InvalidDobAgeOverMaximum,
131    InvalidDobAgeUnder18,
132    InvalidDobAgeUnderMinimum,
133    InvalidProductDescriptionLength,
134    InvalidProductDescriptionUrlMatch,
135    InvalidRepresentativeCountry,
136    InvalidSignator,
137    InvalidStatementDescriptorBusinessMismatch,
138    InvalidStatementDescriptorDenylisted,
139    InvalidStatementDescriptorLength,
140    InvalidStatementDescriptorPrefixDenylisted,
141    InvalidStatementDescriptorPrefixMismatch,
142    InvalidStreetAddress,
143    InvalidTaxId,
144    InvalidTaxIdFormat,
145    InvalidTosAcceptance,
146    InvalidUrlDenylisted,
147    InvalidUrlFormat,
148    InvalidUrlLength,
149    InvalidUrlWebPresenceDetected,
150    InvalidUrlWebsiteBusinessInformationMismatch,
151    InvalidUrlWebsiteEmpty,
152    InvalidUrlWebsiteInaccessible,
153    InvalidUrlWebsiteInaccessibleGeoblocked,
154    InvalidUrlWebsiteInaccessiblePasswordProtected,
155    InvalidUrlWebsiteIncomplete,
156    InvalidUrlWebsiteIncompleteCancellationPolicy,
157    InvalidUrlWebsiteIncompleteCustomerServiceDetails,
158    InvalidUrlWebsiteIncompleteLegalRestrictions,
159    InvalidUrlWebsiteIncompleteRefundPolicy,
160    InvalidUrlWebsiteIncompleteReturnPolicy,
161    InvalidUrlWebsiteIncompleteTermsAndConditions,
162    InvalidUrlWebsiteIncompleteUnderConstruction,
163    InvalidUrlWebsiteOther,
164    InvalidValueOther,
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    /// An unrecognized value from Stripe. Should not be used as a request parameter.
219    Unknown(String),
220}
221impl AccountRequirementsErrorCode {
222    pub fn as_str(&self) -> &str {
223        use AccountRequirementsErrorCode::*;
224        match self {
225            InformationMissing => "information_missing",
226            InvalidAddressCityStatePostalCode => "invalid_address_city_state_postal_code",
227            InvalidAddressHighwayContractBox => "invalid_address_highway_contract_box",
228            InvalidAddressPrivateMailbox => "invalid_address_private_mailbox",
229            InvalidBusinessProfileName => "invalid_business_profile_name",
230            InvalidBusinessProfileNameDenylisted => "invalid_business_profile_name_denylisted",
231            InvalidCompanyNameDenylisted => "invalid_company_name_denylisted",
232            InvalidDobAgeOverMaximum => "invalid_dob_age_over_maximum",
233            InvalidDobAgeUnder18 => "invalid_dob_age_under_18",
234            InvalidDobAgeUnderMinimum => "invalid_dob_age_under_minimum",
235            InvalidProductDescriptionLength => "invalid_product_description_length",
236            InvalidProductDescriptionUrlMatch => "invalid_product_description_url_match",
237            InvalidRepresentativeCountry => "invalid_representative_country",
238            InvalidSignator => "invalid_signator",
239            InvalidStatementDescriptorBusinessMismatch => {
240                "invalid_statement_descriptor_business_mismatch"
241            }
242            InvalidStatementDescriptorDenylisted => "invalid_statement_descriptor_denylisted",
243            InvalidStatementDescriptorLength => "invalid_statement_descriptor_length",
244            InvalidStatementDescriptorPrefixDenylisted => {
245                "invalid_statement_descriptor_prefix_denylisted"
246            }
247            InvalidStatementDescriptorPrefixMismatch => {
248                "invalid_statement_descriptor_prefix_mismatch"
249            }
250            InvalidStreetAddress => "invalid_street_address",
251            InvalidTaxId => "invalid_tax_id",
252            InvalidTaxIdFormat => "invalid_tax_id_format",
253            InvalidTosAcceptance => "invalid_tos_acceptance",
254            InvalidUrlDenylisted => "invalid_url_denylisted",
255            InvalidUrlFormat => "invalid_url_format",
256            InvalidUrlLength => "invalid_url_length",
257            InvalidUrlWebPresenceDetected => "invalid_url_web_presence_detected",
258            InvalidUrlWebsiteBusinessInformationMismatch => {
259                "invalid_url_website_business_information_mismatch"
260            }
261            InvalidUrlWebsiteEmpty => "invalid_url_website_empty",
262            InvalidUrlWebsiteInaccessible => "invalid_url_website_inaccessible",
263            InvalidUrlWebsiteInaccessibleGeoblocked => {
264                "invalid_url_website_inaccessible_geoblocked"
265            }
266            InvalidUrlWebsiteInaccessiblePasswordProtected => {
267                "invalid_url_website_inaccessible_password_protected"
268            }
269            InvalidUrlWebsiteIncomplete => "invalid_url_website_incomplete",
270            InvalidUrlWebsiteIncompleteCancellationPolicy => {
271                "invalid_url_website_incomplete_cancellation_policy"
272            }
273            InvalidUrlWebsiteIncompleteCustomerServiceDetails => {
274                "invalid_url_website_incomplete_customer_service_details"
275            }
276            InvalidUrlWebsiteIncompleteLegalRestrictions => {
277                "invalid_url_website_incomplete_legal_restrictions"
278            }
279            InvalidUrlWebsiteIncompleteRefundPolicy => {
280                "invalid_url_website_incomplete_refund_policy"
281            }
282            InvalidUrlWebsiteIncompleteReturnPolicy => {
283                "invalid_url_website_incomplete_return_policy"
284            }
285            InvalidUrlWebsiteIncompleteTermsAndConditions => {
286                "invalid_url_website_incomplete_terms_and_conditions"
287            }
288            InvalidUrlWebsiteIncompleteUnderConstruction => {
289                "invalid_url_website_incomplete_under_construction"
290            }
291            InvalidUrlWebsiteOther => "invalid_url_website_other",
292            InvalidValueOther => "invalid_value_other",
293            VerificationDirectorsMismatch => "verification_directors_mismatch",
294            VerificationDocumentAddressMismatch => "verification_document_address_mismatch",
295            VerificationDocumentAddressMissing => "verification_document_address_missing",
296            VerificationDocumentCorrupt => "verification_document_corrupt",
297            VerificationDocumentCountryNotSupported => {
298                "verification_document_country_not_supported"
299            }
300            VerificationDocumentDirectorsMismatch => "verification_document_directors_mismatch",
301            VerificationDocumentDobMismatch => "verification_document_dob_mismatch",
302            VerificationDocumentDuplicateType => "verification_document_duplicate_type",
303            VerificationDocumentExpired => "verification_document_expired",
304            VerificationDocumentFailedCopy => "verification_document_failed_copy",
305            VerificationDocumentFailedGreyscale => "verification_document_failed_greyscale",
306            VerificationDocumentFailedOther => "verification_document_failed_other",
307            VerificationDocumentFailedTestMode => "verification_document_failed_test_mode",
308            VerificationDocumentFraudulent => "verification_document_fraudulent",
309            VerificationDocumentIdNumberMismatch => "verification_document_id_number_mismatch",
310            VerificationDocumentIdNumberMissing => "verification_document_id_number_missing",
311            VerificationDocumentIncomplete => "verification_document_incomplete",
312            VerificationDocumentInvalid => "verification_document_invalid",
313            VerificationDocumentIssueOrExpiryDateMissing => {
314                "verification_document_issue_or_expiry_date_missing"
315            }
316            VerificationDocumentManipulated => "verification_document_manipulated",
317            VerificationDocumentMissingBack => "verification_document_missing_back",
318            VerificationDocumentMissingFront => "verification_document_missing_front",
319            VerificationDocumentNameMismatch => "verification_document_name_mismatch",
320            VerificationDocumentNameMissing => "verification_document_name_missing",
321            VerificationDocumentNationalityMismatch => "verification_document_nationality_mismatch",
322            VerificationDocumentNotReadable => "verification_document_not_readable",
323            VerificationDocumentNotSigned => "verification_document_not_signed",
324            VerificationDocumentNotUploaded => "verification_document_not_uploaded",
325            VerificationDocumentPhotoMismatch => "verification_document_photo_mismatch",
326            VerificationDocumentTooLarge => "verification_document_too_large",
327            VerificationDocumentTypeNotSupported => "verification_document_type_not_supported",
328            VerificationExtraneousDirectors => "verification_extraneous_directors",
329            VerificationFailedAddressMatch => "verification_failed_address_match",
330            VerificationFailedAuthorizerAuthority => "verification_failed_authorizer_authority",
331            VerificationFailedBusinessIecNumber => "verification_failed_business_iec_number",
332            VerificationFailedDocumentMatch => "verification_failed_document_match",
333            VerificationFailedIdNumberMatch => "verification_failed_id_number_match",
334            VerificationFailedKeyedIdentity => "verification_failed_keyed_identity",
335            VerificationFailedKeyedMatch => "verification_failed_keyed_match",
336            VerificationFailedNameMatch => "verification_failed_name_match",
337            VerificationFailedOther => "verification_failed_other",
338            VerificationFailedRepresentativeAuthority => {
339                "verification_failed_representative_authority"
340            }
341            VerificationFailedResidentialAddress => "verification_failed_residential_address",
342            VerificationFailedTaxIdMatch => "verification_failed_tax_id_match",
343            VerificationFailedTaxIdNotIssued => "verification_failed_tax_id_not_issued",
344            VerificationLegalEntityStructureMismatch => {
345                "verification_legal_entity_structure_mismatch"
346            }
347            VerificationMissingDirectors => "verification_missing_directors",
348            VerificationMissingExecutives => "verification_missing_executives",
349            VerificationMissingOwners => "verification_missing_owners",
350            VerificationRejectedOwnershipExemptionReason => {
351                "verification_rejected_ownership_exemption_reason"
352            }
353            VerificationRequiresAdditionalMemorandumOfAssociations => {
354                "verification_requires_additional_memorandum_of_associations"
355            }
356            VerificationRequiresAdditionalProofOfRegistration => {
357                "verification_requires_additional_proof_of_registration"
358            }
359            VerificationSupportability => "verification_supportability",
360            Unknown(v) => v,
361        }
362    }
363}
364
365impl std::str::FromStr for AccountRequirementsErrorCode {
366    type Err = std::convert::Infallible;
367    fn from_str(s: &str) -> Result<Self, Self::Err> {
368        use AccountRequirementsErrorCode::*;
369        match s {
370            "information_missing" => Ok(InformationMissing),
371            "invalid_address_city_state_postal_code" => Ok(InvalidAddressCityStatePostalCode),
372            "invalid_address_highway_contract_box" => Ok(InvalidAddressHighwayContractBox),
373            "invalid_address_private_mailbox" => Ok(InvalidAddressPrivateMailbox),
374            "invalid_business_profile_name" => Ok(InvalidBusinessProfileName),
375            "invalid_business_profile_name_denylisted" => Ok(InvalidBusinessProfileNameDenylisted),
376            "invalid_company_name_denylisted" => Ok(InvalidCompanyNameDenylisted),
377            "invalid_dob_age_over_maximum" => Ok(InvalidDobAgeOverMaximum),
378            "invalid_dob_age_under_18" => Ok(InvalidDobAgeUnder18),
379            "invalid_dob_age_under_minimum" => Ok(InvalidDobAgeUnderMinimum),
380            "invalid_product_description_length" => Ok(InvalidProductDescriptionLength),
381            "invalid_product_description_url_match" => Ok(InvalidProductDescriptionUrlMatch),
382            "invalid_representative_country" => Ok(InvalidRepresentativeCountry),
383            "invalid_signator" => Ok(InvalidSignator),
384            "invalid_statement_descriptor_business_mismatch" => {
385                Ok(InvalidStatementDescriptorBusinessMismatch)
386            }
387            "invalid_statement_descriptor_denylisted" => Ok(InvalidStatementDescriptorDenylisted),
388            "invalid_statement_descriptor_length" => Ok(InvalidStatementDescriptorLength),
389            "invalid_statement_descriptor_prefix_denylisted" => {
390                Ok(InvalidStatementDescriptorPrefixDenylisted)
391            }
392            "invalid_statement_descriptor_prefix_mismatch" => {
393                Ok(InvalidStatementDescriptorPrefixMismatch)
394            }
395            "invalid_street_address" => Ok(InvalidStreetAddress),
396            "invalid_tax_id" => Ok(InvalidTaxId),
397            "invalid_tax_id_format" => Ok(InvalidTaxIdFormat),
398            "invalid_tos_acceptance" => Ok(InvalidTosAcceptance),
399            "invalid_url_denylisted" => Ok(InvalidUrlDenylisted),
400            "invalid_url_format" => Ok(InvalidUrlFormat),
401            "invalid_url_length" => Ok(InvalidUrlLength),
402            "invalid_url_web_presence_detected" => Ok(InvalidUrlWebPresenceDetected),
403            "invalid_url_website_business_information_mismatch" => {
404                Ok(InvalidUrlWebsiteBusinessInformationMismatch)
405            }
406            "invalid_url_website_empty" => Ok(InvalidUrlWebsiteEmpty),
407            "invalid_url_website_inaccessible" => Ok(InvalidUrlWebsiteInaccessible),
408            "invalid_url_website_inaccessible_geoblocked" => {
409                Ok(InvalidUrlWebsiteInaccessibleGeoblocked)
410            }
411            "invalid_url_website_inaccessible_password_protected" => {
412                Ok(InvalidUrlWebsiteInaccessiblePasswordProtected)
413            }
414            "invalid_url_website_incomplete" => Ok(InvalidUrlWebsiteIncomplete),
415            "invalid_url_website_incomplete_cancellation_policy" => {
416                Ok(InvalidUrlWebsiteIncompleteCancellationPolicy)
417            }
418            "invalid_url_website_incomplete_customer_service_details" => {
419                Ok(InvalidUrlWebsiteIncompleteCustomerServiceDetails)
420            }
421            "invalid_url_website_incomplete_legal_restrictions" => {
422                Ok(InvalidUrlWebsiteIncompleteLegalRestrictions)
423            }
424            "invalid_url_website_incomplete_refund_policy" => {
425                Ok(InvalidUrlWebsiteIncompleteRefundPolicy)
426            }
427            "invalid_url_website_incomplete_return_policy" => {
428                Ok(InvalidUrlWebsiteIncompleteReturnPolicy)
429            }
430            "invalid_url_website_incomplete_terms_and_conditions" => {
431                Ok(InvalidUrlWebsiteIncompleteTermsAndConditions)
432            }
433            "invalid_url_website_incomplete_under_construction" => {
434                Ok(InvalidUrlWebsiteIncompleteUnderConstruction)
435            }
436            "invalid_url_website_other" => Ok(InvalidUrlWebsiteOther),
437            "invalid_value_other" => Ok(InvalidValueOther),
438            "verification_directors_mismatch" => Ok(VerificationDirectorsMismatch),
439            "verification_document_address_mismatch" => Ok(VerificationDocumentAddressMismatch),
440            "verification_document_address_missing" => Ok(VerificationDocumentAddressMissing),
441            "verification_document_corrupt" => Ok(VerificationDocumentCorrupt),
442            "verification_document_country_not_supported" => {
443                Ok(VerificationDocumentCountryNotSupported)
444            }
445            "verification_document_directors_mismatch" => Ok(VerificationDocumentDirectorsMismatch),
446            "verification_document_dob_mismatch" => Ok(VerificationDocumentDobMismatch),
447            "verification_document_duplicate_type" => Ok(VerificationDocumentDuplicateType),
448            "verification_document_expired" => Ok(VerificationDocumentExpired),
449            "verification_document_failed_copy" => Ok(VerificationDocumentFailedCopy),
450            "verification_document_failed_greyscale" => Ok(VerificationDocumentFailedGreyscale),
451            "verification_document_failed_other" => Ok(VerificationDocumentFailedOther),
452            "verification_document_failed_test_mode" => Ok(VerificationDocumentFailedTestMode),
453            "verification_document_fraudulent" => Ok(VerificationDocumentFraudulent),
454            "verification_document_id_number_mismatch" => Ok(VerificationDocumentIdNumberMismatch),
455            "verification_document_id_number_missing" => Ok(VerificationDocumentIdNumberMissing),
456            "verification_document_incomplete" => Ok(VerificationDocumentIncomplete),
457            "verification_document_invalid" => Ok(VerificationDocumentInvalid),
458            "verification_document_issue_or_expiry_date_missing" => {
459                Ok(VerificationDocumentIssueOrExpiryDateMissing)
460            }
461            "verification_document_manipulated" => Ok(VerificationDocumentManipulated),
462            "verification_document_missing_back" => Ok(VerificationDocumentMissingBack),
463            "verification_document_missing_front" => Ok(VerificationDocumentMissingFront),
464            "verification_document_name_mismatch" => Ok(VerificationDocumentNameMismatch),
465            "verification_document_name_missing" => Ok(VerificationDocumentNameMissing),
466            "verification_document_nationality_mismatch" => {
467                Ok(VerificationDocumentNationalityMismatch)
468            }
469            "verification_document_not_readable" => Ok(VerificationDocumentNotReadable),
470            "verification_document_not_signed" => Ok(VerificationDocumentNotSigned),
471            "verification_document_not_uploaded" => Ok(VerificationDocumentNotUploaded),
472            "verification_document_photo_mismatch" => Ok(VerificationDocumentPhotoMismatch),
473            "verification_document_too_large" => Ok(VerificationDocumentTooLarge),
474            "verification_document_type_not_supported" => Ok(VerificationDocumentTypeNotSupported),
475            "verification_extraneous_directors" => Ok(VerificationExtraneousDirectors),
476            "verification_failed_address_match" => Ok(VerificationFailedAddressMatch),
477            "verification_failed_authorizer_authority" => Ok(VerificationFailedAuthorizerAuthority),
478            "verification_failed_business_iec_number" => Ok(VerificationFailedBusinessIecNumber),
479            "verification_failed_document_match" => Ok(VerificationFailedDocumentMatch),
480            "verification_failed_id_number_match" => Ok(VerificationFailedIdNumberMatch),
481            "verification_failed_keyed_identity" => Ok(VerificationFailedKeyedIdentity),
482            "verification_failed_keyed_match" => Ok(VerificationFailedKeyedMatch),
483            "verification_failed_name_match" => Ok(VerificationFailedNameMatch),
484            "verification_failed_other" => Ok(VerificationFailedOther),
485            "verification_failed_representative_authority" => {
486                Ok(VerificationFailedRepresentativeAuthority)
487            }
488            "verification_failed_residential_address" => Ok(VerificationFailedResidentialAddress),
489            "verification_failed_tax_id_match" => Ok(VerificationFailedTaxIdMatch),
490            "verification_failed_tax_id_not_issued" => Ok(VerificationFailedTaxIdNotIssued),
491            "verification_legal_entity_structure_mismatch" => {
492                Ok(VerificationLegalEntityStructureMismatch)
493            }
494            "verification_missing_directors" => Ok(VerificationMissingDirectors),
495            "verification_missing_executives" => Ok(VerificationMissingExecutives),
496            "verification_missing_owners" => Ok(VerificationMissingOwners),
497            "verification_rejected_ownership_exemption_reason" => {
498                Ok(VerificationRejectedOwnershipExemptionReason)
499            }
500            "verification_requires_additional_memorandum_of_associations" => {
501                Ok(VerificationRequiresAdditionalMemorandumOfAssociations)
502            }
503            "verification_requires_additional_proof_of_registration" => {
504                Ok(VerificationRequiresAdditionalProofOfRegistration)
505            }
506            "verification_supportability" => Ok(VerificationSupportability),
507            v => Ok(Unknown(v.to_owned())),
508        }
509    }
510}
511impl std::fmt::Display for AccountRequirementsErrorCode {
512    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
513        f.write_str(self.as_str())
514    }
515}
516
517impl std::fmt::Debug for AccountRequirementsErrorCode {
518    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
519        f.write_str(self.as_str())
520    }
521}
522#[cfg(feature = "serialize")]
523impl serde::Serialize for AccountRequirementsErrorCode {
524    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
525    where
526        S: serde::Serializer,
527    {
528        serializer.serialize_str(self.as_str())
529    }
530}
531impl miniserde::Deserialize for AccountRequirementsErrorCode {
532    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
533        crate::Place::new(out)
534    }
535}
536
537impl miniserde::de::Visitor for crate::Place<AccountRequirementsErrorCode> {
538    fn string(&mut self, s: &str) -> miniserde::Result<()> {
539        use std::str::FromStr;
540        self.out = Some(AccountRequirementsErrorCode::from_str(s).unwrap());
541        Ok(())
542    }
543}
544
545stripe_types::impl_from_val_with_from_str!(AccountRequirementsErrorCode);
546#[cfg(feature = "deserialize")]
547impl<'de> serde::Deserialize<'de> for AccountRequirementsErrorCode {
548    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
549        use std::str::FromStr;
550        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
551        Ok(Self::from_str(&s).unwrap())
552    }
553}