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