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