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