Skip to main content

stripe_shared/
payment_pages_checkout_session_custom_text.rs

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 PaymentPagesCheckoutSessionCustomText {
6    /// Custom text that should be displayed after the payment confirmation button.
7    pub after_submit: Option<stripe_shared::PaymentPagesCheckoutSessionCustomTextPosition>,
8    /// Custom text that should be displayed alongside shipping address collection.
9    pub shipping_address: Option<stripe_shared::PaymentPagesCheckoutSessionCustomTextPosition>,
10    /// Custom text that should be displayed alongside the payment confirmation button.
11    pub submit: Option<stripe_shared::PaymentPagesCheckoutSessionCustomTextPosition>,
12    /// Custom text that should be displayed in place of the default terms of service agreement text.
13    pub terms_of_service_acceptance:
14        Option<stripe_shared::PaymentPagesCheckoutSessionCustomTextPosition>,
15}
16#[cfg(feature = "redact-generated-debug")]
17impl std::fmt::Debug for PaymentPagesCheckoutSessionCustomText {
18    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
19        f.debug_struct("PaymentPagesCheckoutSessionCustomText").finish_non_exhaustive()
20    }
21}
22#[doc(hidden)]
23pub struct PaymentPagesCheckoutSessionCustomTextBuilder {
24    after_submit: Option<Option<stripe_shared::PaymentPagesCheckoutSessionCustomTextPosition>>,
25    shipping_address: Option<Option<stripe_shared::PaymentPagesCheckoutSessionCustomTextPosition>>,
26    submit: Option<Option<stripe_shared::PaymentPagesCheckoutSessionCustomTextPosition>>,
27    terms_of_service_acceptance:
28        Option<Option<stripe_shared::PaymentPagesCheckoutSessionCustomTextPosition>>,
29}
30
31#[allow(
32    unused_variables,
33    irrefutable_let_patterns,
34    clippy::let_unit_value,
35    clippy::match_single_binding,
36    clippy::single_match
37)]
38const _: () = {
39    use miniserde::de::{Map, Visitor};
40    use miniserde::json::Value;
41    use miniserde::{Deserialize, Result, make_place};
42    use stripe_types::miniserde_helpers::FromValueOpt;
43    use stripe_types::{MapBuilder, ObjectDeser};
44
45    make_place!(Place);
46
47    impl Deserialize for PaymentPagesCheckoutSessionCustomText {
48        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
49            Place::new(out)
50        }
51    }
52
53    struct Builder<'a> {
54        out: &'a mut Option<PaymentPagesCheckoutSessionCustomText>,
55        builder: PaymentPagesCheckoutSessionCustomTextBuilder,
56    }
57
58    impl Visitor for Place<PaymentPagesCheckoutSessionCustomText> {
59        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
60            Ok(Box::new(Builder {
61                out: &mut self.out,
62                builder: PaymentPagesCheckoutSessionCustomTextBuilder::deser_default(),
63            }))
64        }
65    }
66
67    impl MapBuilder for PaymentPagesCheckoutSessionCustomTextBuilder {
68        type Out = PaymentPagesCheckoutSessionCustomText;
69        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
70            Ok(match k {
71                "after_submit" => Deserialize::begin(&mut self.after_submit),
72                "shipping_address" => Deserialize::begin(&mut self.shipping_address),
73                "submit" => Deserialize::begin(&mut self.submit),
74                "terms_of_service_acceptance" => {
75                    Deserialize::begin(&mut self.terms_of_service_acceptance)
76                }
77                _ => <dyn Visitor>::ignore(),
78            })
79        }
80
81        fn deser_default() -> Self {
82            Self {
83                after_submit: Some(None),
84                shipping_address: Some(None),
85                submit: Some(None),
86                terms_of_service_acceptance: Some(None),
87            }
88        }
89
90        fn take_out(&mut self) -> Option<Self::Out> {
91            let (
92                Some(after_submit),
93                Some(shipping_address),
94                Some(submit),
95                Some(terms_of_service_acceptance),
96            ) = (
97                self.after_submit.take(),
98                self.shipping_address.take(),
99                self.submit.take(),
100                self.terms_of_service_acceptance.take(),
101            )
102            else {
103                return None;
104            };
105            Some(Self::Out { after_submit, shipping_address, submit, terms_of_service_acceptance })
106        }
107    }
108
109    impl Map for Builder<'_> {
110        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
111            self.builder.key(k)
112        }
113
114        fn finish(&mut self) -> Result<()> {
115            *self.out = self.builder.take_out();
116            Ok(())
117        }
118    }
119
120    impl ObjectDeser for PaymentPagesCheckoutSessionCustomText {
121        type Builder = PaymentPagesCheckoutSessionCustomTextBuilder;
122    }
123
124    impl FromValueOpt for PaymentPagesCheckoutSessionCustomText {
125        fn from_value(v: Value) -> Option<Self> {
126            let Value::Object(obj) = v else {
127                return None;
128            };
129            let mut b = PaymentPagesCheckoutSessionCustomTextBuilder::deser_default();
130            for (k, v) in obj {
131                match k.as_str() {
132                    "after_submit" => b.after_submit = FromValueOpt::from_value(v),
133                    "shipping_address" => b.shipping_address = FromValueOpt::from_value(v),
134                    "submit" => b.submit = FromValueOpt::from_value(v),
135                    "terms_of_service_acceptance" => {
136                        b.terms_of_service_acceptance = FromValueOpt::from_value(v)
137                    }
138                    _ => {}
139                }
140            }
141            b.take_out()
142        }
143    }
144};