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