stripe_core/customer_session/
requests.rs

1use stripe_client_core::{
2    RequestBuilder, StripeBlockingClient, StripeClient, StripeMethod, StripeRequest,
3};
4
5#[derive(Clone, Debug, serde::Serialize)]
6struct CreateCustomerSessionBuilder {
7    components: CreateCustomerSessionComponents,
8    customer: String,
9    #[serde(skip_serializing_if = "Option::is_none")]
10    expand: Option<Vec<String>>,
11}
12impl CreateCustomerSessionBuilder {
13    fn new(
14        components: impl Into<CreateCustomerSessionComponents>,
15        customer: impl Into<String>,
16    ) -> Self {
17        Self { components: components.into(), customer: customer.into(), expand: None }
18    }
19}
20/// Configuration for each component. At least 1 component must be enabled.
21#[derive(Clone, Debug, serde::Serialize)]
22pub struct CreateCustomerSessionComponents {
23    /// Configuration for buy button.
24    #[serde(skip_serializing_if = "Option::is_none")]
25    pub buy_button: Option<CreateCustomerSessionComponentsBuyButton>,
26    /// Configuration for the customer sheet.
27    #[serde(skip_serializing_if = "Option::is_none")]
28    pub customer_sheet: Option<CreateCustomerSessionComponentsCustomerSheet>,
29    /// Configuration for the mobile payment element.
30    #[serde(skip_serializing_if = "Option::is_none")]
31    pub mobile_payment_element: Option<CreateCustomerSessionComponentsMobilePaymentElement>,
32    /// Configuration for the Payment Element.
33    #[serde(skip_serializing_if = "Option::is_none")]
34    pub payment_element: Option<CreateCustomerSessionComponentsPaymentElement>,
35    /// Configuration for the pricing table.
36    #[serde(skip_serializing_if = "Option::is_none")]
37    pub pricing_table: Option<CreateCustomerSessionComponentsPricingTable>,
38}
39impl CreateCustomerSessionComponents {
40    pub fn new() -> Self {
41        Self {
42            buy_button: None,
43            customer_sheet: None,
44            mobile_payment_element: None,
45            payment_element: None,
46            pricing_table: None,
47        }
48    }
49}
50impl Default for CreateCustomerSessionComponents {
51    fn default() -> Self {
52        Self::new()
53    }
54}
55/// Configuration for buy button.
56#[derive(Copy, Clone, Debug, serde::Serialize)]
57pub struct CreateCustomerSessionComponentsBuyButton {
58    /// Whether the buy button is enabled.
59    pub enabled: bool,
60}
61impl CreateCustomerSessionComponentsBuyButton {
62    pub fn new(enabled: impl Into<bool>) -> Self {
63        Self { enabled: enabled.into() }
64    }
65}
66/// Configuration for the customer sheet.
67#[derive(Clone, Debug, serde::Serialize)]
68pub struct CreateCustomerSessionComponentsCustomerSheet {
69    /// Whether the customer sheet is enabled.
70    pub enabled: bool,
71    /// This hash defines whether the customer sheet supports certain features.
72    #[serde(skip_serializing_if = "Option::is_none")]
73    pub features: Option<CreateCustomerSessionComponentsCustomerSheetFeatures>,
74}
75impl CreateCustomerSessionComponentsCustomerSheet {
76    pub fn new(enabled: impl Into<bool>) -> Self {
77        Self { enabled: enabled.into(), features: None }
78    }
79}
80/// This hash defines whether the customer sheet supports certain features.
81#[derive(Clone, Debug, serde::Serialize)]
82pub struct CreateCustomerSessionComponentsCustomerSheetFeatures {
83    /// A list of [`allow_redisplay`](https://docs.stripe.com/api/payment_methods/object#payment_method_object-allow_redisplay) values that controls which saved payment methods the customer sheet displays by filtering to only show payment methods with an `allow_redisplay` value that is present in this list.
84    ///
85    /// If not specified, defaults to ["always"].
86    /// In order to display all saved payment methods, specify ["always", "limited", "unspecified"].
87    #[serde(skip_serializing_if = "Option::is_none")]
88    pub payment_method_allow_redisplay_filters: Option<
89        Vec<CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters>,
90    >,
91    /// Controls whether the customer sheet displays the option to remove a saved payment method."
92    ///
93    /// Allowing buyers to remove their saved payment methods impacts subscriptions that depend on that payment method.
94    /// Removing the payment method detaches the [`customer` object](https://docs.stripe.com/api/payment_methods/object#payment_method_object-customer) from that [PaymentMethod](https://docs.stripe.com/api/payment_methods).
95    #[serde(skip_serializing_if = "Option::is_none")]
96    pub payment_method_remove:
97        Option<CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove>,
98}
99impl CreateCustomerSessionComponentsCustomerSheetFeatures {
100    pub fn new() -> Self {
101        Self { payment_method_allow_redisplay_filters: None, payment_method_remove: None }
102    }
103}
104impl Default for CreateCustomerSessionComponentsCustomerSheetFeatures {
105    fn default() -> Self {
106        Self::new()
107    }
108}
109/// A list of [`allow_redisplay`](https://docs.stripe.com/api/payment_methods/object#payment_method_object-allow_redisplay) values that controls which saved payment methods the customer sheet displays by filtering to only show payment methods with an `allow_redisplay` value that is present in this list.
110///
111/// If not specified, defaults to ["always"].
112/// In order to display all saved payment methods, specify ["always", "limited", "unspecified"].
113#[derive(Clone, Eq, PartialEq)]
114#[non_exhaustive]
115pub enum CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters {
116    Always,
117    Limited,
118    Unspecified,
119    /// An unrecognized value from Stripe. Should not be used as a request parameter.
120    Unknown(String),
121}
122impl CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters {
123    pub fn as_str(&self) -> &str {
124        use CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters::*;
125        match self {
126            Always => "always",
127            Limited => "limited",
128            Unspecified => "unspecified",
129            Unknown(v) => v,
130        }
131    }
132}
133
134impl std::str::FromStr
135    for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters
136{
137    type Err = std::convert::Infallible;
138    fn from_str(s: &str) -> Result<Self, Self::Err> {
139        use CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters::*;
140        match s {
141            "always" => Ok(Always),
142            "limited" => Ok(Limited),
143            "unspecified" => Ok(Unspecified),
144            v => {
145                tracing::warn!(
146                    "Unknown value '{}' for enum '{}'",
147                    v,
148                    "CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters"
149                );
150                Ok(Unknown(v.to_owned()))
151            }
152        }
153    }
154}
155impl std::fmt::Display
156    for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters
157{
158    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
159        f.write_str(self.as_str())
160    }
161}
162
163impl std::fmt::Debug
164    for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters
165{
166    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
167        f.write_str(self.as_str())
168    }
169}
170impl serde::Serialize
171    for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters
172{
173    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
174    where
175        S: serde::Serializer,
176    {
177        serializer.serialize_str(self.as_str())
178    }
179}
180#[cfg(feature = "deserialize")]
181impl<'de> serde::Deserialize<'de>
182    for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters
183{
184    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
185        use std::str::FromStr;
186        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
187        Ok(Self::from_str(&s).expect("infallible"))
188    }
189}
190/// Controls whether the customer sheet displays the option to remove a saved payment method."
191///
192/// Allowing buyers to remove their saved payment methods impacts subscriptions that depend on that payment method.
193/// Removing the payment method detaches the [`customer` object](https://docs.stripe.com/api/payment_methods/object#payment_method_object-customer) from that [PaymentMethod](https://docs.stripe.com/api/payment_methods).
194#[derive(Clone, Eq, PartialEq)]
195#[non_exhaustive]
196pub enum CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove {
197    Disabled,
198    Enabled,
199    /// An unrecognized value from Stripe. Should not be used as a request parameter.
200    Unknown(String),
201}
202impl CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove {
203    pub fn as_str(&self) -> &str {
204        use CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove::*;
205        match self {
206            Disabled => "disabled",
207            Enabled => "enabled",
208            Unknown(v) => v,
209        }
210    }
211}
212
213impl std::str::FromStr for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove {
214    type Err = std::convert::Infallible;
215    fn from_str(s: &str) -> Result<Self, Self::Err> {
216        use CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove::*;
217        match s {
218            "disabled" => Ok(Disabled),
219            "enabled" => Ok(Enabled),
220            v => {
221                tracing::warn!(
222                    "Unknown value '{}' for enum '{}'",
223                    v,
224                    "CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove"
225                );
226                Ok(Unknown(v.to_owned()))
227            }
228        }
229    }
230}
231impl std::fmt::Display for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove {
232    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
233        f.write_str(self.as_str())
234    }
235}
236
237impl std::fmt::Debug for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove {
238    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
239        f.write_str(self.as_str())
240    }
241}
242impl serde::Serialize for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove {
243    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
244    where
245        S: serde::Serializer,
246    {
247        serializer.serialize_str(self.as_str())
248    }
249}
250#[cfg(feature = "deserialize")]
251impl<'de> serde::Deserialize<'de>
252    for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove
253{
254    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
255        use std::str::FromStr;
256        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
257        Ok(Self::from_str(&s).expect("infallible"))
258    }
259}
260/// Configuration for the mobile payment element.
261#[derive(Clone, Debug, serde::Serialize)]
262pub struct CreateCustomerSessionComponentsMobilePaymentElement {
263    /// Whether the mobile payment element is enabled.
264    pub enabled: bool,
265    /// This hash defines whether the mobile payment element supports certain features.
266    #[serde(skip_serializing_if = "Option::is_none")]
267    pub features: Option<CreateCustomerSessionComponentsMobilePaymentElementFeatures>,
268}
269impl CreateCustomerSessionComponentsMobilePaymentElement {
270    pub fn new(enabled: impl Into<bool>) -> Self {
271        Self { enabled: enabled.into(), features: None }
272    }
273}
274/// This hash defines whether the mobile payment element supports certain features.
275#[derive(Clone, Debug, serde::Serialize)]
276pub struct CreateCustomerSessionComponentsMobilePaymentElementFeatures {
277        /// A list of [`allow_redisplay`](https://docs.stripe.com/api/payment_methods/object#payment_method_object-allow_redisplay) values that controls which saved payment methods the mobile payment element displays by filtering to only show payment methods with an `allow_redisplay` value that is present in this list.
278    ///
279        /// If not specified, defaults to ["always"].
280    /// In order to display all saved payment methods, specify ["always", "limited", "unspecified"].
281#[serde(skip_serializing_if = "Option::is_none")]
282pub payment_method_allow_redisplay_filters: Option<Vec<CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters>>,
283    /// Controls whether or not the mobile payment element shows saved payment methods.
284#[serde(skip_serializing_if = "Option::is_none")]
285pub payment_method_redisplay: Option<CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay>,
286    /// Controls whether the mobile payment element displays the option to remove a saved payment method."
287    ///
288        /// Allowing buyers to remove their saved payment methods impacts subscriptions that depend on that payment method.
289    /// Removing the payment method detaches the [`customer` object](https://docs.stripe.com/api/payment_methods/object#payment_method_object-customer) from that [PaymentMethod](https://docs.stripe.com/api/payment_methods).
290#[serde(skip_serializing_if = "Option::is_none")]
291pub payment_method_remove: Option<CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove>,
292        /// Controls whether the mobile payment element displays a checkbox offering to save a new payment method.
293    ///
294        /// If a customer checks the box, the [`allow_redisplay`](https://docs.stripe.com/api/payment_methods/object#payment_method_object-allow_redisplay) value on the PaymentMethod is set to `'always'` at confirmation time.
295    /// For PaymentIntents, the [`setup_future_usage`](https://docs.stripe.com/api/payment_intents/object#payment_intent_object-setup_future_usage) value is also set to the value defined in `payment_method_save_usage`.
296#[serde(skip_serializing_if = "Option::is_none")]
297pub payment_method_save: Option<CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave>,
298        /// Allows overriding the value of allow_override when saving a new payment method when payment_method_save is set to disabled.
299    /// Use values: "always", "limited", or "unspecified".
300    ///
301    /// If not specified, defaults to `nil` (no override value).
302#[serde(skip_serializing_if = "Option::is_none")]
303pub payment_method_save_allow_redisplay_override: Option<CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride>,
304
305}
306impl CreateCustomerSessionComponentsMobilePaymentElementFeatures {
307    pub fn new() -> Self {
308        Self {
309            payment_method_allow_redisplay_filters: None,
310            payment_method_redisplay: None,
311            payment_method_remove: None,
312            payment_method_save: None,
313            payment_method_save_allow_redisplay_override: None,
314        }
315    }
316}
317impl Default for CreateCustomerSessionComponentsMobilePaymentElementFeatures {
318    fn default() -> Self {
319        Self::new()
320    }
321}
322/// A list of [`allow_redisplay`](https://docs.stripe.com/api/payment_methods/object#payment_method_object-allow_redisplay) values that controls which saved payment methods the mobile payment element displays by filtering to only show payment methods with an `allow_redisplay` value that is present in this list.
323///
324/// If not specified, defaults to ["always"].
325/// In order to display all saved payment methods, specify ["always", "limited", "unspecified"].
326#[derive(Clone, Eq, PartialEq)]
327#[non_exhaustive]
328pub enum CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters
329{
330    Always,
331    Limited,
332    Unspecified,
333    /// An unrecognized value from Stripe. Should not be used as a request parameter.
334    Unknown(String),
335}
336impl CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
337    pub fn as_str(&self) -> &str {
338        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters::*;
339        match self {
340            Always => "always",
341            Limited => "limited",
342            Unspecified => "unspecified",
343            Unknown(v) => v,
344        }
345    }
346}
347
348impl std::str::FromStr for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
349    type Err = std::convert::Infallible;
350    fn from_str(s: &str) -> Result<Self, Self::Err> {
351        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters::*;
352        match s {
353    "always" => Ok(Always),
354"limited" => Ok(Limited),
355"unspecified" => Ok(Unspecified),
356v => { tracing::warn!("Unknown value '{}' for enum '{}'", v, "CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters"); Ok(Unknown(v.to_owned())) }
357
358        }
359    }
360}
361impl std::fmt::Display for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
362    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
363        f.write_str(self.as_str())
364    }
365}
366
367impl std::fmt::Debug for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
368    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
369        f.write_str(self.as_str())
370    }
371}
372impl serde::Serialize for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
373    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
374        serializer.serialize_str(self.as_str())
375    }
376}
377#[cfg(feature = "deserialize")]
378impl<'de> serde::Deserialize<'de> for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
379    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
380        use std::str::FromStr;
381        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
382        Ok(Self::from_str(&s).expect("infallible"))
383    }
384}
385/// Controls whether or not the mobile payment element shows saved payment methods.
386#[derive(Clone, Eq, PartialEq)]
387#[non_exhaustive]
388pub enum CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay {
389    Disabled,
390    Enabled,
391    /// An unrecognized value from Stripe. Should not be used as a request parameter.
392    Unknown(String),
393}
394impl CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay {
395    pub fn as_str(&self) -> &str {
396        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay::*;
397        match self {
398            Disabled => "disabled",
399            Enabled => "enabled",
400            Unknown(v) => v,
401        }
402    }
403}
404
405impl std::str::FromStr
406    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay
407{
408    type Err = std::convert::Infallible;
409    fn from_str(s: &str) -> Result<Self, Self::Err> {
410        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay::*;
411        match s {
412            "disabled" => Ok(Disabled),
413            "enabled" => Ok(Enabled),
414            v => {
415                tracing::warn!(
416                    "Unknown value '{}' for enum '{}'",
417                    v,
418                    "CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay"
419                );
420                Ok(Unknown(v.to_owned()))
421            }
422        }
423    }
424}
425impl std::fmt::Display
426    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay
427{
428    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
429        f.write_str(self.as_str())
430    }
431}
432
433impl std::fmt::Debug
434    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay
435{
436    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
437        f.write_str(self.as_str())
438    }
439}
440impl serde::Serialize
441    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay
442{
443    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
444    where
445        S: serde::Serializer,
446    {
447        serializer.serialize_str(self.as_str())
448    }
449}
450#[cfg(feature = "deserialize")]
451impl<'de> serde::Deserialize<'de>
452    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay
453{
454    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
455        use std::str::FromStr;
456        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
457        Ok(Self::from_str(&s).expect("infallible"))
458    }
459}
460/// Controls whether the mobile payment element displays the option to remove a saved payment method."
461///
462/// Allowing buyers to remove their saved payment methods impacts subscriptions that depend on that payment method.
463/// Removing the payment method detaches the [`customer` object](https://docs.stripe.com/api/payment_methods/object#payment_method_object-customer) from that [PaymentMethod](https://docs.stripe.com/api/payment_methods).
464#[derive(Clone, Eq, PartialEq)]
465#[non_exhaustive]
466pub enum CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove {
467    Disabled,
468    Enabled,
469    /// An unrecognized value from Stripe. Should not be used as a request parameter.
470    Unknown(String),
471}
472impl CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove {
473    pub fn as_str(&self) -> &str {
474        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove::*;
475        match self {
476            Disabled => "disabled",
477            Enabled => "enabled",
478            Unknown(v) => v,
479        }
480    }
481}
482
483impl std::str::FromStr
484    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove
485{
486    type Err = std::convert::Infallible;
487    fn from_str(s: &str) -> Result<Self, Self::Err> {
488        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove::*;
489        match s {
490            "disabled" => Ok(Disabled),
491            "enabled" => Ok(Enabled),
492            v => {
493                tracing::warn!(
494                    "Unknown value '{}' for enum '{}'",
495                    v,
496                    "CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove"
497                );
498                Ok(Unknown(v.to_owned()))
499            }
500        }
501    }
502}
503impl std::fmt::Display
504    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove
505{
506    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
507        f.write_str(self.as_str())
508    }
509}
510
511impl std::fmt::Debug
512    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove
513{
514    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
515        f.write_str(self.as_str())
516    }
517}
518impl serde::Serialize
519    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove
520{
521    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
522    where
523        S: serde::Serializer,
524    {
525        serializer.serialize_str(self.as_str())
526    }
527}
528#[cfg(feature = "deserialize")]
529impl<'de> serde::Deserialize<'de>
530    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove
531{
532    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
533        use std::str::FromStr;
534        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
535        Ok(Self::from_str(&s).expect("infallible"))
536    }
537}
538/// Controls whether the mobile payment element displays a checkbox offering to save a new payment method.
539///
540/// If a customer checks the box, the [`allow_redisplay`](https://docs.stripe.com/api/payment_methods/object#payment_method_object-allow_redisplay) value on the PaymentMethod is set to `'always'` at confirmation time.
541/// For PaymentIntents, the [`setup_future_usage`](https://docs.stripe.com/api/payment_intents/object#payment_intent_object-setup_future_usage) value is also set to the value defined in `payment_method_save_usage`.
542#[derive(Clone, Eq, PartialEq)]
543#[non_exhaustive]
544pub enum CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave {
545    Disabled,
546    Enabled,
547    /// An unrecognized value from Stripe. Should not be used as a request parameter.
548    Unknown(String),
549}
550impl CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave {
551    pub fn as_str(&self) -> &str {
552        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave::*;
553        match self {
554            Disabled => "disabled",
555            Enabled => "enabled",
556            Unknown(v) => v,
557        }
558    }
559}
560
561impl std::str::FromStr
562    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave
563{
564    type Err = std::convert::Infallible;
565    fn from_str(s: &str) -> Result<Self, Self::Err> {
566        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave::*;
567        match s {
568            "disabled" => Ok(Disabled),
569            "enabled" => Ok(Enabled),
570            v => {
571                tracing::warn!(
572                    "Unknown value '{}' for enum '{}'",
573                    v,
574                    "CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave"
575                );
576                Ok(Unknown(v.to_owned()))
577            }
578        }
579    }
580}
581impl std::fmt::Display
582    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave
583{
584    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
585        f.write_str(self.as_str())
586    }
587}
588
589impl std::fmt::Debug
590    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave
591{
592    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
593        f.write_str(self.as_str())
594    }
595}
596impl serde::Serialize
597    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave
598{
599    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
600    where
601        S: serde::Serializer,
602    {
603        serializer.serialize_str(self.as_str())
604    }
605}
606#[cfg(feature = "deserialize")]
607impl<'de> serde::Deserialize<'de>
608    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave
609{
610    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
611        use std::str::FromStr;
612        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
613        Ok(Self::from_str(&s).expect("infallible"))
614    }
615}
616/// Allows overriding the value of allow_override when saving a new payment method when payment_method_save is set to disabled.
617/// Use values: "always", "limited", or "unspecified".
618///
619/// If not specified, defaults to `nil` (no override value).
620#[derive(Clone, Eq, PartialEq)]
621#[non_exhaustive]
622pub enum CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride
623{
624    Always,
625    Limited,
626    Unspecified,
627    /// An unrecognized value from Stripe. Should not be used as a request parameter.
628    Unknown(String),
629}
630impl CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride {
631    pub fn as_str(&self) -> &str {
632        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride::*;
633        match self {
634Always => "always",
635Limited => "limited",
636Unspecified => "unspecified",
637Unknown(v) => v,
638
639        }
640    }
641}
642
643impl std::str::FromStr for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride {
644    type Err = std::convert::Infallible;
645    fn from_str(s: &str) -> Result<Self, Self::Err> {
646        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride::*;
647        match s {
648    "always" => Ok(Always),
649"limited" => Ok(Limited),
650"unspecified" => Ok(Unspecified),
651v => { tracing::warn!("Unknown value '{}' for enum '{}'", v, "CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride"); Ok(Unknown(v.to_owned())) }
652
653        }
654    }
655}
656impl std::fmt::Display for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride {
657    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
658        f.write_str(self.as_str())
659    }
660}
661
662impl std::fmt::Debug for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride {
663    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
664        f.write_str(self.as_str())
665    }
666}
667impl serde::Serialize for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride {
668    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
669        serializer.serialize_str(self.as_str())
670    }
671}
672#[cfg(feature = "deserialize")]
673impl<'de> serde::Deserialize<'de> for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride {
674    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
675        use std::str::FromStr;
676        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
677        Ok(Self::from_str(&s).expect("infallible"))
678    }
679}
680/// Configuration for the Payment Element.
681#[derive(Clone, Debug, serde::Serialize)]
682pub struct CreateCustomerSessionComponentsPaymentElement {
683    /// Whether the Payment Element is enabled.
684    pub enabled: bool,
685    /// This hash defines whether the Payment Element supports certain features.
686    #[serde(skip_serializing_if = "Option::is_none")]
687    pub features: Option<CreateCustomerSessionComponentsPaymentElementFeatures>,
688}
689impl CreateCustomerSessionComponentsPaymentElement {
690    pub fn new(enabled: impl Into<bool>) -> Self {
691        Self { enabled: enabled.into(), features: None }
692    }
693}
694/// This hash defines whether the Payment Element supports certain features.
695#[derive(Clone, Debug, serde::Serialize)]
696pub struct CreateCustomerSessionComponentsPaymentElementFeatures {
697    /// A list of [`allow_redisplay`](https://docs.stripe.com/api/payment_methods/object#payment_method_object-allow_redisplay) values that controls which saved payment methods the Payment Element displays by filtering to only show payment methods with an `allow_redisplay` value that is present in this list.
698    ///
699    /// If not specified, defaults to ["always"].
700    /// In order to display all saved payment methods, specify ["always", "limited", "unspecified"].
701    #[serde(skip_serializing_if = "Option::is_none")]
702    pub payment_method_allow_redisplay_filters: Option<
703        Vec<
704            CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters,
705        >,
706    >,
707    /// Controls whether or not the Payment Element shows saved payment methods.
708    /// This parameter defaults to `disabled`.
709    #[serde(skip_serializing_if = "Option::is_none")]
710    pub payment_method_redisplay:
711        Option<CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay>,
712    /// Determines the max number of saved payment methods for the Payment Element to display.
713    /// This parameter defaults to `3`.
714    /// The maximum redisplay limit is `10`.
715    #[serde(skip_serializing_if = "Option::is_none")]
716    pub payment_method_redisplay_limit: Option<i64>,
717    /// Controls whether the Payment Element displays the option to remove a saved payment method.
718    /// This parameter defaults to `disabled`.
719    ///
720    /// Allowing buyers to remove their saved payment methods impacts subscriptions that depend on that payment method.
721    /// Removing the payment method detaches the [`customer` object](https://docs.stripe.com/api/payment_methods/object#payment_method_object-customer) from that [PaymentMethod](https://docs.stripe.com/api/payment_methods).
722    #[serde(skip_serializing_if = "Option::is_none")]
723    pub payment_method_remove:
724        Option<CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove>,
725    /// Controls whether the Payment Element displays a checkbox offering to save a new payment method.
726    /// This parameter defaults to `disabled`.
727    ///
728    /// If a customer checks the box, the [`allow_redisplay`](https://docs.stripe.com/api/payment_methods/object#payment_method_object-allow_redisplay) value on the PaymentMethod is set to `'always'` at confirmation time.
729    /// For PaymentIntents, the [`setup_future_usage`](https://docs.stripe.com/api/payment_intents/object#payment_intent_object-setup_future_usage) value is also set to the value defined in `payment_method_save_usage`.
730    #[serde(skip_serializing_if = "Option::is_none")]
731    pub payment_method_save:
732        Option<CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave>,
733    /// When using PaymentIntents and the customer checks the save checkbox, this field determines the [`setup_future_usage`](https://docs.stripe.com/api/payment_intents/object#payment_intent_object-setup_future_usage) value used to confirm the PaymentIntent.
734    ///
735    /// When using SetupIntents, directly configure the [`usage`](https://docs.stripe.com/api/setup_intents/object#setup_intent_object-usage) value on SetupIntent creation.
736    #[serde(skip_serializing_if = "Option::is_none")]
737    pub payment_method_save_usage:
738        Option<CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage>,
739}
740impl CreateCustomerSessionComponentsPaymentElementFeatures {
741    pub fn new() -> Self {
742        Self {
743            payment_method_allow_redisplay_filters: None,
744            payment_method_redisplay: None,
745            payment_method_redisplay_limit: None,
746            payment_method_remove: None,
747            payment_method_save: None,
748            payment_method_save_usage: None,
749        }
750    }
751}
752impl Default for CreateCustomerSessionComponentsPaymentElementFeatures {
753    fn default() -> Self {
754        Self::new()
755    }
756}
757/// A list of [`allow_redisplay`](https://docs.stripe.com/api/payment_methods/object#payment_method_object-allow_redisplay) values that controls which saved payment methods the Payment Element displays by filtering to only show payment methods with an `allow_redisplay` value that is present in this list.
758///
759/// If not specified, defaults to ["always"].
760/// In order to display all saved payment methods, specify ["always", "limited", "unspecified"].
761#[derive(Clone, Eq, PartialEq)]
762#[non_exhaustive]
763pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
764    Always,
765    Limited,
766    Unspecified,
767    /// An unrecognized value from Stripe. Should not be used as a request parameter.
768    Unknown(String),
769}
770impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
771    pub fn as_str(&self) -> &str {
772        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters::*;
773        match self {
774            Always => "always",
775            Limited => "limited",
776            Unspecified => "unspecified",
777            Unknown(v) => v,
778        }
779    }
780}
781
782impl std::str::FromStr
783    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
784{
785    type Err = std::convert::Infallible;
786    fn from_str(s: &str) -> Result<Self, Self::Err> {
787        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters::*;
788        match s {
789            "always" => Ok(Always),
790            "limited" => Ok(Limited),
791            "unspecified" => Ok(Unspecified),
792            v => {
793                tracing::warn!(
794                    "Unknown value '{}' for enum '{}'",
795                    v,
796                    "CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters"
797                );
798                Ok(Unknown(v.to_owned()))
799            }
800        }
801    }
802}
803impl std::fmt::Display
804    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
805{
806    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
807        f.write_str(self.as_str())
808    }
809}
810
811impl std::fmt::Debug
812    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
813{
814    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
815        f.write_str(self.as_str())
816    }
817}
818impl serde::Serialize
819    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
820{
821    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
822    where
823        S: serde::Serializer,
824    {
825        serializer.serialize_str(self.as_str())
826    }
827}
828#[cfg(feature = "deserialize")]
829impl<'de> serde::Deserialize<'de>
830    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
831{
832    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
833        use std::str::FromStr;
834        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
835        Ok(Self::from_str(&s).expect("infallible"))
836    }
837}
838/// Controls whether or not the Payment Element shows saved payment methods.
839/// This parameter defaults to `disabled`.
840#[derive(Clone, Eq, PartialEq)]
841#[non_exhaustive]
842pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay {
843    Disabled,
844    Enabled,
845    /// An unrecognized value from Stripe. Should not be used as a request parameter.
846    Unknown(String),
847}
848impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay {
849    pub fn as_str(&self) -> &str {
850        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay::*;
851        match self {
852            Disabled => "disabled",
853            Enabled => "enabled",
854            Unknown(v) => v,
855        }
856    }
857}
858
859impl std::str::FromStr
860    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
861{
862    type Err = std::convert::Infallible;
863    fn from_str(s: &str) -> Result<Self, Self::Err> {
864        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay::*;
865        match s {
866            "disabled" => Ok(Disabled),
867            "enabled" => Ok(Enabled),
868            v => {
869                tracing::warn!(
870                    "Unknown value '{}' for enum '{}'",
871                    v,
872                    "CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay"
873                );
874                Ok(Unknown(v.to_owned()))
875            }
876        }
877    }
878}
879impl std::fmt::Display
880    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
881{
882    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
883        f.write_str(self.as_str())
884    }
885}
886
887impl std::fmt::Debug
888    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
889{
890    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
891        f.write_str(self.as_str())
892    }
893}
894impl serde::Serialize
895    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
896{
897    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
898    where
899        S: serde::Serializer,
900    {
901        serializer.serialize_str(self.as_str())
902    }
903}
904#[cfg(feature = "deserialize")]
905impl<'de> serde::Deserialize<'de>
906    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
907{
908    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
909        use std::str::FromStr;
910        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
911        Ok(Self::from_str(&s).expect("infallible"))
912    }
913}
914/// Controls whether the Payment Element displays the option to remove a saved payment method.
915/// This parameter defaults to `disabled`.
916///
917/// Allowing buyers to remove their saved payment methods impacts subscriptions that depend on that payment method.
918/// Removing the payment method detaches the [`customer` object](https://docs.stripe.com/api/payment_methods/object#payment_method_object-customer) from that [PaymentMethod](https://docs.stripe.com/api/payment_methods).
919#[derive(Clone, Eq, PartialEq)]
920#[non_exhaustive]
921pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove {
922    Disabled,
923    Enabled,
924    /// An unrecognized value from Stripe. Should not be used as a request parameter.
925    Unknown(String),
926}
927impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove {
928    pub fn as_str(&self) -> &str {
929        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove::*;
930        match self {
931            Disabled => "disabled",
932            Enabled => "enabled",
933            Unknown(v) => v,
934        }
935    }
936}
937
938impl std::str::FromStr
939    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove
940{
941    type Err = std::convert::Infallible;
942    fn from_str(s: &str) -> Result<Self, Self::Err> {
943        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove::*;
944        match s {
945            "disabled" => Ok(Disabled),
946            "enabled" => Ok(Enabled),
947            v => {
948                tracing::warn!(
949                    "Unknown value '{}' for enum '{}'",
950                    v,
951                    "CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove"
952                );
953                Ok(Unknown(v.to_owned()))
954            }
955        }
956    }
957}
958impl std::fmt::Display
959    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove
960{
961    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
962        f.write_str(self.as_str())
963    }
964}
965
966impl std::fmt::Debug for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove {
967    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
968        f.write_str(self.as_str())
969    }
970}
971impl serde::Serialize for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove {
972    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
973    where
974        S: serde::Serializer,
975    {
976        serializer.serialize_str(self.as_str())
977    }
978}
979#[cfg(feature = "deserialize")]
980impl<'de> serde::Deserialize<'de>
981    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove
982{
983    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
984        use std::str::FromStr;
985        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
986        Ok(Self::from_str(&s).expect("infallible"))
987    }
988}
989/// Controls whether the Payment Element displays a checkbox offering to save a new payment method.
990/// This parameter defaults to `disabled`.
991///
992/// If a customer checks the box, the [`allow_redisplay`](https://docs.stripe.com/api/payment_methods/object#payment_method_object-allow_redisplay) value on the PaymentMethod is set to `'always'` at confirmation time.
993/// For PaymentIntents, the [`setup_future_usage`](https://docs.stripe.com/api/payment_intents/object#payment_intent_object-setup_future_usage) value is also set to the value defined in `payment_method_save_usage`.
994#[derive(Clone, Eq, PartialEq)]
995#[non_exhaustive]
996pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
997    Disabled,
998    Enabled,
999    /// An unrecognized value from Stripe. Should not be used as a request parameter.
1000    Unknown(String),
1001}
1002impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
1003    pub fn as_str(&self) -> &str {
1004        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave::*;
1005        match self {
1006            Disabled => "disabled",
1007            Enabled => "enabled",
1008            Unknown(v) => v,
1009        }
1010    }
1011}
1012
1013impl std::str::FromStr for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
1014    type Err = std::convert::Infallible;
1015    fn from_str(s: &str) -> Result<Self, Self::Err> {
1016        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave::*;
1017        match s {
1018            "disabled" => Ok(Disabled),
1019            "enabled" => Ok(Enabled),
1020            v => {
1021                tracing::warn!(
1022                    "Unknown value '{}' for enum '{}'",
1023                    v,
1024                    "CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave"
1025                );
1026                Ok(Unknown(v.to_owned()))
1027            }
1028        }
1029    }
1030}
1031impl std::fmt::Display for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
1032    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1033        f.write_str(self.as_str())
1034    }
1035}
1036
1037impl std::fmt::Debug for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
1038    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1039        f.write_str(self.as_str())
1040    }
1041}
1042impl serde::Serialize for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
1043    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1044    where
1045        S: serde::Serializer,
1046    {
1047        serializer.serialize_str(self.as_str())
1048    }
1049}
1050#[cfg(feature = "deserialize")]
1051impl<'de> serde::Deserialize<'de>
1052    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave
1053{
1054    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1055        use std::str::FromStr;
1056        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
1057        Ok(Self::from_str(&s).expect("infallible"))
1058    }
1059}
1060/// When using PaymentIntents and the customer checks the save checkbox, this field determines the [`setup_future_usage`](https://docs.stripe.com/api/payment_intents/object#payment_intent_object-setup_future_usage) value used to confirm the PaymentIntent.
1061///
1062/// When using SetupIntents, directly configure the [`usage`](https://docs.stripe.com/api/setup_intents/object#setup_intent_object-usage) value on SetupIntent creation.
1063#[derive(Clone, Eq, PartialEq)]
1064#[non_exhaustive]
1065pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage {
1066    OffSession,
1067    OnSession,
1068    /// An unrecognized value from Stripe. Should not be used as a request parameter.
1069    Unknown(String),
1070}
1071impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage {
1072    pub fn as_str(&self) -> &str {
1073        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage::*;
1074        match self {
1075            OffSession => "off_session",
1076            OnSession => "on_session",
1077            Unknown(v) => v,
1078        }
1079    }
1080}
1081
1082impl std::str::FromStr
1083    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
1084{
1085    type Err = std::convert::Infallible;
1086    fn from_str(s: &str) -> Result<Self, Self::Err> {
1087        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage::*;
1088        match s {
1089            "off_session" => Ok(OffSession),
1090            "on_session" => Ok(OnSession),
1091            v => {
1092                tracing::warn!(
1093                    "Unknown value '{}' for enum '{}'",
1094                    v,
1095                    "CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage"
1096                );
1097                Ok(Unknown(v.to_owned()))
1098            }
1099        }
1100    }
1101}
1102impl std::fmt::Display
1103    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
1104{
1105    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1106        f.write_str(self.as_str())
1107    }
1108}
1109
1110impl std::fmt::Debug
1111    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
1112{
1113    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1114        f.write_str(self.as_str())
1115    }
1116}
1117impl serde::Serialize
1118    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
1119{
1120    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1121    where
1122        S: serde::Serializer,
1123    {
1124        serializer.serialize_str(self.as_str())
1125    }
1126}
1127#[cfg(feature = "deserialize")]
1128impl<'de> serde::Deserialize<'de>
1129    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
1130{
1131    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1132        use std::str::FromStr;
1133        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
1134        Ok(Self::from_str(&s).expect("infallible"))
1135    }
1136}
1137/// Configuration for the pricing table.
1138#[derive(Copy, Clone, Debug, serde::Serialize)]
1139pub struct CreateCustomerSessionComponentsPricingTable {
1140    /// Whether the pricing table is enabled.
1141    pub enabled: bool,
1142}
1143impl CreateCustomerSessionComponentsPricingTable {
1144    pub fn new(enabled: impl Into<bool>) -> Self {
1145        Self { enabled: enabled.into() }
1146    }
1147}
1148/// Creates a Customer Session object that includes a single-use client secret that you can use on your front-end to grant client-side API access for certain customer resources.
1149#[derive(Clone, Debug, serde::Serialize)]
1150pub struct CreateCustomerSession {
1151    inner: CreateCustomerSessionBuilder,
1152}
1153impl CreateCustomerSession {
1154    /// Construct a new `CreateCustomerSession`.
1155    pub fn new(
1156        components: impl Into<CreateCustomerSessionComponents>,
1157        customer: impl Into<String>,
1158    ) -> Self {
1159        Self { inner: CreateCustomerSessionBuilder::new(components.into(), customer.into()) }
1160    }
1161    /// Specifies which fields in the response should be expanded.
1162    pub fn expand(mut self, expand: impl Into<Vec<String>>) -> Self {
1163        self.inner.expand = Some(expand.into());
1164        self
1165    }
1166}
1167impl CreateCustomerSession {
1168    /// Send the request and return the deserialized response.
1169    pub async fn send<C: StripeClient>(
1170        &self,
1171        client: &C,
1172    ) -> Result<<Self as StripeRequest>::Output, C::Err> {
1173        self.customize().send(client).await
1174    }
1175
1176    /// Send the request and return the deserialized response, blocking until completion.
1177    pub fn send_blocking<C: StripeBlockingClient>(
1178        &self,
1179        client: &C,
1180    ) -> Result<<Self as StripeRequest>::Output, C::Err> {
1181        self.customize().send_blocking(client)
1182    }
1183}
1184
1185impl StripeRequest for CreateCustomerSession {
1186    type Output = stripe_core::CustomerSession;
1187
1188    fn build(&self) -> RequestBuilder {
1189        RequestBuilder::new(StripeMethod::Post, "/customer_sessions").form(&self.inner)
1190    }
1191}
stripe_core/customer_session/requests.rs

stripe_core/customer_session/
requests.rs
