stripe_shared/
payment_pages_checkout_session_saved_payment_method_options.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 PaymentPagesCheckoutSessionSavedPaymentMethodOptions {
6    /// Uses the `allow_redisplay` value of each saved payment method to filter the set presented to a returning customer.
7    /// By default, only saved payment methods with ’allow_redisplay: ‘always’ are shown in Checkout.
8    pub allow_redisplay_filters:
9        Option<Vec<PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters>>,
10    /// Enable customers to choose if they wish to remove their saved payment methods. Disabled by default.
11    pub payment_method_remove:
12        Option<PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove>,
13    /// Enable customers to choose if they wish to save their payment method for future use.
14    /// Disabled by default.
15    pub payment_method_save:
16        Option<PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave>,
17}
18#[cfg(feature = "redact-generated-debug")]
19impl std::fmt::Debug for PaymentPagesCheckoutSessionSavedPaymentMethodOptions {
20    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21        f.debug_struct("PaymentPagesCheckoutSessionSavedPaymentMethodOptions")
22            .finish_non_exhaustive()
23    }
24}
25#[doc(hidden)]
26pub struct PaymentPagesCheckoutSessionSavedPaymentMethodOptionsBuilder {
27    allow_redisplay_filters: Option<
28        Option<Vec<PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters>>,
29    >,
30    payment_method_remove:
31        Option<Option<PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove>>,
32    payment_method_save:
33        Option<Option<PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave>>,
34}
35
36#[allow(
37    unused_variables,
38    irrefutable_let_patterns,
39    clippy::let_unit_value,
40    clippy::match_single_binding,
41    clippy::single_match
42)]
43const _: () = {
44    use miniserde::de::{Map, Visitor};
45    use miniserde::json::Value;
46    use miniserde::{Deserialize, Result, make_place};
47    use stripe_types::miniserde_helpers::FromValueOpt;
48    use stripe_types::{MapBuilder, ObjectDeser};
49
50    make_place!(Place);
51
52    impl Deserialize for PaymentPagesCheckoutSessionSavedPaymentMethodOptions {
53        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
54            Place::new(out)
55        }
56    }
57
58    struct Builder<'a> {
59        out: &'a mut Option<PaymentPagesCheckoutSessionSavedPaymentMethodOptions>,
60        builder: PaymentPagesCheckoutSessionSavedPaymentMethodOptionsBuilder,
61    }
62
63    impl Visitor for Place<PaymentPagesCheckoutSessionSavedPaymentMethodOptions> {
64        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
65            Ok(Box::new(Builder {
66                out: &mut self.out,
67                builder: PaymentPagesCheckoutSessionSavedPaymentMethodOptionsBuilder::deser_default(
68                ),
69            }))
70        }
71    }
72
73    impl MapBuilder for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsBuilder {
74        type Out = PaymentPagesCheckoutSessionSavedPaymentMethodOptions;
75        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
76            Ok(match k {
77                "allow_redisplay_filters" => Deserialize::begin(&mut self.allow_redisplay_filters),
78                "payment_method_remove" => Deserialize::begin(&mut self.payment_method_remove),
79                "payment_method_save" => Deserialize::begin(&mut self.payment_method_save),
80                _ => <dyn Visitor>::ignore(),
81            })
82        }
83
84        fn deser_default() -> Self {
85            Self {
86                allow_redisplay_filters: Some(None),
87                payment_method_remove: Some(None),
88                payment_method_save: Some(None),
89            }
90        }
91
92        fn take_out(&mut self) -> Option<Self::Out> {
93            let (
94                Some(allow_redisplay_filters),
95                Some(payment_method_remove),
96                Some(payment_method_save),
97            ) = (
98                self.allow_redisplay_filters.take(),
99                self.payment_method_remove.take(),
100                self.payment_method_save.take(),
101            )
102            else {
103                return None;
104            };
105            Some(Self::Out { allow_redisplay_filters, payment_method_remove, payment_method_save })
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 PaymentPagesCheckoutSessionSavedPaymentMethodOptions {
121        type Builder = PaymentPagesCheckoutSessionSavedPaymentMethodOptionsBuilder;
122    }
123
124    impl FromValueOpt for PaymentPagesCheckoutSessionSavedPaymentMethodOptions {
125        fn from_value(v: Value) -> Option<Self> {
126            let Value::Object(obj) = v else {
127                return None;
128            };
129            let mut b =
130                PaymentPagesCheckoutSessionSavedPaymentMethodOptionsBuilder::deser_default();
131            for (k, v) in obj {
132                match k.as_str() {
133                    "allow_redisplay_filters" => {
134                        b.allow_redisplay_filters = FromValueOpt::from_value(v)
135                    }
136                    "payment_method_remove" => {
137                        b.payment_method_remove = FromValueOpt::from_value(v)
138                    }
139                    "payment_method_save" => b.payment_method_save = FromValueOpt::from_value(v),
140                    _ => {}
141                }
142            }
143            b.take_out()
144        }
145    }
146};
147/// Uses the `allow_redisplay` value of each saved payment method to filter the set presented to a returning customer.
148/// By default, only saved payment methods with ’allow_redisplay: ‘always’ are shown in Checkout.
149#[derive(Clone, Eq, PartialEq)]
150#[non_exhaustive]
151pub enum PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters {
152    Always,
153    Limited,
154    Unspecified,
155    /// An unrecognized value from Stripe. Should not be used as a request parameter.
156    Unknown(String),
157}
158impl PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters {
159    pub fn as_str(&self) -> &str {
160        use PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters::*;
161        match self {
162            Always => "always",
163            Limited => "limited",
164            Unspecified => "unspecified",
165            Unknown(v) => v,
166        }
167    }
168}
169
170impl std::str::FromStr
171    for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters
172{
173    type Err = std::convert::Infallible;
174    fn from_str(s: &str) -> Result<Self, Self::Err> {
175        use PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters::*;
176        match s {
177            "always" => Ok(Always),
178            "limited" => Ok(Limited),
179            "unspecified" => Ok(Unspecified),
180            v => {
181                tracing::warn!(
182                    "Unknown value '{}' for enum '{}'",
183                    v,
184                    "PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters"
185                );
186                Ok(Unknown(v.to_owned()))
187            }
188        }
189    }
190}
191impl std::fmt::Display
192    for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters
193{
194    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
195        f.write_str(self.as_str())
196    }
197}
198
199#[cfg(not(feature = "redact-generated-debug"))]
200impl std::fmt::Debug for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters {
201    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
202        f.write_str(self.as_str())
203    }
204}
205#[cfg(feature = "redact-generated-debug")]
206impl std::fmt::Debug for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters {
207    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
208        f.debug_struct(stringify!(
209            PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters
210        ))
211        .finish_non_exhaustive()
212    }
213}
214#[cfg(feature = "serialize")]
215impl serde::Serialize
216    for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters
217{
218    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
219    where
220        S: serde::Serializer,
221    {
222        serializer.serialize_str(self.as_str())
223    }
224}
225impl miniserde::Deserialize
226    for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters
227{
228    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
229        crate::Place::new(out)
230    }
231}
232
233impl miniserde::de::Visitor
234    for crate::Place<PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters>
235{
236    fn string(&mut self, s: &str) -> miniserde::Result<()> {
237        use std::str::FromStr;
238        self.out = Some(
239            PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters::from_str(s)
240                .expect("infallible"),
241        );
242        Ok(())
243    }
244}
245
246stripe_types::impl_from_val_with_from_str!(
247    PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters
248);
249#[cfg(feature = "deserialize")]
250impl<'de> serde::Deserialize<'de>
251    for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsAllowRedisplayFilters
252{
253    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
254        use std::str::FromStr;
255        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
256        Ok(Self::from_str(&s).expect("infallible"))
257    }
258}
259/// Enable customers to choose if they wish to remove their saved payment methods. Disabled by default.
260#[derive(Clone, Eq, PartialEq)]
261#[non_exhaustive]
262pub enum PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove {
263    Disabled,
264    Enabled,
265    /// An unrecognized value from Stripe. Should not be used as a request parameter.
266    Unknown(String),
267}
268impl PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove {
269    pub fn as_str(&self) -> &str {
270        use PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove::*;
271        match self {
272            Disabled => "disabled",
273            Enabled => "enabled",
274            Unknown(v) => v,
275        }
276    }
277}
278
279impl std::str::FromStr for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove {
280    type Err = std::convert::Infallible;
281    fn from_str(s: &str) -> Result<Self, Self::Err> {
282        use PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove::*;
283        match s {
284            "disabled" => Ok(Disabled),
285            "enabled" => Ok(Enabled),
286            v => {
287                tracing::warn!(
288                    "Unknown value '{}' for enum '{}'",
289                    v,
290                    "PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove"
291                );
292                Ok(Unknown(v.to_owned()))
293            }
294        }
295    }
296}
297impl std::fmt::Display for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove {
298    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
299        f.write_str(self.as_str())
300    }
301}
302
303#[cfg(not(feature = "redact-generated-debug"))]
304impl std::fmt::Debug for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove {
305    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
306        f.write_str(self.as_str())
307    }
308}
309#[cfg(feature = "redact-generated-debug")]
310impl std::fmt::Debug for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove {
311    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
312        f.debug_struct(stringify!(
313            PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove
314        ))
315        .finish_non_exhaustive()
316    }
317}
318#[cfg(feature = "serialize")]
319impl serde::Serialize for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove {
320    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
321    where
322        S: serde::Serializer,
323    {
324        serializer.serialize_str(self.as_str())
325    }
326}
327impl miniserde::Deserialize
328    for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove
329{
330    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
331        crate::Place::new(out)
332    }
333}
334
335impl miniserde::de::Visitor
336    for crate::Place<PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove>
337{
338    fn string(&mut self, s: &str) -> miniserde::Result<()> {
339        use std::str::FromStr;
340        self.out = Some(
341            PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove::from_str(s)
342                .expect("infallible"),
343        );
344        Ok(())
345    }
346}
347
348stripe_types::impl_from_val_with_from_str!(
349    PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove
350);
351#[cfg(feature = "deserialize")]
352impl<'de> serde::Deserialize<'de>
353    for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodRemove
354{
355    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
356        use std::str::FromStr;
357        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
358        Ok(Self::from_str(&s).expect("infallible"))
359    }
360}
361/// Enable customers to choose if they wish to save their payment method for future use.
362/// Disabled by default.
363#[derive(Clone, Eq, PartialEq)]
364#[non_exhaustive]
365pub enum PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave {
366    Disabled,
367    Enabled,
368    /// An unrecognized value from Stripe. Should not be used as a request parameter.
369    Unknown(String),
370}
371impl PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave {
372    pub fn as_str(&self) -> &str {
373        use PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave::*;
374        match self {
375            Disabled => "disabled",
376            Enabled => "enabled",
377            Unknown(v) => v,
378        }
379    }
380}
381
382impl std::str::FromStr for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave {
383    type Err = std::convert::Infallible;
384    fn from_str(s: &str) -> Result<Self, Self::Err> {
385        use PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave::*;
386        match s {
387            "disabled" => Ok(Disabled),
388            "enabled" => Ok(Enabled),
389            v => {
390                tracing::warn!(
391                    "Unknown value '{}' for enum '{}'",
392                    v,
393                    "PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave"
394                );
395                Ok(Unknown(v.to_owned()))
396            }
397        }
398    }
399}
400impl std::fmt::Display for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave {
401    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
402        f.write_str(self.as_str())
403    }
404}
405
406#[cfg(not(feature = "redact-generated-debug"))]
407impl std::fmt::Debug for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave {
408    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
409        f.write_str(self.as_str())
410    }
411}
412#[cfg(feature = "redact-generated-debug")]
413impl std::fmt::Debug for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave {
414    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
415        f.debug_struct(stringify!(
416            PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave
417        ))
418        .finish_non_exhaustive()
419    }
420}
421#[cfg(feature = "serialize")]
422impl serde::Serialize for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave {
423    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
424    where
425        S: serde::Serializer,
426    {
427        serializer.serialize_str(self.as_str())
428    }
429}
430impl miniserde::Deserialize
431    for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave
432{
433    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
434        crate::Place::new(out)
435    }
436}
437
438impl miniserde::de::Visitor
439    for crate::Place<PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave>
440{
441    fn string(&mut self, s: &str) -> miniserde::Result<()> {
442        use std::str::FromStr;
443        self.out = Some(
444            PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave::from_str(s)
445                .expect("infallible"),
446        );
447        Ok(())
448    }
449}
450
451stripe_types::impl_from_val_with_from_str!(
452    PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave
453);
454#[cfg(feature = "deserialize")]
455impl<'de> serde::Deserialize<'de>
456    for PaymentPagesCheckoutSessionSavedPaymentMethodOptionsPaymentMethodSave
457{
458    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
459        use std::str::FromStr;
460        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
461        Ok(Self::from_str(&s).expect("infallible"))
462    }
463}
stripe_shared/payment_pages_checkout_session_saved_payment_method_options.rs

stripe_shared/
payment_pages_checkout_session_saved_payment_method_options.rs
