1#[derive(Clone, Eq, PartialEq)]
2#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
3#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
4#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
5pub struct PaymentPagesCheckoutSessionShippingAddressCollection {
6 pub allowed_countries:
10 Vec<PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries>,
11}
12#[cfg(feature = "redact-generated-debug")]
13impl std::fmt::Debug for PaymentPagesCheckoutSessionShippingAddressCollection {
14 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15 f.debug_struct("PaymentPagesCheckoutSessionShippingAddressCollection")
16 .finish_non_exhaustive()
17 }
18}
19#[doc(hidden)]
20pub struct PaymentPagesCheckoutSessionShippingAddressCollectionBuilder {
21 allowed_countries:
22 Option<Vec<PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries>>,
23}
24
25#[allow(
26 unused_variables,
27 irrefutable_let_patterns,
28 clippy::let_unit_value,
29 clippy::match_single_binding,
30 clippy::single_match
31)]
32const _: () = {
33 use miniserde::de::{Map, Visitor};
34 use miniserde::json::Value;
35 use miniserde::{Deserialize, Result, make_place};
36 use stripe_types::miniserde_helpers::FromValueOpt;
37 use stripe_types::{MapBuilder, ObjectDeser};
38
39 make_place!(Place);
40
41 impl Deserialize for PaymentPagesCheckoutSessionShippingAddressCollection {
42 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
43 Place::new(out)
44 }
45 }
46
47 struct Builder<'a> {
48 out: &'a mut Option<PaymentPagesCheckoutSessionShippingAddressCollection>,
49 builder: PaymentPagesCheckoutSessionShippingAddressCollectionBuilder,
50 }
51
52 impl Visitor for Place<PaymentPagesCheckoutSessionShippingAddressCollection> {
53 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
54 Ok(Box::new(Builder {
55 out: &mut self.out,
56 builder: PaymentPagesCheckoutSessionShippingAddressCollectionBuilder::deser_default(
57 ),
58 }))
59 }
60 }
61
62 impl MapBuilder for PaymentPagesCheckoutSessionShippingAddressCollectionBuilder {
63 type Out = PaymentPagesCheckoutSessionShippingAddressCollection;
64 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
65 Ok(match k {
66 "allowed_countries" => Deserialize::begin(&mut self.allowed_countries),
67 _ => <dyn Visitor>::ignore(),
68 })
69 }
70
71 fn deser_default() -> Self {
72 Self { allowed_countries: None }
73 }
74
75 fn take_out(&mut self) -> Option<Self::Out> {
76 let (Some(allowed_countries),) = (self.allowed_countries.take(),) else {
77 return None;
78 };
79 Some(Self::Out { allowed_countries })
80 }
81 }
82
83 impl Map for Builder<'_> {
84 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
85 self.builder.key(k)
86 }
87
88 fn finish(&mut self) -> Result<()> {
89 *self.out = self.builder.take_out();
90 Ok(())
91 }
92 }
93
94 impl ObjectDeser for PaymentPagesCheckoutSessionShippingAddressCollection {
95 type Builder = PaymentPagesCheckoutSessionShippingAddressCollectionBuilder;
96 }
97
98 impl FromValueOpt for PaymentPagesCheckoutSessionShippingAddressCollection {
99 fn from_value(v: Value) -> Option<Self> {
100 let Value::Object(obj) = v else {
101 return None;
102 };
103 let mut b =
104 PaymentPagesCheckoutSessionShippingAddressCollectionBuilder::deser_default();
105 for (k, v) in obj {
106 match k.as_str() {
107 "allowed_countries" => b.allowed_countries = FromValueOpt::from_value(v),
108 _ => {}
109 }
110 }
111 b.take_out()
112 }
113 }
114};
115#[derive(Clone, Eq, PartialEq)]
119#[non_exhaustive]
120pub enum PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries {
121 Ac,
122 Ad,
123 Ae,
124 Af,
125 Ag,
126 Ai,
127 Al,
128 Am,
129 Ao,
130 Aq,
131 Ar,
132 At,
133 Au,
134 Aw,
135 Ax,
136 Az,
137 Ba,
138 Bb,
139 Bd,
140 Be,
141 Bf,
142 Bg,
143 Bh,
144 Bi,
145 Bj,
146 Bl,
147 Bm,
148 Bn,
149 Bo,
150 Bq,
151 Br,
152 Bs,
153 Bt,
154 Bv,
155 Bw,
156 By,
157 Bz,
158 Ca,
159 Cd,
160 Cf,
161 Cg,
162 Ch,
163 Ci,
164 Ck,
165 Cl,
166 Cm,
167 Cn,
168 Co,
169 Cr,
170 Cv,
171 Cw,
172 Cy,
173 Cz,
174 De,
175 Dj,
176 Dk,
177 Dm,
178 Do,
179 Dz,
180 Ec,
181 Ee,
182 Eg,
183 Eh,
184 Er,
185 Es,
186 Et,
187 Fi,
188 Fj,
189 Fk,
190 Fo,
191 Fr,
192 Ga,
193 Gb,
194 Gd,
195 Ge,
196 Gf,
197 Gg,
198 Gh,
199 Gi,
200 Gl,
201 Gm,
202 Gn,
203 Gp,
204 Gq,
205 Gr,
206 Gs,
207 Gt,
208 Gu,
209 Gw,
210 Gy,
211 Hk,
212 Hn,
213 Hr,
214 Ht,
215 Hu,
216 Id,
217 Ie,
218 Il,
219 Im,
220 In,
221 Io,
222 Iq,
223 Is,
224 It,
225 Je,
226 Jm,
227 Jo,
228 Jp,
229 Ke,
230 Kg,
231 Kh,
232 Ki,
233 Km,
234 Kn,
235 Kr,
236 Kw,
237 Ky,
238 Kz,
239 La,
240 Lb,
241 Lc,
242 Li,
243 Lk,
244 Lr,
245 Ls,
246 Lt,
247 Lu,
248 Lv,
249 Ly,
250 Ma,
251 Mc,
252 Md,
253 Me,
254 Mf,
255 Mg,
256 Mk,
257 Ml,
258 Mm,
259 Mn,
260 Mo,
261 Mq,
262 Mr,
263 Ms,
264 Mt,
265 Mu,
266 Mv,
267 Mw,
268 Mx,
269 My,
270 Mz,
271 Na,
272 Nc,
273 Ne,
274 Ng,
275 Ni,
276 Nl,
277 No,
278 Np,
279 Nr,
280 Nu,
281 Nz,
282 Om,
283 Pa,
284 Pe,
285 Pf,
286 Pg,
287 Ph,
288 Pk,
289 Pl,
290 Pm,
291 Pn,
292 Pr,
293 Ps,
294 Pt,
295 Py,
296 Qa,
297 Re,
298 Ro,
299 Rs,
300 Ru,
301 Rw,
302 Sa,
303 Sb,
304 Sc,
305 Sd,
306 Se,
307 Sg,
308 Sh,
309 Si,
310 Sj,
311 Sk,
312 Sl,
313 Sm,
314 Sn,
315 So,
316 Sr,
317 Ss,
318 St,
319 Sv,
320 Sx,
321 Sz,
322 Ta,
323 Tc,
324 Td,
325 Tf,
326 Tg,
327 Th,
328 Tj,
329 Tk,
330 Tl,
331 Tm,
332 Tn,
333 To,
334 Tr,
335 Tt,
336 Tv,
337 Tw,
338 Tz,
339 Ua,
340 Ug,
341 Us,
342 Uy,
343 Uz,
344 Va,
345 Vc,
346 Ve,
347 Vg,
348 Vn,
349 Vu,
350 Wf,
351 Ws,
352 Xk,
353 Ye,
354 Yt,
355 Za,
356 Zm,
357 Zw,
358 Zz,
359 Unknown(String),
361}
362impl PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries {
363 pub fn as_str(&self) -> &str {
364 use PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::*;
365 match self {
366 Ac => "AC",
367 Ad => "AD",
368 Ae => "AE",
369 Af => "AF",
370 Ag => "AG",
371 Ai => "AI",
372 Al => "AL",
373 Am => "AM",
374 Ao => "AO",
375 Aq => "AQ",
376 Ar => "AR",
377 At => "AT",
378 Au => "AU",
379 Aw => "AW",
380 Ax => "AX",
381 Az => "AZ",
382 Ba => "BA",
383 Bb => "BB",
384 Bd => "BD",
385 Be => "BE",
386 Bf => "BF",
387 Bg => "BG",
388 Bh => "BH",
389 Bi => "BI",
390 Bj => "BJ",
391 Bl => "BL",
392 Bm => "BM",
393 Bn => "BN",
394 Bo => "BO",
395 Bq => "BQ",
396 Br => "BR",
397 Bs => "BS",
398 Bt => "BT",
399 Bv => "BV",
400 Bw => "BW",
401 By => "BY",
402 Bz => "BZ",
403 Ca => "CA",
404 Cd => "CD",
405 Cf => "CF",
406 Cg => "CG",
407 Ch => "CH",
408 Ci => "CI",
409 Ck => "CK",
410 Cl => "CL",
411 Cm => "CM",
412 Cn => "CN",
413 Co => "CO",
414 Cr => "CR",
415 Cv => "CV",
416 Cw => "CW",
417 Cy => "CY",
418 Cz => "CZ",
419 De => "DE",
420 Dj => "DJ",
421 Dk => "DK",
422 Dm => "DM",
423 Do => "DO",
424 Dz => "DZ",
425 Ec => "EC",
426 Ee => "EE",
427 Eg => "EG",
428 Eh => "EH",
429 Er => "ER",
430 Es => "ES",
431 Et => "ET",
432 Fi => "FI",
433 Fj => "FJ",
434 Fk => "FK",
435 Fo => "FO",
436 Fr => "FR",
437 Ga => "GA",
438 Gb => "GB",
439 Gd => "GD",
440 Ge => "GE",
441 Gf => "GF",
442 Gg => "GG",
443 Gh => "GH",
444 Gi => "GI",
445 Gl => "GL",
446 Gm => "GM",
447 Gn => "GN",
448 Gp => "GP",
449 Gq => "GQ",
450 Gr => "GR",
451 Gs => "GS",
452 Gt => "GT",
453 Gu => "GU",
454 Gw => "GW",
455 Gy => "GY",
456 Hk => "HK",
457 Hn => "HN",
458 Hr => "HR",
459 Ht => "HT",
460 Hu => "HU",
461 Id => "ID",
462 Ie => "IE",
463 Il => "IL",
464 Im => "IM",
465 In => "IN",
466 Io => "IO",
467 Iq => "IQ",
468 Is => "IS",
469 It => "IT",
470 Je => "JE",
471 Jm => "JM",
472 Jo => "JO",
473 Jp => "JP",
474 Ke => "KE",
475 Kg => "KG",
476 Kh => "KH",
477 Ki => "KI",
478 Km => "KM",
479 Kn => "KN",
480 Kr => "KR",
481 Kw => "KW",
482 Ky => "KY",
483 Kz => "KZ",
484 La => "LA",
485 Lb => "LB",
486 Lc => "LC",
487 Li => "LI",
488 Lk => "LK",
489 Lr => "LR",
490 Ls => "LS",
491 Lt => "LT",
492 Lu => "LU",
493 Lv => "LV",
494 Ly => "LY",
495 Ma => "MA",
496 Mc => "MC",
497 Md => "MD",
498 Me => "ME",
499 Mf => "MF",
500 Mg => "MG",
501 Mk => "MK",
502 Ml => "ML",
503 Mm => "MM",
504 Mn => "MN",
505 Mo => "MO",
506 Mq => "MQ",
507 Mr => "MR",
508 Ms => "MS",
509 Mt => "MT",
510 Mu => "MU",
511 Mv => "MV",
512 Mw => "MW",
513 Mx => "MX",
514 My => "MY",
515 Mz => "MZ",
516 Na => "NA",
517 Nc => "NC",
518 Ne => "NE",
519 Ng => "NG",
520 Ni => "NI",
521 Nl => "NL",
522 No => "NO",
523 Np => "NP",
524 Nr => "NR",
525 Nu => "NU",
526 Nz => "NZ",
527 Om => "OM",
528 Pa => "PA",
529 Pe => "PE",
530 Pf => "PF",
531 Pg => "PG",
532 Ph => "PH",
533 Pk => "PK",
534 Pl => "PL",
535 Pm => "PM",
536 Pn => "PN",
537 Pr => "PR",
538 Ps => "PS",
539 Pt => "PT",
540 Py => "PY",
541 Qa => "QA",
542 Re => "RE",
543 Ro => "RO",
544 Rs => "RS",
545 Ru => "RU",
546 Rw => "RW",
547 Sa => "SA",
548 Sb => "SB",
549 Sc => "SC",
550 Sd => "SD",
551 Se => "SE",
552 Sg => "SG",
553 Sh => "SH",
554 Si => "SI",
555 Sj => "SJ",
556 Sk => "SK",
557 Sl => "SL",
558 Sm => "SM",
559 Sn => "SN",
560 So => "SO",
561 Sr => "SR",
562 Ss => "SS",
563 St => "ST",
564 Sv => "SV",
565 Sx => "SX",
566 Sz => "SZ",
567 Ta => "TA",
568 Tc => "TC",
569 Td => "TD",
570 Tf => "TF",
571 Tg => "TG",
572 Th => "TH",
573 Tj => "TJ",
574 Tk => "TK",
575 Tl => "TL",
576 Tm => "TM",
577 Tn => "TN",
578 To => "TO",
579 Tr => "TR",
580 Tt => "TT",
581 Tv => "TV",
582 Tw => "TW",
583 Tz => "TZ",
584 Ua => "UA",
585 Ug => "UG",
586 Us => "US",
587 Uy => "UY",
588 Uz => "UZ",
589 Va => "VA",
590 Vc => "VC",
591 Ve => "VE",
592 Vg => "VG",
593 Vn => "VN",
594 Vu => "VU",
595 Wf => "WF",
596 Ws => "WS",
597 Xk => "XK",
598 Ye => "YE",
599 Yt => "YT",
600 Za => "ZA",
601 Zm => "ZM",
602 Zw => "ZW",
603 Zz => "ZZ",
604 Unknown(v) => v,
605 }
606 }
607}
608
609impl std::str::FromStr for PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries {
610 type Err = std::convert::Infallible;
611 fn from_str(s: &str) -> Result<Self, Self::Err> {
612 use PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::*;
613 match s {
614 "AC" => Ok(Ac),
615 "AD" => Ok(Ad),
616 "AE" => Ok(Ae),
617 "AF" => Ok(Af),
618 "AG" => Ok(Ag),
619 "AI" => Ok(Ai),
620 "AL" => Ok(Al),
621 "AM" => Ok(Am),
622 "AO" => Ok(Ao),
623 "AQ" => Ok(Aq),
624 "AR" => Ok(Ar),
625 "AT" => Ok(At),
626 "AU" => Ok(Au),
627 "AW" => Ok(Aw),
628 "AX" => Ok(Ax),
629 "AZ" => Ok(Az),
630 "BA" => Ok(Ba),
631 "BB" => Ok(Bb),
632 "BD" => Ok(Bd),
633 "BE" => Ok(Be),
634 "BF" => Ok(Bf),
635 "BG" => Ok(Bg),
636 "BH" => Ok(Bh),
637 "BI" => Ok(Bi),
638 "BJ" => Ok(Bj),
639 "BL" => Ok(Bl),
640 "BM" => Ok(Bm),
641 "BN" => Ok(Bn),
642 "BO" => Ok(Bo),
643 "BQ" => Ok(Bq),
644 "BR" => Ok(Br),
645 "BS" => Ok(Bs),
646 "BT" => Ok(Bt),
647 "BV" => Ok(Bv),
648 "BW" => Ok(Bw),
649 "BY" => Ok(By),
650 "BZ" => Ok(Bz),
651 "CA" => Ok(Ca),
652 "CD" => Ok(Cd),
653 "CF" => Ok(Cf),
654 "CG" => Ok(Cg),
655 "CH" => Ok(Ch),
656 "CI" => Ok(Ci),
657 "CK" => Ok(Ck),
658 "CL" => Ok(Cl),
659 "CM" => Ok(Cm),
660 "CN" => Ok(Cn),
661 "CO" => Ok(Co),
662 "CR" => Ok(Cr),
663 "CV" => Ok(Cv),
664 "CW" => Ok(Cw),
665 "CY" => Ok(Cy),
666 "CZ" => Ok(Cz),
667 "DE" => Ok(De),
668 "DJ" => Ok(Dj),
669 "DK" => Ok(Dk),
670 "DM" => Ok(Dm),
671 "DO" => Ok(Do),
672 "DZ" => Ok(Dz),
673 "EC" => Ok(Ec),
674 "EE" => Ok(Ee),
675 "EG" => Ok(Eg),
676 "EH" => Ok(Eh),
677 "ER" => Ok(Er),
678 "ES" => Ok(Es),
679 "ET" => Ok(Et),
680 "FI" => Ok(Fi),
681 "FJ" => Ok(Fj),
682 "FK" => Ok(Fk),
683 "FO" => Ok(Fo),
684 "FR" => Ok(Fr),
685 "GA" => Ok(Ga),
686 "GB" => Ok(Gb),
687 "GD" => Ok(Gd),
688 "GE" => Ok(Ge),
689 "GF" => Ok(Gf),
690 "GG" => Ok(Gg),
691 "GH" => Ok(Gh),
692 "GI" => Ok(Gi),
693 "GL" => Ok(Gl),
694 "GM" => Ok(Gm),
695 "GN" => Ok(Gn),
696 "GP" => Ok(Gp),
697 "GQ" => Ok(Gq),
698 "GR" => Ok(Gr),
699 "GS" => Ok(Gs),
700 "GT" => Ok(Gt),
701 "GU" => Ok(Gu),
702 "GW" => Ok(Gw),
703 "GY" => Ok(Gy),
704 "HK" => Ok(Hk),
705 "HN" => Ok(Hn),
706 "HR" => Ok(Hr),
707 "HT" => Ok(Ht),
708 "HU" => Ok(Hu),
709 "ID" => Ok(Id),
710 "IE" => Ok(Ie),
711 "IL" => Ok(Il),
712 "IM" => Ok(Im),
713 "IN" => Ok(In),
714 "IO" => Ok(Io),
715 "IQ" => Ok(Iq),
716 "IS" => Ok(Is),
717 "IT" => Ok(It),
718 "JE" => Ok(Je),
719 "JM" => Ok(Jm),
720 "JO" => Ok(Jo),
721 "JP" => Ok(Jp),
722 "KE" => Ok(Ke),
723 "KG" => Ok(Kg),
724 "KH" => Ok(Kh),
725 "KI" => Ok(Ki),
726 "KM" => Ok(Km),
727 "KN" => Ok(Kn),
728 "KR" => Ok(Kr),
729 "KW" => Ok(Kw),
730 "KY" => Ok(Ky),
731 "KZ" => Ok(Kz),
732 "LA" => Ok(La),
733 "LB" => Ok(Lb),
734 "LC" => Ok(Lc),
735 "LI" => Ok(Li),
736 "LK" => Ok(Lk),
737 "LR" => Ok(Lr),
738 "LS" => Ok(Ls),
739 "LT" => Ok(Lt),
740 "LU" => Ok(Lu),
741 "LV" => Ok(Lv),
742 "LY" => Ok(Ly),
743 "MA" => Ok(Ma),
744 "MC" => Ok(Mc),
745 "MD" => Ok(Md),
746 "ME" => Ok(Me),
747 "MF" => Ok(Mf),
748 "MG" => Ok(Mg),
749 "MK" => Ok(Mk),
750 "ML" => Ok(Ml),
751 "MM" => Ok(Mm),
752 "MN" => Ok(Mn),
753 "MO" => Ok(Mo),
754 "MQ" => Ok(Mq),
755 "MR" => Ok(Mr),
756 "MS" => Ok(Ms),
757 "MT" => Ok(Mt),
758 "MU" => Ok(Mu),
759 "MV" => Ok(Mv),
760 "MW" => Ok(Mw),
761 "MX" => Ok(Mx),
762 "MY" => Ok(My),
763 "MZ" => Ok(Mz),
764 "NA" => Ok(Na),
765 "NC" => Ok(Nc),
766 "NE" => Ok(Ne),
767 "NG" => Ok(Ng),
768 "NI" => Ok(Ni),
769 "NL" => Ok(Nl),
770 "NO" => Ok(No),
771 "NP" => Ok(Np),
772 "NR" => Ok(Nr),
773 "NU" => Ok(Nu),
774 "NZ" => Ok(Nz),
775 "OM" => Ok(Om),
776 "PA" => Ok(Pa),
777 "PE" => Ok(Pe),
778 "PF" => Ok(Pf),
779 "PG" => Ok(Pg),
780 "PH" => Ok(Ph),
781 "PK" => Ok(Pk),
782 "PL" => Ok(Pl),
783 "PM" => Ok(Pm),
784 "PN" => Ok(Pn),
785 "PR" => Ok(Pr),
786 "PS" => Ok(Ps),
787 "PT" => Ok(Pt),
788 "PY" => Ok(Py),
789 "QA" => Ok(Qa),
790 "RE" => Ok(Re),
791 "RO" => Ok(Ro),
792 "RS" => Ok(Rs),
793 "RU" => Ok(Ru),
794 "RW" => Ok(Rw),
795 "SA" => Ok(Sa),
796 "SB" => Ok(Sb),
797 "SC" => Ok(Sc),
798 "SD" => Ok(Sd),
799 "SE" => Ok(Se),
800 "SG" => Ok(Sg),
801 "SH" => Ok(Sh),
802 "SI" => Ok(Si),
803 "SJ" => Ok(Sj),
804 "SK" => Ok(Sk),
805 "SL" => Ok(Sl),
806 "SM" => Ok(Sm),
807 "SN" => Ok(Sn),
808 "SO" => Ok(So),
809 "SR" => Ok(Sr),
810 "SS" => Ok(Ss),
811 "ST" => Ok(St),
812 "SV" => Ok(Sv),
813 "SX" => Ok(Sx),
814 "SZ" => Ok(Sz),
815 "TA" => Ok(Ta),
816 "TC" => Ok(Tc),
817 "TD" => Ok(Td),
818 "TF" => Ok(Tf),
819 "TG" => Ok(Tg),
820 "TH" => Ok(Th),
821 "TJ" => Ok(Tj),
822 "TK" => Ok(Tk),
823 "TL" => Ok(Tl),
824 "TM" => Ok(Tm),
825 "TN" => Ok(Tn),
826 "TO" => Ok(To),
827 "TR" => Ok(Tr),
828 "TT" => Ok(Tt),
829 "TV" => Ok(Tv),
830 "TW" => Ok(Tw),
831 "TZ" => Ok(Tz),
832 "UA" => Ok(Ua),
833 "UG" => Ok(Ug),
834 "US" => Ok(Us),
835 "UY" => Ok(Uy),
836 "UZ" => Ok(Uz),
837 "VA" => Ok(Va),
838 "VC" => Ok(Vc),
839 "VE" => Ok(Ve),
840 "VG" => Ok(Vg),
841 "VN" => Ok(Vn),
842 "VU" => Ok(Vu),
843 "WF" => Ok(Wf),
844 "WS" => Ok(Ws),
845 "XK" => Ok(Xk),
846 "YE" => Ok(Ye),
847 "YT" => Ok(Yt),
848 "ZA" => Ok(Za),
849 "ZM" => Ok(Zm),
850 "ZW" => Ok(Zw),
851 "ZZ" => Ok(Zz),
852 v => {
853 tracing::warn!(
854 "Unknown value '{}' for enum '{}'",
855 v,
856 "PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries"
857 );
858 Ok(Unknown(v.to_owned()))
859 }
860 }
861 }
862}
863impl std::fmt::Display for PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries {
864 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
865 f.write_str(self.as_str())
866 }
867}
868
869#[cfg(not(feature = "redact-generated-debug"))]
870impl std::fmt::Debug for PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries {
871 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
872 f.write_str(self.as_str())
873 }
874}
875#[cfg(feature = "redact-generated-debug")]
876impl std::fmt::Debug for PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries {
877 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
878 f.debug_struct(stringify!(
879 PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries
880 ))
881 .finish_non_exhaustive()
882 }
883}
884#[cfg(feature = "serialize")]
885impl serde::Serialize for PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries {
886 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
887 where
888 S: serde::Serializer,
889 {
890 serializer.serialize_str(self.as_str())
891 }
892}
893impl miniserde::Deserialize
894 for PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries
895{
896 fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
897 crate::Place::new(out)
898 }
899}
900
901impl miniserde::de::Visitor
902 for crate::Place<PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries>
903{
904 fn string(&mut self, s: &str) -> miniserde::Result<()> {
905 use std::str::FromStr;
906 self.out = Some(
907 PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::from_str(s)
908 .expect("infallible"),
909 );
910 Ok(())
911 }
912}
913
914stripe_types::impl_from_val_with_from_str!(
915 PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries
916);
917#[cfg(feature = "deserialize")]
918impl<'de> serde::Deserialize<'de>
919 for PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries
920{
921 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
922 use std::str::FromStr;
923 let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
924 Ok(Self::from_str(&s).expect("infallible"))
925 }
926}