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