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