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 Payment Element.
27    #[serde(skip_serializing_if = "Option::is_none")]
28    pub payment_element: Option<CreateCustomerSessionComponentsPaymentElement>,
29    /// Configuration for the pricing table.
30    #[serde(skip_serializing_if = "Option::is_none")]
31    pub pricing_table: Option<CreateCustomerSessionComponentsPricingTable>,
32}
33impl CreateCustomerSessionComponents {
34    pub fn new() -> Self {
35        Self { buy_button: None, payment_element: None, pricing_table: None }
36    }
37}
38impl Default for CreateCustomerSessionComponents {
39    fn default() -> Self {
40        Self::new()
41    }
42}
43/// Configuration for buy button.
44#[derive(Copy, Clone, Debug, serde::Serialize)]
45pub struct CreateCustomerSessionComponentsBuyButton {
46    /// Whether the buy button is enabled.
47    pub enabled: bool,
48}
49impl CreateCustomerSessionComponentsBuyButton {
50    pub fn new(enabled: impl Into<bool>) -> Self {
51        Self { enabled: enabled.into() }
52    }
53}
54/// Configuration for the Payment Element.
55#[derive(Clone, Debug, serde::Serialize)]
56pub struct CreateCustomerSessionComponentsPaymentElement {
57    /// Whether the Payment Element is enabled.
58    pub enabled: bool,
59    /// This hash defines whether the Payment Element supports certain features.
60    #[serde(skip_serializing_if = "Option::is_none")]
61    pub features: Option<CreateCustomerSessionComponentsPaymentElementFeatures>,
62}
63impl CreateCustomerSessionComponentsPaymentElement {
64    pub fn new(enabled: impl Into<bool>) -> Self {
65        Self { enabled: enabled.into(), features: None }
66    }
67}
68/// This hash defines whether the Payment Element supports certain features.
69#[derive(Clone, Debug, serde::Serialize)]
70pub struct CreateCustomerSessionComponentsPaymentElementFeatures {
71    /// 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.
72    ///
73    /// If not specified, defaults to ["always"].
74    /// In order to display all saved payment methods, specify ["always", "limited", "unspecified"].
75    #[serde(skip_serializing_if = "Option::is_none")]
76    pub payment_method_allow_redisplay_filters: Option<
77        Vec<
78            CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters,
79        >,
80    >,
81    /// Controls whether or not the Payment Element shows saved payment methods.
82    /// This parameter defaults to `disabled`.
83    #[serde(skip_serializing_if = "Option::is_none")]
84    pub payment_method_redisplay:
85        Option<CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay>,
86    /// Determines the max number of saved payment methods for the Payment Element to display.
87    /// This parameter defaults to `3`.
88    /// The maximum redisplay limit is `10`.
89    #[serde(skip_serializing_if = "Option::is_none")]
90    pub payment_method_redisplay_limit: Option<i64>,
91    /// Controls whether the Payment Element displays the option to remove a saved payment method.
92    /// This parameter defaults to `disabled`.
93    ///
94    /// Allowing buyers to remove their saved payment methods impacts subscriptions that depend on that payment method.
95    /// 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).
96    #[serde(skip_serializing_if = "Option::is_none")]
97    pub payment_method_remove:
98        Option<CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove>,
99    /// Controls whether the Payment Element displays a checkbox offering to save a new payment method.
100    /// This parameter defaults to `disabled`.
101    ///
102    /// 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.
103    /// 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`.
104    #[serde(skip_serializing_if = "Option::is_none")]
105    pub payment_method_save:
106        Option<CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave>,
107    /// 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.
108    ///
109    /// When using SetupIntents, directly configure the [`usage`](https://docs.stripe.com/api/setup_intents/object#setup_intent_object-usage) value on SetupIntent creation.
110    #[serde(skip_serializing_if = "Option::is_none")]
111    pub payment_method_save_usage:
112        Option<CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage>,
113}
114impl CreateCustomerSessionComponentsPaymentElementFeatures {
115    pub fn new() -> Self {
116        Self {
117            payment_method_allow_redisplay_filters: None,
118            payment_method_redisplay: None,
119            payment_method_redisplay_limit: None,
120            payment_method_remove: None,
121            payment_method_save: None,
122            payment_method_save_usage: None,
123        }
124    }
125}
126impl Default for CreateCustomerSessionComponentsPaymentElementFeatures {
127    fn default() -> Self {
128        Self::new()
129    }
130}
131/// 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.
132///
133/// If not specified, defaults to ["always"].
134/// In order to display all saved payment methods, specify ["always", "limited", "unspecified"].
135#[derive(Copy, Clone, Eq, PartialEq)]
136pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
137    Always,
138    Limited,
139    Unspecified,
140}
141impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters {
142    pub fn as_str(self) -> &'static str {
143        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters::*;
144        match self {
145            Always => "always",
146            Limited => "limited",
147            Unspecified => "unspecified",
148        }
149    }
150}
151
152impl std::str::FromStr
153    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
154{
155    type Err = stripe_types::StripeParseError;
156    fn from_str(s: &str) -> Result<Self, Self::Err> {
157        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters::*;
158        match s {
159            "always" => Ok(Always),
160            "limited" => Ok(Limited),
161            "unspecified" => Ok(Unspecified),
162            _ => Err(stripe_types::StripeParseError),
163        }
164    }
165}
166impl std::fmt::Display
167    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
168{
169    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
170        f.write_str(self.as_str())
171    }
172}
173
174impl std::fmt::Debug
175    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
176{
177    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
178        f.write_str(self.as_str())
179    }
180}
181impl serde::Serialize
182    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
183{
184    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
185    where
186        S: serde::Serializer,
187    {
188        serializer.serialize_str(self.as_str())
189    }
190}
191#[cfg(feature = "deserialize")]
192impl<'de> serde::Deserialize<'de>
193    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters
194{
195    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
196        use std::str::FromStr;
197        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
198        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodAllowRedisplayFilters"))
199    }
200}
201/// Controls whether or not the Payment Element shows saved payment methods.
202/// This parameter defaults to `disabled`.
203#[derive(Copy, Clone, Eq, PartialEq)]
204pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay {
205    Disabled,
206    Enabled,
207}
208impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay {
209    pub fn as_str(self) -> &'static str {
210        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay::*;
211        match self {
212            Disabled => "disabled",
213            Enabled => "enabled",
214        }
215    }
216}
217
218impl std::str::FromStr
219    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
220{
221    type Err = stripe_types::StripeParseError;
222    fn from_str(s: &str) -> Result<Self, Self::Err> {
223        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay::*;
224        match s {
225            "disabled" => Ok(Disabled),
226            "enabled" => Ok(Enabled),
227            _ => Err(stripe_types::StripeParseError),
228        }
229    }
230}
231impl std::fmt::Display
232    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
233{
234    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
235        f.write_str(self.as_str())
236    }
237}
238
239impl std::fmt::Debug
240    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
241{
242    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
243        f.write_str(self.as_str())
244    }
245}
246impl serde::Serialize
247    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
248{
249    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
250    where
251        S: serde::Serializer,
252    {
253        serializer.serialize_str(self.as_str())
254    }
255}
256#[cfg(feature = "deserialize")]
257impl<'de> serde::Deserialize<'de>
258    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay
259{
260    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
261        use std::str::FromStr;
262        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
263        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRedisplay"))
264    }
265}
266/// Controls whether the Payment Element displays the option to remove a saved payment method.
267/// This parameter defaults to `disabled`.
268///
269/// Allowing buyers to remove their saved payment methods impacts subscriptions that depend on that payment method.
270/// 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).
271#[derive(Copy, Clone, Eq, PartialEq)]
272pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove {
273    Disabled,
274    Enabled,
275}
276impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove {
277    pub fn as_str(self) -> &'static str {
278        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove::*;
279        match self {
280            Disabled => "disabled",
281            Enabled => "enabled",
282        }
283    }
284}
285
286impl std::str::FromStr
287    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove
288{
289    type Err = stripe_types::StripeParseError;
290    fn from_str(s: &str) -> Result<Self, Self::Err> {
291        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove::*;
292        match s {
293            "disabled" => Ok(Disabled),
294            "enabled" => Ok(Enabled),
295            _ => Err(stripe_types::StripeParseError),
296        }
297    }
298}
299impl std::fmt::Display
300    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove
301{
302    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
303        f.write_str(self.as_str())
304    }
305}
306
307impl std::fmt::Debug for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove {
308    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
309        f.write_str(self.as_str())
310    }
311}
312impl serde::Serialize for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove {
313    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
314    where
315        S: serde::Serializer,
316    {
317        serializer.serialize_str(self.as_str())
318    }
319}
320#[cfg(feature = "deserialize")]
321impl<'de> serde::Deserialize<'de>
322    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove
323{
324    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
325        use std::str::FromStr;
326        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
327        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodRemove"))
328    }
329}
330/// Controls whether the Payment Element displays a checkbox offering to save a new payment method.
331/// This parameter defaults to `disabled`.
332///
333/// 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.
334/// 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`.
335#[derive(Copy, Clone, Eq, PartialEq)]
336pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
337    Disabled,
338    Enabled,
339}
340impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
341    pub fn as_str(self) -> &'static str {
342        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave::*;
343        match self {
344            Disabled => "disabled",
345            Enabled => "enabled",
346        }
347    }
348}
349
350impl std::str::FromStr for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
351    type Err = stripe_types::StripeParseError;
352    fn from_str(s: &str) -> Result<Self, Self::Err> {
353        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave::*;
354        match s {
355            "disabled" => Ok(Disabled),
356            "enabled" => Ok(Enabled),
357            _ => Err(stripe_types::StripeParseError),
358        }
359    }
360}
361impl std::fmt::Display for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
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 CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
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 CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave {
373    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
374    where
375        S: serde::Serializer,
376    {
377        serializer.serialize_str(self.as_str())
378    }
379}
380#[cfg(feature = "deserialize")]
381impl<'de> serde::Deserialize<'de>
382    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave
383{
384    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
385        use std::str::FromStr;
386        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
387        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSave"))
388    }
389}
390/// 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.
391///
392/// When using SetupIntents, directly configure the [`usage`](https://docs.stripe.com/api/setup_intents/object#setup_intent_object-usage) value on SetupIntent creation.
393#[derive(Copy, Clone, Eq, PartialEq)]
394pub enum CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage {
395    OffSession,
396    OnSession,
397}
398impl CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage {
399    pub fn as_str(self) -> &'static str {
400        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage::*;
401        match self {
402            OffSession => "off_session",
403            OnSession => "on_session",
404        }
405    }
406}
407
408impl std::str::FromStr
409    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
410{
411    type Err = stripe_types::StripeParseError;
412    fn from_str(s: &str) -> Result<Self, Self::Err> {
413        use CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage::*;
414        match s {
415            "off_session" => Ok(OffSession),
416            "on_session" => Ok(OnSession),
417            _ => Err(stripe_types::StripeParseError),
418        }
419    }
420}
421impl std::fmt::Display
422    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
423{
424    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
425        f.write_str(self.as_str())
426    }
427}
428
429impl std::fmt::Debug
430    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
431{
432    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
433        f.write_str(self.as_str())
434    }
435}
436impl serde::Serialize
437    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
438{
439    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
440    where
441        S: serde::Serializer,
442    {
443        serializer.serialize_str(self.as_str())
444    }
445}
446#[cfg(feature = "deserialize")]
447impl<'de> serde::Deserialize<'de>
448    for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage
449{
450    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
451        use std::str::FromStr;
452        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
453        Self::from_str(&s).map_err(|_| serde::de::Error::custom("Unknown value for CreateCustomerSessionComponentsPaymentElementFeaturesPaymentMethodSaveUsage"))
454    }
455}
456/// Configuration for the pricing table.
457#[derive(Copy, Clone, Debug, serde::Serialize)]
458pub struct CreateCustomerSessionComponentsPricingTable {
459    /// Whether the pricing table is enabled.
460    pub enabled: bool,
461}
462impl CreateCustomerSessionComponentsPricingTable {
463    pub fn new(enabled: impl Into<bool>) -> Self {
464        Self { enabled: enabled.into() }
465    }
466}
467/// 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.
468#[derive(Clone, Debug, serde::Serialize)]
469pub struct CreateCustomerSession {
470    inner: CreateCustomerSessionBuilder,
471}
472impl CreateCustomerSession {
473    /// Construct a new `CreateCustomerSession`.
474    pub fn new(
475        components: impl Into<CreateCustomerSessionComponents>,
476        customer: impl Into<String>,
477    ) -> Self {
478        Self { inner: CreateCustomerSessionBuilder::new(components.into(), customer.into()) }
479    }
480    /// Specifies which fields in the response should be expanded.
481    pub fn expand(mut self, expand: impl Into<Vec<String>>) -> Self {
482        self.inner.expand = Some(expand.into());
483        self
484    }
485}
486impl CreateCustomerSession {
487    /// Send the request and return the deserialized response.
488    pub async fn send<C: StripeClient>(
489        &self,
490        client: &C,
491    ) -> Result<<Self as StripeRequest>::Output, C::Err> {
492        self.customize().send(client).await
493    }
494
495    /// Send the request and return the deserialized response, blocking until completion.
496    pub fn send_blocking<C: StripeBlockingClient>(
497        &self,
498        client: &C,
499    ) -> Result<<Self as StripeRequest>::Output, C::Err> {
500        self.customize().send_blocking(client)
501    }
502}
503
504impl StripeRequest for CreateCustomerSession {
505    type Output = stripe_core::CustomerSession;
506
507    fn build(&self) -> RequestBuilder {
508        RequestBuilder::new(StripeMethod::Post, "/customer_sessions").form(&self.inner)
509    }
510}
stripe_core/customer_session/requests.rs

stripe_core/customer_session/
requests.rs
