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. Exactly 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(Copy, Clone, Eq, PartialEq)]
114pub enum CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters {
115    Always,
116    Limited,
117    Unspecified,
118}
119impl CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters {
120    pub fn as_str(self) -> &'static str {
121        use CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters::*;
122        match self {
123            Always => "always",
124            Limited => "limited",
125            Unspecified => "unspecified",
126        }
127    }
128}
129
130impl std::str::FromStr
131    for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters
132{
133    type Err = stripe_types::StripeParseError;
134    fn from_str(s: &str) -> Result<Self, Self::Err> {
135        use CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters::*;
136        match s {
137            "always" => Ok(Always),
138            "limited" => Ok(Limited),
139            "unspecified" => Ok(Unspecified),
140            _ => Err(stripe_types::StripeParseError),
141        }
142    }
143}
144impl std::fmt::Display
145    for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters
146{
147    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
148        f.write_str(self.as_str())
149    }
150}
151
152impl std::fmt::Debug
153    for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters
154{
155    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
156        f.write_str(self.as_str())
157    }
158}
159impl serde::Serialize
160    for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters
161{
162    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
163    where
164        S: serde::Serializer,
165    {
166        serializer.serialize_str(self.as_str())
167    }
168}
169#[cfg(feature = "deserialize")]
170impl<'de> serde::Deserialize<'de>
171    for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters
172{
173    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
174        use std::str::FromStr;
175        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
176        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodAllowRedisplayFilters"))
177    }
178}
179/// Controls whether the customer sheet displays the option to remove a saved payment method."
180///
181/// Allowing buyers to remove their saved payment methods impacts subscriptions that depend on that payment method.
182/// 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).
183#[derive(Copy, Clone, Eq, PartialEq)]
184pub enum CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove {
185    Disabled,
186    Enabled,
187}
188impl CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove {
189    pub fn as_str(self) -> &'static str {
190        use CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove::*;
191        match self {
192            Disabled => "disabled",
193            Enabled => "enabled",
194        }
195    }
196}
197
198impl std::str::FromStr for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove {
199    type Err = stripe_types::StripeParseError;
200    fn from_str(s: &str) -> Result<Self, Self::Err> {
201        use CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove::*;
202        match s {
203            "disabled" => Ok(Disabled),
204            "enabled" => Ok(Enabled),
205            _ => Err(stripe_types::StripeParseError),
206        }
207    }
208}
209impl std::fmt::Display for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove {
210    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
211        f.write_str(self.as_str())
212    }
213}
214
215impl std::fmt::Debug for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove {
216    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
217        f.write_str(self.as_str())
218    }
219}
220impl serde::Serialize for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove {
221    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
222    where
223        S: serde::Serializer,
224    {
225        serializer.serialize_str(self.as_str())
226    }
227}
228#[cfg(feature = "deserialize")]
229impl<'de> serde::Deserialize<'de>
230    for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove
231{
232    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
233        use std::str::FromStr;
234        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
235        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsCustomerSheetFeaturesPaymentMethodRemove"))
236    }
237}
238/// Configuration for the mobile payment element.
239#[derive(Clone, Debug, serde::Serialize)]
240pub struct CreateCustomerSessionComponentsMobilePaymentElement {
241    /// Whether the mobile payment element is enabled.
242    pub enabled: bool,
243    /// This hash defines whether the mobile payment element supports certain features.
244    #[serde(skip_serializing_if = "Option::is_none")]
245    pub features: Option<CreateCustomerSessionComponentsMobilePaymentElementFeatures>,
246}
247impl CreateCustomerSessionComponentsMobilePaymentElement {
248    pub fn new(enabled: impl Into<bool>) -> Self {
249        Self { enabled: enabled.into(), features: None }
250    }
251}
252/// This hash defines whether the mobile payment element supports certain features.
253#[derive(Clone, Debug, serde::Serialize)]
254pub struct CreateCustomerSessionComponentsMobilePaymentElementFeatures {
255        /// 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.
256    ///
257        /// If not specified, defaults to ["always"].
258    /// In order to display all saved payment methods, specify ["always", "limited", "unspecified"].
259#[serde(skip_serializing_if = "Option::is_none")]
260pub payment_method_allow_redisplay_filters: Option<Vec<CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters>>,
261    /// Controls whether or not the mobile payment element shows saved payment methods.
262#[serde(skip_serializing_if = "Option::is_none")]
263pub payment_method_redisplay: Option<CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay>,
264    /// Controls whether the mobile payment element displays the option to remove a saved payment method."
265    ///
266        /// Allowing buyers to remove their saved payment methods impacts subscriptions that depend on that payment method.
267    /// 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).
268#[serde(skip_serializing_if = "Option::is_none")]
269pub payment_method_remove: Option<CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove>,
270        /// Controls whether the mobile payment element displays a checkbox offering to save a new payment method.
271    ///
272        /// 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.
273    /// 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`.
274#[serde(skip_serializing_if = "Option::is_none")]
275pub payment_method_save: Option<CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave>,
276        /// Allows overriding the value of allow_override when saving a new payment method when payment_method_save is set to disabled.
277    /// Use values: "always", "limited", or "unspecified".
278    ///
279    /// If not specified, defaults to `nil` (no override value).
280#[serde(skip_serializing_if = "Option::is_none")]
281pub payment_method_save_allow_redisplay_override: Option<CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride>,
282
283}
284impl CreateCustomerSessionComponentsMobilePaymentElementFeatures {
285    pub fn new() -> Self {
286        Self {
287            payment_method_allow_redisplay_filters: None,
288            payment_method_redisplay: None,
289            payment_method_remove: None,
290            payment_method_save: None,
291            payment_method_save_allow_redisplay_override: None,
292        }
293    }
294}
295impl Default for CreateCustomerSessionComponentsMobilePaymentElementFeatures {
296    fn default() -> Self {
297        Self::new()
298    }
299}
300/// 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.
301///
302/// If not specified, defaults to ["always"].
303/// In order to display all saved payment methods, specify ["always", "limited", "unspecified"].
304#[derive(Copy, Clone, Eq, PartialEq)]
305pub enum CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters
306{
307    Always,
308    Limited,
309    Unspecified,
310}
311impl CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
312    pub fn as_str(self) -> &'static str {
313        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters::*;
314        match self {
315            Always => "always",
316            Limited => "limited",
317            Unspecified => "unspecified",
318        }
319    }
320}
321
322impl std::str::FromStr for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
323    type Err = stripe_types::StripeParseError;
324    fn from_str(s: &str) -> Result<Self, Self::Err> {
325        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters::*;
326        match s {
327    "always" => Ok(Always),
328"limited" => Ok(Limited),
329"unspecified" => Ok(Unspecified),
330_ => Err(stripe_types::StripeParseError)
331
332        }
333    }
334}
335impl std::fmt::Display for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
336    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
337        f.write_str(self.as_str())
338    }
339}
340
341impl std::fmt::Debug for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
342    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
343        f.write_str(self.as_str())
344    }
345}
346impl serde::Serialize for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
347    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
348        serializer.serialize_str(self.as_str())
349    }
350}
351#[cfg(feature = "deserialize")]
352impl<'de> serde::Deserialize<'de> for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
353    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
354        use std::str::FromStr;
355        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
356        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodAllowRedisplayFilters"))
357    }
358}
359/// Controls whether or not the mobile payment element shows saved payment methods.
360#[derive(Copy, Clone, Eq, PartialEq)]
361pub enum CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay {
362    Disabled,
363    Enabled,
364}
365impl CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay {
366    pub fn as_str(self) -> &'static str {
367        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay::*;
368        match self {
369            Disabled => "disabled",
370            Enabled => "enabled",
371        }
372    }
373}
374
375impl std::str::FromStr
376    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay
377{
378    type Err = stripe_types::StripeParseError;
379    fn from_str(s: &str) -> Result<Self, Self::Err> {
380        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay::*;
381        match s {
382            "disabled" => Ok(Disabled),
383            "enabled" => Ok(Enabled),
384            _ => Err(stripe_types::StripeParseError),
385        }
386    }
387}
388impl std::fmt::Display
389    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay
390{
391    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
392        f.write_str(self.as_str())
393    }
394}
395
396impl std::fmt::Debug
397    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay
398{
399    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
400        f.write_str(self.as_str())
401    }
402}
403impl serde::Serialize
404    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay
405{
406    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
407    where
408        S: serde::Serializer,
409    {
410        serializer.serialize_str(self.as_str())
411    }
412}
413#[cfg(feature = "deserialize")]
414impl<'de> serde::Deserialize<'de>
415    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay
416{
417    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
418        use std::str::FromStr;
419        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
420        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRedisplay"))
421    }
422}
423/// Controls whether the mobile payment element displays the option to remove a saved payment method."
424///
425/// Allowing buyers to remove their saved payment methods impacts subscriptions that depend on that payment method.
426/// 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).
427#[derive(Copy, Clone, Eq, PartialEq)]
428pub enum CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove {
429    Disabled,
430    Enabled,
431}
432impl CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove {
433    pub fn as_str(self) -> &'static str {
434        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove::*;
435        match self {
436            Disabled => "disabled",
437            Enabled => "enabled",
438        }
439    }
440}
441
442impl std::str::FromStr
443    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove
444{
445    type Err = stripe_types::StripeParseError;
446    fn from_str(s: &str) -> Result<Self, Self::Err> {
447        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove::*;
448        match s {
449            "disabled" => Ok(Disabled),
450            "enabled" => Ok(Enabled),
451            _ => Err(stripe_types::StripeParseError),
452        }
453    }
454}
455impl std::fmt::Display
456    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove
457{
458    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
459        f.write_str(self.as_str())
460    }
461}
462
463impl std::fmt::Debug
464    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove
465{
466    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
467        f.write_str(self.as_str())
468    }
469}
470impl serde::Serialize
471    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove
472{
473    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
474    where
475        S: serde::Serializer,
476    {
477        serializer.serialize_str(self.as_str())
478    }
479}
480#[cfg(feature = "deserialize")]
481impl<'de> serde::Deserialize<'de>
482    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove
483{
484    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
485        use std::str::FromStr;
486        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
487        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodRemove"))
488    }
489}
490/// Controls whether the mobile payment element displays a checkbox offering to save a new payment method.
491///
492/// 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.
493/// 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`.
494#[derive(Copy, Clone, Eq, PartialEq)]
495pub enum CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave {
496    Disabled,
497    Enabled,
498}
499impl CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave {
500    pub fn as_str(self) -> &'static str {
501        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave::*;
502        match self {
503            Disabled => "disabled",
504            Enabled => "enabled",
505        }
506    }
507}
508
509impl std::str::FromStr
510    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave
511{
512    type Err = stripe_types::StripeParseError;
513    fn from_str(s: &str) -> Result<Self, Self::Err> {
514        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave::*;
515        match s {
516            "disabled" => Ok(Disabled),
517            "enabled" => Ok(Enabled),
518            _ => Err(stripe_types::StripeParseError),
519        }
520    }
521}
522impl std::fmt::Display
523    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave
524{
525    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
526        f.write_str(self.as_str())
527    }
528}
529
530impl std::fmt::Debug
531    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave
532{
533    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
534        f.write_str(self.as_str())
535    }
536}
537impl serde::Serialize
538    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave
539{
540    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
541    where
542        S: serde::Serializer,
543    {
544        serializer.serialize_str(self.as_str())
545    }
546}
547#[cfg(feature = "deserialize")]
548impl<'de> serde::Deserialize<'de>
549    for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave
550{
551    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
552        use std::str::FromStr;
553        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
554        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSave"))
555    }
556}
557/// Allows overriding the value of allow_override when saving a new payment method when payment_method_save is set to disabled.
558/// Use values: "always", "limited", or "unspecified".
559///
560/// If not specified, defaults to `nil` (no override value).
561#[derive(Copy, Clone, Eq, PartialEq)]
562pub enum CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride
563{
564    Always,
565    Limited,
566    Unspecified,
567}
568impl CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride {
569    pub fn as_str(self) -> &'static str {
570        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride::*;
571        match self {
572Always => "always",
573Limited => "limited",
574Unspecified => "unspecified",
575
576        }
577    }
578}
579
580impl std::str::FromStr for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride {
581    type Err = stripe_types::StripeParseError;
582    fn from_str(s: &str) -> Result<Self, Self::Err> {
583        use CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride::*;
584        match s {
585    "always" => Ok(Always),
586"limited" => Ok(Limited),
587"unspecified" => Ok(Unspecified),
588_ => Err(stripe_types::StripeParseError)
589
590        }
591    }
592}
593impl std::fmt::Display for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride {
594    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
595        f.write_str(self.as_str())
596    }
597}
598
599impl std::fmt::Debug for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride {
600    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
601        f.write_str(self.as_str())
602    }
603}
604impl serde::Serialize for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride {
605    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
606        serializer.serialize_str(self.as_str())
607    }
608}
609#[cfg(feature = "deserialize")]
610impl<'de> serde::Deserialize<'de> for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride {
611    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
612        use std::str::FromStr;
613        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
614        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsMobilePaymentElementFeaturesPaymentMethodSaveAllowRedisplayOverride"))
615    }
616}
617/// Configuration for the Payment Element.
618#[derive(Clone, Debug, serde::Serialize)]
619pub struct CreateCustomerSessionComponentsPaymentElement {
620    /// Whether the Payment Element is enabled.
621    pub enabled: bool,
622    /// This hash defines whether the Payment Element supports certain features.
623    #[serde(skip_serializing_if = "Option::is_none")]
624    pub features: Option<CreateCustomerSessionComponentsPaymentElementFeatures>,
625}
626impl CreateCustomerSessionComponentsPaymentElement {
627    pub fn new(enabled: impl Into<bool>) -> Self {
628        Self { enabled: enabled.into(), features: None }
629    }
630}
631/// This hash defines whether the Payment Element supports certain features.
632#[derive(Clone, Debug, serde::Serialize)]
633pub struct CreateCustomerSessionComponentsPaymentElementFeatures {
634    /// 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.
635    ///
636    /// If not specified, defaults to ["always"].
637    /// In order to display all saved payment methods, specify ["always", "limited", "unspecified"].
638    #[serde(skip_serializing_if = "Option::is_none")]
639    pub payment_method_allow_redisplay_filters: Option<
640        Vec<
641            CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters,
642        >,
643    >,
644    /// Controls whether or not the Payment Element shows saved payment methods.
645    /// This parameter defaults to `disabled`.
646    #[serde(skip_serializing_if = "Option::is_none")]
647    pub payment_method_redisplay:
648        Option<CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay>,
649    /// Determines the max number of saved payment methods for the Payment Element to display.
650    /// This parameter defaults to `3`.
651    /// The maximum redisplay limit is `10`.
652    #[serde(skip_serializing_if = "Option::is_none")]
653    pub payment_method_redisplay_limit: Option<i64>,
654    /// Controls whether the Payment Element displays the option to remove a saved payment method.
655    /// This parameter defaults to `disabled`.
656    ///
657    /// Allowing buyers to remove their saved payment methods impacts subscriptions that depend on that payment method.
658    /// 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).
659    #[serde(skip_serializing_if = "Option::is_none")]
660    pub payment_method_remove:
661        Option<CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove>,
662    /// Controls whether the Payment Element displays a checkbox offering to save a new payment method.
663    /// This parameter defaults to `disabled`.
664    ///
665    /// 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.
666    /// 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`.
667    #[serde(skip_serializing_if = "Option::is_none")]
668    pub payment_method_save:
669        Option<CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave>,
670    /// 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.
671    ///
672    /// When using SetupIntents, directly configure the [`usage`](https://docs.stripe.com/api/setup_intents/object#setup_intent_object-usage) value on SetupIntent creation.
673    #[serde(skip_serializing_if = "Option::is_none")]
674    pub payment_method_save_usage:
675        Option<CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage>,
676}
677impl CreateCustomerSessionComponentsPaymentElementFeatures {
678    pub fn new() -> Self {
679        Self {
680            payment_method_allow_redisplay_filters: None,
681            payment_method_redisplay: None,
682            payment_method_redisplay_limit: None,
683            payment_method_remove: None,
684            payment_method_save: None,
685            payment_method_save_usage: None,
686        }
687    }
688}
689impl Default for CreateCustomerSessionComponentsPaymentElementFeatures {
690    fn default() -> Self {
691        Self::new()
692    }
693}
694/// 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.
695///
696/// If not specified, defaults to ["always"].
697/// In order to display all saved payment methods, specify ["always", "limited", "unspecified"].
698#[derive(Copy, Clone, Eq, PartialEq)]
699pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
700    Always,
701    Limited,
702    Unspecified,
703}
704impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
705    pub fn as_str(self) -> &'static str {
706        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters::*;
707        match self {
708            Always => "always",
709            Limited => "limited",
710            Unspecified => "unspecified",
711        }
712    }
713}
714
715impl std::str::FromStr
716    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
717{
718    type Err = stripe_types::StripeParseError;
719    fn from_str(s: &str) -> Result<Self, Self::Err> {
720        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters::*;
721        match s {
722            "always" => Ok(Always),
723            "limited" => Ok(Limited),
724            "unspecified" => Ok(Unspecified),
725            _ => Err(stripe_types::StripeParseError),
726        }
727    }
728}
729impl std::fmt::Display
730    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
731{
732    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
733        f.write_str(self.as_str())
734    }
735}
736
737impl std::fmt::Debug
738    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
739{
740    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
741        f.write_str(self.as_str())
742    }
743}
744impl serde::Serialize
745    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
746{
747    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
748    where
749        S: serde::Serializer,
750    {
751        serializer.serialize_str(self.as_str())
752    }
753}
754#[cfg(feature = "deserialize")]
755impl<'de> serde::Deserialize<'de>
756    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
757{
758    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
759        use std::str::FromStr;
760        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
761        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters"))
762    }
763}
764/// Controls whether or not the Payment Element shows saved payment methods.
765/// This parameter defaults to `disabled`.
766#[derive(Copy, Clone, Eq, PartialEq)]
767pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay {
768    Disabled,
769    Enabled,
770}
771impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay {
772    pub fn as_str(self) -> &'static str {
773        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay::*;
774        match self {
775            Disabled => "disabled",
776            Enabled => "enabled",
777        }
778    }
779}
780
781impl std::str::FromStr
782    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
783{
784    type Err = stripe_types::StripeParseError;
785    fn from_str(s: &str) -> Result<Self, Self::Err> {
786        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay::*;
787        match s {
788            "disabled" => Ok(Disabled),
789            "enabled" => Ok(Enabled),
790            _ => Err(stripe_types::StripeParseError),
791        }
792    }
793}
794impl std::fmt::Display
795    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
796{
797    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
798        f.write_str(self.as_str())
799    }
800}
801
802impl std::fmt::Debug
803    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
804{
805    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
806        f.write_str(self.as_str())
807    }
808}
809impl serde::Serialize
810    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
811{
812    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
813    where
814        S: serde::Serializer,
815    {
816        serializer.serialize_str(self.as_str())
817    }
818}
819#[cfg(feature = "deserialize")]
820impl<'de> serde::Deserialize<'de>
821    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
822{
823    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
824        use std::str::FromStr;
825        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
826        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay"))
827    }
828}
829/// Controls whether the Payment Element displays the option to remove a saved payment method.
830/// This parameter defaults to `disabled`.
831///
832/// Allowing buyers to remove their saved payment methods impacts subscriptions that depend on that payment method.
833/// 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).
834#[derive(Copy, Clone, Eq, PartialEq)]
835pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove {
836    Disabled,
837    Enabled,
838}
839impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove {
840    pub fn as_str(self) -> &'static str {
841        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove::*;
842        match self {
843            Disabled => "disabled",
844            Enabled => "enabled",
845        }
846    }
847}
848
849impl std::str::FromStr
850    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove
851{
852    type Err = stripe_types::StripeParseError;
853    fn from_str(s: &str) -> Result<Self, Self::Err> {
854        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove::*;
855        match s {
856            "disabled" => Ok(Disabled),
857            "enabled" => Ok(Enabled),
858            _ => Err(stripe_types::StripeParseError),
859        }
860    }
861}
862impl std::fmt::Display
863    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove
864{
865    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
866        f.write_str(self.as_str())
867    }
868}
869
870impl std::fmt::Debug for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove {
871    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
872        f.write_str(self.as_str())
873    }
874}
875impl serde::Serialize for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove {
876    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
877    where
878        S: serde::Serializer,
879    {
880        serializer.serialize_str(self.as_str())
881    }
882}
883#[cfg(feature = "deserialize")]
884impl<'de> serde::Deserialize<'de>
885    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove
886{
887    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
888        use std::str::FromStr;
889        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
890        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove"))
891    }
892}
893/// Controls whether the Payment Element displays a checkbox offering to save a new payment method.
894/// This parameter defaults to `disabled`.
895///
896/// 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.
897/// 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`.
898#[derive(Copy, Clone, Eq, PartialEq)]
899pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
900    Disabled,
901    Enabled,
902}
903impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
904    pub fn as_str(self) -> &'static str {
905        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave::*;
906        match self {
907            Disabled => "disabled",
908            Enabled => "enabled",
909        }
910    }
911}
912
913impl std::str::FromStr for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
914    type Err = stripe_types::StripeParseError;
915    fn from_str(s: &str) -> Result<Self, Self::Err> {
916        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave::*;
917        match s {
918            "disabled" => Ok(Disabled),
919            "enabled" => Ok(Enabled),
920            _ => Err(stripe_types::StripeParseError),
921        }
922    }
923}
924impl std::fmt::Display for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
925    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
926        f.write_str(self.as_str())
927    }
928}
929
930impl std::fmt::Debug for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
931    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
932        f.write_str(self.as_str())
933    }
934}
935impl serde::Serialize for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
936    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
937    where
938        S: serde::Serializer,
939    {
940        serializer.serialize_str(self.as_str())
941    }
942}
943#[cfg(feature = "deserialize")]
944impl<'de> serde::Deserialize<'de>
945    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave
946{
947    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
948        use std::str::FromStr;
949        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
950        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave"))
951    }
952}
953/// 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.
954///
955/// When using SetupIntents, directly configure the [`usage`](https://docs.stripe.com/api/setup_intents/object#setup_intent_object-usage) value on SetupIntent creation.
956#[derive(Copy, Clone, Eq, PartialEq)]
957pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage {
958    OffSession,
959    OnSession,
960}
961impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage {
962    pub fn as_str(self) -> &'static str {
963        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage::*;
964        match self {
965            OffSession => "off_session",
966            OnSession => "on_session",
967        }
968    }
969}
970
971impl std::str::FromStr
972    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
973{
974    type Err = stripe_types::StripeParseError;
975    fn from_str(s: &str) -> Result<Self, Self::Err> {
976        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage::*;
977        match s {
978            "off_session" => Ok(OffSession),
979            "on_session" => Ok(OnSession),
980            _ => Err(stripe_types::StripeParseError),
981        }
982    }
983}
984impl std::fmt::Display
985    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
986{
987    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
988        f.write_str(self.as_str())
989    }
990}
991
992impl std::fmt::Debug
993    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
994{
995    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
996        f.write_str(self.as_str())
997    }
998}
999impl serde::Serialize
1000    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
1001{
1002    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1003    where
1004        S: serde::Serializer,
1005    {
1006        serializer.serialize_str(self.as_str())
1007    }
1008}
1009#[cfg(feature = "deserialize")]
1010impl<'de> serde::Deserialize<'de>
1011    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
1012{
1013    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1014        use std::str::FromStr;
1015        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
1016        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage"))
1017    }
1018}
1019/// Configuration for the pricing table.
1020#[derive(Copy, Clone, Debug, serde::Serialize)]
1021pub struct CreateCustomerSessionComponentsPricingTable {
1022    /// Whether the pricing table is enabled.
1023    pub enabled: bool,
1024}
1025impl CreateCustomerSessionComponentsPricingTable {
1026    pub fn new(enabled: impl Into<bool>) -> Self {
1027        Self { enabled: enabled.into() }
1028    }
1029}
1030/// 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.
1031#[derive(Clone, Debug, serde::Serialize)]
1032pub struct CreateCustomerSession {
1033    inner: CreateCustomerSessionBuilder,
1034}
1035impl CreateCustomerSession {
1036    /// Construct a new `CreateCustomerSession`.
1037    pub fn new(
1038        components: impl Into<CreateCustomerSessionComponents>,
1039        customer: impl Into<String>,
1040    ) -> Self {
1041        Self { inner: CreateCustomerSessionBuilder::new(components.into(), customer.into()) }
1042    }
1043    /// Specifies which fields in the response should be expanded.
1044    pub fn expand(mut self, expand: impl Into<Vec<String>>) -> Self {
1045        self.inner.expand = Some(expand.into());
1046        self
1047    }
1048}
1049impl CreateCustomerSession {
1050    /// Send the request and return the deserialized response.
1051    pub async fn send<C: StripeClient>(
1052        &self,
1053        client: &C,
1054    ) -> Result<<Self as StripeRequest>::Output, C::Err> {
1055        self.customize().send(client).await
1056    }
1057
1058    /// Send the request and return the deserialized response, blocking until completion.
1059    pub fn send_blocking<C: StripeBlockingClient>(
1060        &self,
1061        client: &C,
1062    ) -> Result<<Self as StripeRequest>::Output, C::Err> {
1063        self.customize().send_blocking(client)
1064    }
1065}
1066
1067impl StripeRequest for CreateCustomerSession {
1068    type Output = stripe_core::CustomerSession;
1069
1070    fn build(&self) -> RequestBuilder {
1071        RequestBuilder::new(StripeMethod::Post, "/customer_sessions").form(&self.inner)
1072    }
1073}
stripe_core/customer_session/requests.rs

stripe_core/customer_session/
requests.rs
