1#[derive(Clone, Debug)]
8#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
9pub struct TaxId {
10 pub country: Option<String>,
12 pub created: stripe_types::Timestamp,
14 pub customer: Option<stripe_types::Expandable<stripe_shared::Customer>>,
16 pub customer_account: Option<String>,
18 pub id: stripe_shared::TaxIdId,
20 pub livemode: bool,
22 pub owner: Option<stripe_shared::TaxIDsOwner>,
24 #[cfg_attr(feature = "deserialize", serde(rename = "type"))]
27 pub type_: TaxIdType,
28 pub value: String,
30 pub verification: Option<stripe_shared::TaxIdVerification>,
32}
33#[doc(hidden)]
34pub struct TaxIdBuilder {
35 country: Option<Option<String>>,
36 created: Option<stripe_types::Timestamp>,
37 customer: Option<Option<stripe_types::Expandable<stripe_shared::Customer>>>,
38 customer_account: Option<Option<String>>,
39 id: Option<stripe_shared::TaxIdId>,
40 livemode: Option<bool>,
41 owner: Option<Option<stripe_shared::TaxIDsOwner>>,
42 type_: Option<TaxIdType>,
43 value: Option<String>,
44 verification: Option<Option<stripe_shared::TaxIdVerification>>,
45}
46
47#[allow(
48 unused_variables,
49 irrefutable_let_patterns,
50 clippy::let_unit_value,
51 clippy::match_single_binding,
52 clippy::single_match
53)]
54const _: () = {
55 use miniserde::de::{Map, Visitor};
56 use miniserde::json::Value;
57 use miniserde::{Deserialize, Result, make_place};
58 use stripe_types::miniserde_helpers::FromValueOpt;
59 use stripe_types::{MapBuilder, ObjectDeser};
60
61 make_place!(Place);
62
63 impl Deserialize for TaxId {
64 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
65 Place::new(out)
66 }
67 }
68
69 struct Builder<'a> {
70 out: &'a mut Option<TaxId>,
71 builder: TaxIdBuilder,
72 }
73
74 impl Visitor for Place<TaxId> {
75 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
76 Ok(Box::new(Builder { out: &mut self.out, builder: TaxIdBuilder::deser_default() }))
77 }
78 }
79
80 impl MapBuilder for TaxIdBuilder {
81 type Out = TaxId;
82 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
83 Ok(match k {
84 "country" => Deserialize::begin(&mut self.country),
85 "created" => Deserialize::begin(&mut self.created),
86 "customer" => Deserialize::begin(&mut self.customer),
87 "customer_account" => Deserialize::begin(&mut self.customer_account),
88 "id" => Deserialize::begin(&mut self.id),
89 "livemode" => Deserialize::begin(&mut self.livemode),
90 "owner" => Deserialize::begin(&mut self.owner),
91 "type" => Deserialize::begin(&mut self.type_),
92 "value" => Deserialize::begin(&mut self.value),
93 "verification" => Deserialize::begin(&mut self.verification),
94 _ => <dyn Visitor>::ignore(),
95 })
96 }
97
98 fn deser_default() -> Self {
99 Self {
100 country: Deserialize::default(),
101 created: Deserialize::default(),
102 customer: Deserialize::default(),
103 customer_account: Deserialize::default(),
104 id: Deserialize::default(),
105 livemode: Deserialize::default(),
106 owner: Deserialize::default(),
107 type_: Deserialize::default(),
108 value: Deserialize::default(),
109 verification: Deserialize::default(),
110 }
111 }
112
113 fn take_out(&mut self) -> Option<Self::Out> {
114 let (
115 Some(country),
116 Some(created),
117 Some(customer),
118 Some(customer_account),
119 Some(id),
120 Some(livemode),
121 Some(owner),
122 Some(type_),
123 Some(value),
124 Some(verification),
125 ) = (
126 self.country.take(),
127 self.created,
128 self.customer.take(),
129 self.customer_account.take(),
130 self.id.take(),
131 self.livemode,
132 self.owner.take(),
133 self.type_.take(),
134 self.value.take(),
135 self.verification.take(),
136 )
137 else {
138 return None;
139 };
140 Some(Self::Out {
141 country,
142 created,
143 customer,
144 customer_account,
145 id,
146 livemode,
147 owner,
148 type_,
149 value,
150 verification,
151 })
152 }
153 }
154
155 impl Map for Builder<'_> {
156 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
157 self.builder.key(k)
158 }
159
160 fn finish(&mut self) -> Result<()> {
161 *self.out = self.builder.take_out();
162 Ok(())
163 }
164 }
165
166 impl ObjectDeser for TaxId {
167 type Builder = TaxIdBuilder;
168 }
169
170 impl FromValueOpt for TaxId {
171 fn from_value(v: Value) -> Option<Self> {
172 let Value::Object(obj) = v else {
173 return None;
174 };
175 let mut b = TaxIdBuilder::deser_default();
176 for (k, v) in obj {
177 match k.as_str() {
178 "country" => b.country = FromValueOpt::from_value(v),
179 "created" => b.created = FromValueOpt::from_value(v),
180 "customer" => b.customer = FromValueOpt::from_value(v),
181 "customer_account" => b.customer_account = FromValueOpt::from_value(v),
182 "id" => b.id = FromValueOpt::from_value(v),
183 "livemode" => b.livemode = FromValueOpt::from_value(v),
184 "owner" => b.owner = FromValueOpt::from_value(v),
185 "type" => b.type_ = FromValueOpt::from_value(v),
186 "value" => b.value = FromValueOpt::from_value(v),
187 "verification" => b.verification = FromValueOpt::from_value(v),
188 _ => {}
189 }
190 }
191 b.take_out()
192 }
193 }
194};
195#[cfg(feature = "serialize")]
196impl serde::Serialize for TaxId {
197 fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
198 use serde::ser::SerializeStruct;
199 let mut s = s.serialize_struct("TaxId", 11)?;
200 s.serialize_field("country", &self.country)?;
201 s.serialize_field("created", &self.created)?;
202 s.serialize_field("customer", &self.customer)?;
203 s.serialize_field("customer_account", &self.customer_account)?;
204 s.serialize_field("id", &self.id)?;
205 s.serialize_field("livemode", &self.livemode)?;
206 s.serialize_field("owner", &self.owner)?;
207 s.serialize_field("type", &self.type_)?;
208 s.serialize_field("value", &self.value)?;
209 s.serialize_field("verification", &self.verification)?;
210
211 s.serialize_field("object", "tax_id")?;
212 s.end()
213 }
214}
215#[derive(Clone, Eq, PartialEq)]
218#[non_exhaustive]
219pub enum TaxIdType {
220 AdNrt,
221 AeTrn,
222 AlTin,
223 AmTin,
224 AoTin,
225 ArCuit,
226 AuAbn,
227 AuArn,
228 AwTin,
229 AzTin,
230 BaTin,
231 BbTin,
232 BdBin,
233 BfIfu,
234 BgUic,
235 BhVat,
236 BjIfu,
237 BoTin,
238 BrCnpj,
239 BrCpf,
240 BsTin,
241 ByTin,
242 CaBn,
243 CaGstHst,
244 CaPstBc,
245 CaPstMb,
246 CaPstSk,
247 CaQst,
248 CdNif,
249 ChUid,
250 ChVat,
251 ClTin,
252 CmNiu,
253 CnTin,
254 CoNit,
255 CrTin,
256 CvNif,
257 DeStn,
258 DoRcn,
259 EcRuc,
260 EgTin,
261 EsCif,
262 EtTin,
263 EuOssVat,
264 EuVat,
265 GbVat,
266 GeVat,
267 GnNif,
268 HkBr,
269 HrOib,
270 HuTin,
271 IdNpwp,
272 IlVat,
273 InGst,
274 IsVat,
275 JpCn,
276 JpRn,
277 JpTrn,
278 KePin,
279 KgTin,
280 KhTin,
281 KrBrn,
282 KzBin,
283 LaTin,
284 LiUid,
285 LiVat,
286 MaVat,
287 MdVat,
288 MePib,
289 MkVat,
290 MrNif,
291 MxRfc,
292 MyFrp,
293 MyItn,
294 MySst,
295 NgTin,
296 NoVat,
297 NoVoec,
298 NpPan,
299 NzGst,
300 OmVat,
301 PeRuc,
302 PhTin,
303 RoTin,
304 RsPib,
305 RuInn,
306 RuKpp,
307 SaVat,
308 SgGst,
309 SgUen,
310 SiTin,
311 SnNinea,
312 SrFin,
313 SvNit,
314 ThVat,
315 TjTin,
316 TrTin,
317 TwVat,
318 TzVat,
319 UaVat,
320 UgTin,
321 Unknown,
322 UsEin,
323 UyRuc,
324 UzTin,
325 UzVat,
326 VeRif,
327 VnTin,
328 ZaVat,
329 ZmTin,
330 ZwTin,
331 _Unknown(String),
334}
335impl TaxIdType {
336 pub fn as_str(&self) -> &str {
337 use TaxIdType::*;
338 match self {
339 AdNrt => "ad_nrt",
340 AeTrn => "ae_trn",
341 AlTin => "al_tin",
342 AmTin => "am_tin",
343 AoTin => "ao_tin",
344 ArCuit => "ar_cuit",
345 AuAbn => "au_abn",
346 AuArn => "au_arn",
347 AwTin => "aw_tin",
348 AzTin => "az_tin",
349 BaTin => "ba_tin",
350 BbTin => "bb_tin",
351 BdBin => "bd_bin",
352 BfIfu => "bf_ifu",
353 BgUic => "bg_uic",
354 BhVat => "bh_vat",
355 BjIfu => "bj_ifu",
356 BoTin => "bo_tin",
357 BrCnpj => "br_cnpj",
358 BrCpf => "br_cpf",
359 BsTin => "bs_tin",
360 ByTin => "by_tin",
361 CaBn => "ca_bn",
362 CaGstHst => "ca_gst_hst",
363 CaPstBc => "ca_pst_bc",
364 CaPstMb => "ca_pst_mb",
365 CaPstSk => "ca_pst_sk",
366 CaQst => "ca_qst",
367 CdNif => "cd_nif",
368 ChUid => "ch_uid",
369 ChVat => "ch_vat",
370 ClTin => "cl_tin",
371 CmNiu => "cm_niu",
372 CnTin => "cn_tin",
373 CoNit => "co_nit",
374 CrTin => "cr_tin",
375 CvNif => "cv_nif",
376 DeStn => "de_stn",
377 DoRcn => "do_rcn",
378 EcRuc => "ec_ruc",
379 EgTin => "eg_tin",
380 EsCif => "es_cif",
381 EtTin => "et_tin",
382 EuOssVat => "eu_oss_vat",
383 EuVat => "eu_vat",
384 GbVat => "gb_vat",
385 GeVat => "ge_vat",
386 GnNif => "gn_nif",
387 HkBr => "hk_br",
388 HrOib => "hr_oib",
389 HuTin => "hu_tin",
390 IdNpwp => "id_npwp",
391 IlVat => "il_vat",
392 InGst => "in_gst",
393 IsVat => "is_vat",
394 JpCn => "jp_cn",
395 JpRn => "jp_rn",
396 JpTrn => "jp_trn",
397 KePin => "ke_pin",
398 KgTin => "kg_tin",
399 KhTin => "kh_tin",
400 KrBrn => "kr_brn",
401 KzBin => "kz_bin",
402 LaTin => "la_tin",
403 LiUid => "li_uid",
404 LiVat => "li_vat",
405 MaVat => "ma_vat",
406 MdVat => "md_vat",
407 MePib => "me_pib",
408 MkVat => "mk_vat",
409 MrNif => "mr_nif",
410 MxRfc => "mx_rfc",
411 MyFrp => "my_frp",
412 MyItn => "my_itn",
413 MySst => "my_sst",
414 NgTin => "ng_tin",
415 NoVat => "no_vat",
416 NoVoec => "no_voec",
417 NpPan => "np_pan",
418 NzGst => "nz_gst",
419 OmVat => "om_vat",
420 PeRuc => "pe_ruc",
421 PhTin => "ph_tin",
422 RoTin => "ro_tin",
423 RsPib => "rs_pib",
424 RuInn => "ru_inn",
425 RuKpp => "ru_kpp",
426 SaVat => "sa_vat",
427 SgGst => "sg_gst",
428 SgUen => "sg_uen",
429 SiTin => "si_tin",
430 SnNinea => "sn_ninea",
431 SrFin => "sr_fin",
432 SvNit => "sv_nit",
433 ThVat => "th_vat",
434 TjTin => "tj_tin",
435 TrTin => "tr_tin",
436 TwVat => "tw_vat",
437 TzVat => "tz_vat",
438 UaVat => "ua_vat",
439 UgTin => "ug_tin",
440 Unknown => "unknown",
441 UsEin => "us_ein",
442 UyRuc => "uy_ruc",
443 UzTin => "uz_tin",
444 UzVat => "uz_vat",
445 VeRif => "ve_rif",
446 VnTin => "vn_tin",
447 ZaVat => "za_vat",
448 ZmTin => "zm_tin",
449 ZwTin => "zw_tin",
450 _Unknown(v) => v,
451 }
452 }
453}
454
455impl std::str::FromStr for TaxIdType {
456 type Err = std::convert::Infallible;
457 fn from_str(s: &str) -> Result<Self, Self::Err> {
458 use TaxIdType::*;
459 match s {
460 "ad_nrt" => Ok(AdNrt),
461 "ae_trn" => Ok(AeTrn),
462 "al_tin" => Ok(AlTin),
463 "am_tin" => Ok(AmTin),
464 "ao_tin" => Ok(AoTin),
465 "ar_cuit" => Ok(ArCuit),
466 "au_abn" => Ok(AuAbn),
467 "au_arn" => Ok(AuArn),
468 "aw_tin" => Ok(AwTin),
469 "az_tin" => Ok(AzTin),
470 "ba_tin" => Ok(BaTin),
471 "bb_tin" => Ok(BbTin),
472 "bd_bin" => Ok(BdBin),
473 "bf_ifu" => Ok(BfIfu),
474 "bg_uic" => Ok(BgUic),
475 "bh_vat" => Ok(BhVat),
476 "bj_ifu" => Ok(BjIfu),
477 "bo_tin" => Ok(BoTin),
478 "br_cnpj" => Ok(BrCnpj),
479 "br_cpf" => Ok(BrCpf),
480 "bs_tin" => Ok(BsTin),
481 "by_tin" => Ok(ByTin),
482 "ca_bn" => Ok(CaBn),
483 "ca_gst_hst" => Ok(CaGstHst),
484 "ca_pst_bc" => Ok(CaPstBc),
485 "ca_pst_mb" => Ok(CaPstMb),
486 "ca_pst_sk" => Ok(CaPstSk),
487 "ca_qst" => Ok(CaQst),
488 "cd_nif" => Ok(CdNif),
489 "ch_uid" => Ok(ChUid),
490 "ch_vat" => Ok(ChVat),
491 "cl_tin" => Ok(ClTin),
492 "cm_niu" => Ok(CmNiu),
493 "cn_tin" => Ok(CnTin),
494 "co_nit" => Ok(CoNit),
495 "cr_tin" => Ok(CrTin),
496 "cv_nif" => Ok(CvNif),
497 "de_stn" => Ok(DeStn),
498 "do_rcn" => Ok(DoRcn),
499 "ec_ruc" => Ok(EcRuc),
500 "eg_tin" => Ok(EgTin),
501 "es_cif" => Ok(EsCif),
502 "et_tin" => Ok(EtTin),
503 "eu_oss_vat" => Ok(EuOssVat),
504 "eu_vat" => Ok(EuVat),
505 "gb_vat" => Ok(GbVat),
506 "ge_vat" => Ok(GeVat),
507 "gn_nif" => Ok(GnNif),
508 "hk_br" => Ok(HkBr),
509 "hr_oib" => Ok(HrOib),
510 "hu_tin" => Ok(HuTin),
511 "id_npwp" => Ok(IdNpwp),
512 "il_vat" => Ok(IlVat),
513 "in_gst" => Ok(InGst),
514 "is_vat" => Ok(IsVat),
515 "jp_cn" => Ok(JpCn),
516 "jp_rn" => Ok(JpRn),
517 "jp_trn" => Ok(JpTrn),
518 "ke_pin" => Ok(KePin),
519 "kg_tin" => Ok(KgTin),
520 "kh_tin" => Ok(KhTin),
521 "kr_brn" => Ok(KrBrn),
522 "kz_bin" => Ok(KzBin),
523 "la_tin" => Ok(LaTin),
524 "li_uid" => Ok(LiUid),
525 "li_vat" => Ok(LiVat),
526 "ma_vat" => Ok(MaVat),
527 "md_vat" => Ok(MdVat),
528 "me_pib" => Ok(MePib),
529 "mk_vat" => Ok(MkVat),
530 "mr_nif" => Ok(MrNif),
531 "mx_rfc" => Ok(MxRfc),
532 "my_frp" => Ok(MyFrp),
533 "my_itn" => Ok(MyItn),
534 "my_sst" => Ok(MySst),
535 "ng_tin" => Ok(NgTin),
536 "no_vat" => Ok(NoVat),
537 "no_voec" => Ok(NoVoec),
538 "np_pan" => Ok(NpPan),
539 "nz_gst" => Ok(NzGst),
540 "om_vat" => Ok(OmVat),
541 "pe_ruc" => Ok(PeRuc),
542 "ph_tin" => Ok(PhTin),
543 "ro_tin" => Ok(RoTin),
544 "rs_pib" => Ok(RsPib),
545 "ru_inn" => Ok(RuInn),
546 "ru_kpp" => Ok(RuKpp),
547 "sa_vat" => Ok(SaVat),
548 "sg_gst" => Ok(SgGst),
549 "sg_uen" => Ok(SgUen),
550 "si_tin" => Ok(SiTin),
551 "sn_ninea" => Ok(SnNinea),
552 "sr_fin" => Ok(SrFin),
553 "sv_nit" => Ok(SvNit),
554 "th_vat" => Ok(ThVat),
555 "tj_tin" => Ok(TjTin),
556 "tr_tin" => Ok(TrTin),
557 "tw_vat" => Ok(TwVat),
558 "tz_vat" => Ok(TzVat),
559 "ua_vat" => Ok(UaVat),
560 "ug_tin" => Ok(UgTin),
561 "unknown" => Ok(Unknown),
562 "us_ein" => Ok(UsEin),
563 "uy_ruc" => Ok(UyRuc),
564 "uz_tin" => Ok(UzTin),
565 "uz_vat" => Ok(UzVat),
566 "ve_rif" => Ok(VeRif),
567 "vn_tin" => Ok(VnTin),
568 "za_vat" => Ok(ZaVat),
569 "zm_tin" => Ok(ZmTin),
570 "zw_tin" => Ok(ZwTin),
571 v => {
572 tracing::warn!("Unknown value '{}' for enum '{}'", v, "TaxIdType");
573 Ok(_Unknown(v.to_owned()))
574 }
575 }
576 }
577}
578impl std::fmt::Display for TaxIdType {
579 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
580 f.write_str(self.as_str())
581 }
582}
583
584impl std::fmt::Debug for TaxIdType {
585 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
586 f.write_str(self.as_str())
587 }
588}
589#[cfg(feature = "serialize")]
590impl serde::Serialize for TaxIdType {
591 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
592 where
593 S: serde::Serializer,
594 {
595 serializer.serialize_str(self.as_str())
596 }
597}
598impl miniserde::Deserialize for TaxIdType {
599 fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
600 crate::Place::new(out)
601 }
602}
603
604impl miniserde::de::Visitor for crate::Place<TaxIdType> {
605 fn string(&mut self, s: &str) -> miniserde::Result<()> {
606 use std::str::FromStr;
607 self.out = Some(TaxIdType::from_str(s).expect("infallible"));
608 Ok(())
609 }
610}
611
612stripe_types::impl_from_val_with_from_str!(TaxIdType);
613#[cfg(feature = "deserialize")]
614impl<'de> serde::Deserialize<'de> for TaxIdType {
615 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
616 use std::str::FromStr;
617 let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
618 Ok(Self::from_str(&s).expect("infallible"))
619 }
620}
621impl stripe_types::Object for TaxId {
622 type Id = stripe_shared::TaxIdId;
623 fn id(&self) -> &Self::Id {
624 &self.id
625 }
626
627 fn into_id(self) -> Self::Id {
628 self.id
629 }
630}
631stripe_types::def_id!(TaxIdId);