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