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