stripe_shared/
checkout_card_payment_method_options.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct CheckoutCardPaymentMethodOptions {
5    /// Controls when the funds will be captured from the customer's account.
6    pub capture_method: Option<CheckoutCardPaymentMethodOptionsCaptureMethod>,
7    pub installments: Option<stripe_shared::CheckoutCardInstallmentsOptions>,
8    /// Request ability to [capture beyond the standard authorization validity window](/payments/extended-authorization) for this CheckoutSession.
9    pub request_extended_authorization:
10        Option<CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization>,
11    /// Request ability to [increment the authorization](/payments/incremental-authorization) for this CheckoutSession.
12    pub request_incremental_authorization:
13        Option<CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization>,
14    /// Request ability to make [multiple captures](/payments/multicapture) for this CheckoutSession.
15    pub request_multicapture: Option<CheckoutCardPaymentMethodOptionsRequestMulticapture>,
16    /// Request ability to [overcapture](/payments/overcapture) for this CheckoutSession.
17    pub request_overcapture: Option<CheckoutCardPaymentMethodOptionsRequestOvercapture>,
18    /// We strongly recommend that you rely on our SCA Engine to automatically prompt your customers for authentication based on risk level and [other requirements](https://stripe.com/docs/strong-customer-authentication).
19    /// However, if you wish to request 3D Secure based on logic from your own fraud engine, provide this option.
20    /// If not provided, this value defaults to `automatic`.
21    /// Read our guide on [manually requesting 3D Secure](https://stripe.com/docs/payments/3d-secure/authentication-flow#manual-three-ds) for more information on how this configuration interacts with Radar and our SCA Engine.
22    pub request_three_d_secure: CheckoutCardPaymentMethodOptionsRequestThreeDSecure,
23    pub restrictions:
24        Option<stripe_shared::PaymentPagesPrivateCardPaymentMethodOptionsResourceRestrictions>,
25    /// Indicates that you intend to make future payments with this PaymentIntent's payment method.
26    ///
27    /// If you provide a Customer with the PaymentIntent, you can use this parameter to [attach the payment method](/payments/save-during-payment) to the Customer after the PaymentIntent is confirmed and the customer completes any required actions.
28    /// If you don't provide a Customer, you can still [attach](/api/payment_methods/attach) the payment method to a Customer after the transaction completes.
29    ///
30    /// If the payment method is `card_present` and isn't a digital wallet, Stripe creates and attaches a [generated_card](/api/charges/object#charge_object-payment_method_details-card_present-generated_card) payment method representing the card to the Customer instead.
31    ///
32    /// When processing card payments, Stripe uses `setup_future_usage` to help you comply with regional legislation and network rules, such as [SCA](/strong-customer-authentication).
33    pub setup_future_usage: Option<CheckoutCardPaymentMethodOptionsSetupFutureUsage>,
34    /// Provides information about a card payment that customers see on their statements.
35    /// Concatenated with the Kana prefix (shortened Kana descriptor) or Kana statement descriptor that’s set on the account to form the complete statement descriptor.
36    /// Maximum 22 characters.
37    /// On card statements, the *concatenation* of both prefix and suffix (including separators) will appear truncated to 22 characters.
38    pub statement_descriptor_suffix_kana: Option<String>,
39    /// Provides information about a card payment that customers see on their statements.
40    /// Concatenated with the Kanji prefix (shortened Kanji descriptor) or Kanji statement descriptor that’s set on the account to form the complete statement descriptor.
41    /// Maximum 17 characters.
42    /// On card statements, the *concatenation* of both prefix and suffix (including separators) will appear truncated to 17 characters.
43    pub statement_descriptor_suffix_kanji: Option<String>,
44}
45#[doc(hidden)]
46pub struct CheckoutCardPaymentMethodOptionsBuilder {
47    capture_method: Option<Option<CheckoutCardPaymentMethodOptionsCaptureMethod>>,
48    installments: Option<Option<stripe_shared::CheckoutCardInstallmentsOptions>>,
49    request_extended_authorization:
50        Option<Option<CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization>>,
51    request_incremental_authorization:
52        Option<Option<CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization>>,
53    request_multicapture: Option<Option<CheckoutCardPaymentMethodOptionsRequestMulticapture>>,
54    request_overcapture: Option<Option<CheckoutCardPaymentMethodOptionsRequestOvercapture>>,
55    request_three_d_secure: Option<CheckoutCardPaymentMethodOptionsRequestThreeDSecure>,
56    restrictions: Option<
57        Option<stripe_shared::PaymentPagesPrivateCardPaymentMethodOptionsResourceRestrictions>,
58    >,
59    setup_future_usage: Option<Option<CheckoutCardPaymentMethodOptionsSetupFutureUsage>>,
60    statement_descriptor_suffix_kana: Option<Option<String>>,
61    statement_descriptor_suffix_kanji: Option<Option<String>>,
62}
63
64#[allow(
65    unused_variables,
66    irrefutable_let_patterns,
67    clippy::let_unit_value,
68    clippy::match_single_binding,
69    clippy::single_match
70)]
71const _: () = {
72    use miniserde::de::{Map, Visitor};
73    use miniserde::json::Value;
74    use miniserde::{Deserialize, Result, make_place};
75    use stripe_types::miniserde_helpers::FromValueOpt;
76    use stripe_types::{MapBuilder, ObjectDeser};
77
78    make_place!(Place);
79
80    impl Deserialize for CheckoutCardPaymentMethodOptions {
81        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
82            Place::new(out)
83        }
84    }
85
86    struct Builder<'a> {
87        out: &'a mut Option<CheckoutCardPaymentMethodOptions>,
88        builder: CheckoutCardPaymentMethodOptionsBuilder,
89    }
90
91    impl Visitor for Place<CheckoutCardPaymentMethodOptions> {
92        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
93            Ok(Box::new(Builder {
94                out: &mut self.out,
95                builder: CheckoutCardPaymentMethodOptionsBuilder::deser_default(),
96            }))
97        }
98    }
99
100    impl MapBuilder for CheckoutCardPaymentMethodOptionsBuilder {
101        type Out = CheckoutCardPaymentMethodOptions;
102        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
103            Ok(match k {
104                "capture_method" => Deserialize::begin(&mut self.capture_method),
105                "installments" => Deserialize::begin(&mut self.installments),
106                "request_extended_authorization" => {
107                    Deserialize::begin(&mut self.request_extended_authorization)
108                }
109                "request_incremental_authorization" => {
110                    Deserialize::begin(&mut self.request_incremental_authorization)
111                }
112                "request_multicapture" => Deserialize::begin(&mut self.request_multicapture),
113                "request_overcapture" => Deserialize::begin(&mut self.request_overcapture),
114                "request_three_d_secure" => Deserialize::begin(&mut self.request_three_d_secure),
115                "restrictions" => Deserialize::begin(&mut self.restrictions),
116                "setup_future_usage" => Deserialize::begin(&mut self.setup_future_usage),
117                "statement_descriptor_suffix_kana" => {
118                    Deserialize::begin(&mut self.statement_descriptor_suffix_kana)
119                }
120                "statement_descriptor_suffix_kanji" => {
121                    Deserialize::begin(&mut self.statement_descriptor_suffix_kanji)
122                }
123                _ => <dyn Visitor>::ignore(),
124            })
125        }
126
127        fn deser_default() -> Self {
128            Self {
129                capture_method: Deserialize::default(),
130                installments: Deserialize::default(),
131                request_extended_authorization: Deserialize::default(),
132                request_incremental_authorization: Deserialize::default(),
133                request_multicapture: Deserialize::default(),
134                request_overcapture: Deserialize::default(),
135                request_three_d_secure: Deserialize::default(),
136                restrictions: Deserialize::default(),
137                setup_future_usage: Deserialize::default(),
138                statement_descriptor_suffix_kana: Deserialize::default(),
139                statement_descriptor_suffix_kanji: Deserialize::default(),
140            }
141        }
142
143        fn take_out(&mut self) -> Option<Self::Out> {
144            let (
145                Some(capture_method),
146                Some(installments),
147                Some(request_extended_authorization),
148                Some(request_incremental_authorization),
149                Some(request_multicapture),
150                Some(request_overcapture),
151                Some(request_three_d_secure),
152                Some(restrictions),
153                Some(setup_future_usage),
154                Some(statement_descriptor_suffix_kana),
155                Some(statement_descriptor_suffix_kanji),
156            ) = (
157                self.capture_method.take(),
158                self.installments,
159                self.request_extended_authorization.take(),
160                self.request_incremental_authorization.take(),
161                self.request_multicapture.take(),
162                self.request_overcapture.take(),
163                self.request_three_d_secure.take(),
164                self.restrictions.take(),
165                self.setup_future_usage.take(),
166                self.statement_descriptor_suffix_kana.take(),
167                self.statement_descriptor_suffix_kanji.take(),
168            )
169            else {
170                return None;
171            };
172            Some(Self::Out {
173                capture_method,
174                installments,
175                request_extended_authorization,
176                request_incremental_authorization,
177                request_multicapture,
178                request_overcapture,
179                request_three_d_secure,
180                restrictions,
181                setup_future_usage,
182                statement_descriptor_suffix_kana,
183                statement_descriptor_suffix_kanji,
184            })
185        }
186    }
187
188    impl Map for Builder<'_> {
189        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
190            self.builder.key(k)
191        }
192
193        fn finish(&mut self) -> Result<()> {
194            *self.out = self.builder.take_out();
195            Ok(())
196        }
197    }
198
199    impl ObjectDeser for CheckoutCardPaymentMethodOptions {
200        type Builder = CheckoutCardPaymentMethodOptionsBuilder;
201    }
202
203    impl FromValueOpt for CheckoutCardPaymentMethodOptions {
204        fn from_value(v: Value) -> Option<Self> {
205            let Value::Object(obj) = v else {
206                return None;
207            };
208            let mut b = CheckoutCardPaymentMethodOptionsBuilder::deser_default();
209            for (k, v) in obj {
210                match k.as_str() {
211                    "capture_method" => b.capture_method = FromValueOpt::from_value(v),
212                    "installments" => b.installments = FromValueOpt::from_value(v),
213                    "request_extended_authorization" => {
214                        b.request_extended_authorization = FromValueOpt::from_value(v)
215                    }
216                    "request_incremental_authorization" => {
217                        b.request_incremental_authorization = FromValueOpt::from_value(v)
218                    }
219                    "request_multicapture" => b.request_multicapture = FromValueOpt::from_value(v),
220                    "request_overcapture" => b.request_overcapture = FromValueOpt::from_value(v),
221                    "request_three_d_secure" => {
222                        b.request_three_d_secure = FromValueOpt::from_value(v)
223                    }
224                    "restrictions" => b.restrictions = FromValueOpt::from_value(v),
225                    "setup_future_usage" => b.setup_future_usage = FromValueOpt::from_value(v),
226                    "statement_descriptor_suffix_kana" => {
227                        b.statement_descriptor_suffix_kana = FromValueOpt::from_value(v)
228                    }
229                    "statement_descriptor_suffix_kanji" => {
230                        b.statement_descriptor_suffix_kanji = FromValueOpt::from_value(v)
231                    }
232                    _ => {}
233                }
234            }
235            b.take_out()
236        }
237    }
238};
239/// Controls when the funds will be captured from the customer's account.
240#[derive(Clone, Eq, PartialEq)]
241#[non_exhaustive]
242pub enum CheckoutCardPaymentMethodOptionsCaptureMethod {
243    Manual,
244    /// An unrecognized value from Stripe. Should not be used as a request parameter.
245    Unknown(String),
246}
247impl CheckoutCardPaymentMethodOptionsCaptureMethod {
248    pub fn as_str(&self) -> &str {
249        use CheckoutCardPaymentMethodOptionsCaptureMethod::*;
250        match self {
251            Manual => "manual",
252            Unknown(v) => v,
253        }
254    }
255}
256
257impl std::str::FromStr for CheckoutCardPaymentMethodOptionsCaptureMethod {
258    type Err = std::convert::Infallible;
259    fn from_str(s: &str) -> Result<Self, Self::Err> {
260        use CheckoutCardPaymentMethodOptionsCaptureMethod::*;
261        match s {
262            "manual" => Ok(Manual),
263            v => {
264                tracing::warn!(
265                    "Unknown value '{}' for enum '{}'",
266                    v,
267                    "CheckoutCardPaymentMethodOptionsCaptureMethod"
268                );
269                Ok(Unknown(v.to_owned()))
270            }
271        }
272    }
273}
274impl std::fmt::Display for CheckoutCardPaymentMethodOptionsCaptureMethod {
275    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
276        f.write_str(self.as_str())
277    }
278}
279
280impl std::fmt::Debug for CheckoutCardPaymentMethodOptionsCaptureMethod {
281    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
282        f.write_str(self.as_str())
283    }
284}
285#[cfg(feature = "serialize")]
286impl serde::Serialize for CheckoutCardPaymentMethodOptionsCaptureMethod {
287    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
288    where
289        S: serde::Serializer,
290    {
291        serializer.serialize_str(self.as_str())
292    }
293}
294impl miniserde::Deserialize for CheckoutCardPaymentMethodOptionsCaptureMethod {
295    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
296        crate::Place::new(out)
297    }
298}
299
300impl miniserde::de::Visitor for crate::Place<CheckoutCardPaymentMethodOptionsCaptureMethod> {
301    fn string(&mut self, s: &str) -> miniserde::Result<()> {
302        use std::str::FromStr;
303        self.out =
304            Some(CheckoutCardPaymentMethodOptionsCaptureMethod::from_str(s).expect("infallible"));
305        Ok(())
306    }
307}
308
309stripe_types::impl_from_val_with_from_str!(CheckoutCardPaymentMethodOptionsCaptureMethod);
310#[cfg(feature = "deserialize")]
311impl<'de> serde::Deserialize<'de> for CheckoutCardPaymentMethodOptionsCaptureMethod {
312    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
313        use std::str::FromStr;
314        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
315        Ok(Self::from_str(&s).expect("infallible"))
316    }
317}
318/// Request ability to [capture beyond the standard authorization validity window](/payments/extended-authorization) for this CheckoutSession.
319#[derive(Clone, Eq, PartialEq)]
320#[non_exhaustive]
321pub enum CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization {
322    IfAvailable,
323    Never,
324    /// An unrecognized value from Stripe. Should not be used as a request parameter.
325    Unknown(String),
326}
327impl CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization {
328    pub fn as_str(&self) -> &str {
329        use CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization::*;
330        match self {
331            IfAvailable => "if_available",
332            Never => "never",
333            Unknown(v) => v,
334        }
335    }
336}
337
338impl std::str::FromStr for CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization {
339    type Err = std::convert::Infallible;
340    fn from_str(s: &str) -> Result<Self, Self::Err> {
341        use CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization::*;
342        match s {
343            "if_available" => Ok(IfAvailable),
344            "never" => Ok(Never),
345            v => {
346                tracing::warn!(
347                    "Unknown value '{}' for enum '{}'",
348                    v,
349                    "CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization"
350                );
351                Ok(Unknown(v.to_owned()))
352            }
353        }
354    }
355}
356impl std::fmt::Display for CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization {
357    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
358        f.write_str(self.as_str())
359    }
360}
361
362impl std::fmt::Debug for CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization {
363    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
364        f.write_str(self.as_str())
365    }
366}
367#[cfg(feature = "serialize")]
368impl serde::Serialize for CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization {
369    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
370    where
371        S: serde::Serializer,
372    {
373        serializer.serialize_str(self.as_str())
374    }
375}
376impl miniserde::Deserialize for CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization {
377    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
378        crate::Place::new(out)
379    }
380}
381
382impl miniserde::de::Visitor
383    for crate::Place<CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization>
384{
385    fn string(&mut self, s: &str) -> miniserde::Result<()> {
386        use std::str::FromStr;
387        self.out = Some(
388            CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization::from_str(s)
389                .expect("infallible"),
390        );
391        Ok(())
392    }
393}
394
395stripe_types::impl_from_val_with_from_str!(
396    CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization
397);
398#[cfg(feature = "deserialize")]
399impl<'de> serde::Deserialize<'de> for CheckoutCardPaymentMethodOptionsRequestExtendedAuthorization {
400    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
401        use std::str::FromStr;
402        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
403        Ok(Self::from_str(&s).expect("infallible"))
404    }
405}
406/// Request ability to [increment the authorization](/payments/incremental-authorization) for this CheckoutSession.
407#[derive(Clone, Eq, PartialEq)]
408#[non_exhaustive]
409pub enum CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization {
410    IfAvailable,
411    Never,
412    /// An unrecognized value from Stripe. Should not be used as a request parameter.
413    Unknown(String),
414}
415impl CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization {
416    pub fn as_str(&self) -> &str {
417        use CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization::*;
418        match self {
419            IfAvailable => "if_available",
420            Never => "never",
421            Unknown(v) => v,
422        }
423    }
424}
425
426impl std::str::FromStr for CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization {
427    type Err = std::convert::Infallible;
428    fn from_str(s: &str) -> Result<Self, Self::Err> {
429        use CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization::*;
430        match s {
431            "if_available" => Ok(IfAvailable),
432            "never" => Ok(Never),
433            v => {
434                tracing::warn!(
435                    "Unknown value '{}' for enum '{}'",
436                    v,
437                    "CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization"
438                );
439                Ok(Unknown(v.to_owned()))
440            }
441        }
442    }
443}
444impl std::fmt::Display for CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization {
445    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
446        f.write_str(self.as_str())
447    }
448}
449
450impl std::fmt::Debug for CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization {
451    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
452        f.write_str(self.as_str())
453    }
454}
455#[cfg(feature = "serialize")]
456impl serde::Serialize for CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization {
457    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
458    where
459        S: serde::Serializer,
460    {
461        serializer.serialize_str(self.as_str())
462    }
463}
464impl miniserde::Deserialize for CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization {
465    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
466        crate::Place::new(out)
467    }
468}
469
470impl miniserde::de::Visitor
471    for crate::Place<CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization>
472{
473    fn string(&mut self, s: &str) -> miniserde::Result<()> {
474        use std::str::FromStr;
475        self.out = Some(
476            CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization::from_str(s)
477                .expect("infallible"),
478        );
479        Ok(())
480    }
481}
482
483stripe_types::impl_from_val_with_from_str!(
484    CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization
485);
486#[cfg(feature = "deserialize")]
487impl<'de> serde::Deserialize<'de>
488    for CheckoutCardPaymentMethodOptionsRequestIncrementalAuthorization
489{
490    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
491        use std::str::FromStr;
492        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
493        Ok(Self::from_str(&s).expect("infallible"))
494    }
495}
496/// Request ability to make [multiple captures](/payments/multicapture) for this CheckoutSession.
497#[derive(Clone, Eq, PartialEq)]
498#[non_exhaustive]
499pub enum CheckoutCardPaymentMethodOptionsRequestMulticapture {
500    IfAvailable,
501    Never,
502    /// An unrecognized value from Stripe. Should not be used as a request parameter.
503    Unknown(String),
504}
505impl CheckoutCardPaymentMethodOptionsRequestMulticapture {
506    pub fn as_str(&self) -> &str {
507        use CheckoutCardPaymentMethodOptionsRequestMulticapture::*;
508        match self {
509            IfAvailable => "if_available",
510            Never => "never",
511            Unknown(v) => v,
512        }
513    }
514}
515
516impl std::str::FromStr for CheckoutCardPaymentMethodOptionsRequestMulticapture {
517    type Err = std::convert::Infallible;
518    fn from_str(s: &str) -> Result<Self, Self::Err> {
519        use CheckoutCardPaymentMethodOptionsRequestMulticapture::*;
520        match s {
521            "if_available" => Ok(IfAvailable),
522            "never" => Ok(Never),
523            v => {
524                tracing::warn!(
525                    "Unknown value '{}' for enum '{}'",
526                    v,
527                    "CheckoutCardPaymentMethodOptionsRequestMulticapture"
528                );
529                Ok(Unknown(v.to_owned()))
530            }
531        }
532    }
533}
534impl std::fmt::Display for CheckoutCardPaymentMethodOptionsRequestMulticapture {
535    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
536        f.write_str(self.as_str())
537    }
538}
539
540impl std::fmt::Debug for CheckoutCardPaymentMethodOptionsRequestMulticapture {
541    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
542        f.write_str(self.as_str())
543    }
544}
545#[cfg(feature = "serialize")]
546impl serde::Serialize for CheckoutCardPaymentMethodOptionsRequestMulticapture {
547    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
548    where
549        S: serde::Serializer,
550    {
551        serializer.serialize_str(self.as_str())
552    }
553}
554impl miniserde::Deserialize for CheckoutCardPaymentMethodOptionsRequestMulticapture {
555    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
556        crate::Place::new(out)
557    }
558}
559
560impl miniserde::de::Visitor for crate::Place<CheckoutCardPaymentMethodOptionsRequestMulticapture> {
561    fn string(&mut self, s: &str) -> miniserde::Result<()> {
562        use std::str::FromStr;
563        self.out = Some(
564            CheckoutCardPaymentMethodOptionsRequestMulticapture::from_str(s).expect("infallible"),
565        );
566        Ok(())
567    }
568}
569
570stripe_types::impl_from_val_with_from_str!(CheckoutCardPaymentMethodOptionsRequestMulticapture);
571#[cfg(feature = "deserialize")]
572impl<'de> serde::Deserialize<'de> for CheckoutCardPaymentMethodOptionsRequestMulticapture {
573    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
574        use std::str::FromStr;
575        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
576        Ok(Self::from_str(&s).expect("infallible"))
577    }
578}
579/// Request ability to [overcapture](/payments/overcapture) for this CheckoutSession.
580#[derive(Clone, Eq, PartialEq)]
581#[non_exhaustive]
582pub enum CheckoutCardPaymentMethodOptionsRequestOvercapture {
583    IfAvailable,
584    Never,
585    /// An unrecognized value from Stripe. Should not be used as a request parameter.
586    Unknown(String),
587}
588impl CheckoutCardPaymentMethodOptionsRequestOvercapture {
589    pub fn as_str(&self) -> &str {
590        use CheckoutCardPaymentMethodOptionsRequestOvercapture::*;
591        match self {
592            IfAvailable => "if_available",
593            Never => "never",
594            Unknown(v) => v,
595        }
596    }
597}
598
599impl std::str::FromStr for CheckoutCardPaymentMethodOptionsRequestOvercapture {
600    type Err = std::convert::Infallible;
601    fn from_str(s: &str) -> Result<Self, Self::Err> {
602        use CheckoutCardPaymentMethodOptionsRequestOvercapture::*;
603        match s {
604            "if_available" => Ok(IfAvailable),
605            "never" => Ok(Never),
606            v => {
607                tracing::warn!(
608                    "Unknown value '{}' for enum '{}'",
609                    v,
610                    "CheckoutCardPaymentMethodOptionsRequestOvercapture"
611                );
612                Ok(Unknown(v.to_owned()))
613            }
614        }
615    }
616}
617impl std::fmt::Display for CheckoutCardPaymentMethodOptionsRequestOvercapture {
618    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
619        f.write_str(self.as_str())
620    }
621}
622
623impl std::fmt::Debug for CheckoutCardPaymentMethodOptionsRequestOvercapture {
624    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
625        f.write_str(self.as_str())
626    }
627}
628#[cfg(feature = "serialize")]
629impl serde::Serialize for CheckoutCardPaymentMethodOptionsRequestOvercapture {
630    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
631    where
632        S: serde::Serializer,
633    {
634        serializer.serialize_str(self.as_str())
635    }
636}
637impl miniserde::Deserialize for CheckoutCardPaymentMethodOptionsRequestOvercapture {
638    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
639        crate::Place::new(out)
640    }
641}
642
643impl miniserde::de::Visitor for crate::Place<CheckoutCardPaymentMethodOptionsRequestOvercapture> {
644    fn string(&mut self, s: &str) -> miniserde::Result<()> {
645        use std::str::FromStr;
646        self.out = Some(
647            CheckoutCardPaymentMethodOptionsRequestOvercapture::from_str(s).expect("infallible"),
648        );
649        Ok(())
650    }
651}
652
653stripe_types::impl_from_val_with_from_str!(CheckoutCardPaymentMethodOptionsRequestOvercapture);
654#[cfg(feature = "deserialize")]
655impl<'de> serde::Deserialize<'de> for CheckoutCardPaymentMethodOptionsRequestOvercapture {
656    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
657        use std::str::FromStr;
658        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
659        Ok(Self::from_str(&s).expect("infallible"))
660    }
661}
662/// We strongly recommend that you rely on our SCA Engine to automatically prompt your customers for authentication based on risk level and [other requirements](https://stripe.com/docs/strong-customer-authentication).
663/// However, if you wish to request 3D Secure based on logic from your own fraud engine, provide this option.
664/// If not provided, this value defaults to `automatic`.
665/// Read our guide on [manually requesting 3D Secure](https://stripe.com/docs/payments/3d-secure/authentication-flow#manual-three-ds) for more information on how this configuration interacts with Radar and our SCA Engine.
666#[derive(Clone, Eq, PartialEq)]
667#[non_exhaustive]
668pub enum CheckoutCardPaymentMethodOptionsRequestThreeDSecure {
669    Any,
670    Automatic,
671    Challenge,
672    /// An unrecognized value from Stripe. Should not be used as a request parameter.
673    Unknown(String),
674}
675impl CheckoutCardPaymentMethodOptionsRequestThreeDSecure {
676    pub fn as_str(&self) -> &str {
677        use CheckoutCardPaymentMethodOptionsRequestThreeDSecure::*;
678        match self {
679            Any => "any",
680            Automatic => "automatic",
681            Challenge => "challenge",
682            Unknown(v) => v,
683        }
684    }
685}
686
687impl std::str::FromStr for CheckoutCardPaymentMethodOptionsRequestThreeDSecure {
688    type Err = std::convert::Infallible;
689    fn from_str(s: &str) -> Result<Self, Self::Err> {
690        use CheckoutCardPaymentMethodOptionsRequestThreeDSecure::*;
691        match s {
692            "any" => Ok(Any),
693            "automatic" => Ok(Automatic),
694            "challenge" => Ok(Challenge),
695            v => {
696                tracing::warn!(
697                    "Unknown value '{}' for enum '{}'",
698                    v,
699                    "CheckoutCardPaymentMethodOptionsRequestThreeDSecure"
700                );
701                Ok(Unknown(v.to_owned()))
702            }
703        }
704    }
705}
706impl std::fmt::Display for CheckoutCardPaymentMethodOptionsRequestThreeDSecure {
707    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
708        f.write_str(self.as_str())
709    }
710}
711
712impl std::fmt::Debug for CheckoutCardPaymentMethodOptionsRequestThreeDSecure {
713    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
714        f.write_str(self.as_str())
715    }
716}
717#[cfg(feature = "serialize")]
718impl serde::Serialize for CheckoutCardPaymentMethodOptionsRequestThreeDSecure {
719    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
720    where
721        S: serde::Serializer,
722    {
723        serializer.serialize_str(self.as_str())
724    }
725}
726impl miniserde::Deserialize for CheckoutCardPaymentMethodOptionsRequestThreeDSecure {
727    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
728        crate::Place::new(out)
729    }
730}
731
732impl miniserde::de::Visitor for crate::Place<CheckoutCardPaymentMethodOptionsRequestThreeDSecure> {
733    fn string(&mut self, s: &str) -> miniserde::Result<()> {
734        use std::str::FromStr;
735        self.out = Some(
736            CheckoutCardPaymentMethodOptionsRequestThreeDSecure::from_str(s).expect("infallible"),
737        );
738        Ok(())
739    }
740}
741
742stripe_types::impl_from_val_with_from_str!(CheckoutCardPaymentMethodOptionsRequestThreeDSecure);
743#[cfg(feature = "deserialize")]
744impl<'de> serde::Deserialize<'de> for CheckoutCardPaymentMethodOptionsRequestThreeDSecure {
745    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
746        use std::str::FromStr;
747        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
748        Ok(Self::from_str(&s).expect("infallible"))
749    }
750}
751/// Indicates that you intend to make future payments with this PaymentIntent's payment method.
752///
753/// If you provide a Customer with the PaymentIntent, you can use this parameter to [attach the payment method](/payments/save-during-payment) to the Customer after the PaymentIntent is confirmed and the customer completes any required actions.
754/// If you don't provide a Customer, you can still [attach](/api/payment_methods/attach) the payment method to a Customer after the transaction completes.
755///
756/// If the payment method is `card_present` and isn't a digital wallet, Stripe creates and attaches a [generated_card](/api/charges/object#charge_object-payment_method_details-card_present-generated_card) payment method representing the card to the Customer instead.
757///
758/// When processing card payments, Stripe uses `setup_future_usage` to help you comply with regional legislation and network rules, such as [SCA](/strong-customer-authentication).
759#[derive(Clone, Eq, PartialEq)]
760#[non_exhaustive]
761pub enum CheckoutCardPaymentMethodOptionsSetupFutureUsage {
762    None,
763    OffSession,
764    OnSession,
765    /// An unrecognized value from Stripe. Should not be used as a request parameter.
766    Unknown(String),
767}
768impl CheckoutCardPaymentMethodOptionsSetupFutureUsage {
769    pub fn as_str(&self) -> &str {
770        use CheckoutCardPaymentMethodOptionsSetupFutureUsage::*;
771        match self {
772            None => "none",
773            OffSession => "off_session",
774            OnSession => "on_session",
775            Unknown(v) => v,
776        }
777    }
778}
779
780impl std::str::FromStr for CheckoutCardPaymentMethodOptionsSetupFutureUsage {
781    type Err = std::convert::Infallible;
782    fn from_str(s: &str) -> Result<Self, Self::Err> {
783        use CheckoutCardPaymentMethodOptionsSetupFutureUsage::*;
784        match s {
785            "none" => Ok(None),
786            "off_session" => Ok(OffSession),
787            "on_session" => Ok(OnSession),
788            v => {
789                tracing::warn!(
790                    "Unknown value '{}' for enum '{}'",
791                    v,
792                    "CheckoutCardPaymentMethodOptionsSetupFutureUsage"
793                );
794                Ok(Unknown(v.to_owned()))
795            }
796        }
797    }
798}
799impl std::fmt::Display for CheckoutCardPaymentMethodOptionsSetupFutureUsage {
800    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
801        f.write_str(self.as_str())
802    }
803}
804
805impl std::fmt::Debug for CheckoutCardPaymentMethodOptionsSetupFutureUsage {
806    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
807        f.write_str(self.as_str())
808    }
809}
810#[cfg(feature = "serialize")]
811impl serde::Serialize for CheckoutCardPaymentMethodOptionsSetupFutureUsage {
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}
819impl miniserde::Deserialize for CheckoutCardPaymentMethodOptionsSetupFutureUsage {
820    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
821        crate::Place::new(out)
822    }
823}
824
825impl miniserde::de::Visitor for crate::Place<CheckoutCardPaymentMethodOptionsSetupFutureUsage> {
826    fn string(&mut self, s: &str) -> miniserde::Result<()> {
827        use std::str::FromStr;
828        self.out = Some(
829            CheckoutCardPaymentMethodOptionsSetupFutureUsage::from_str(s).expect("infallible"),
830        );
831        Ok(())
832    }
833}
834
835stripe_types::impl_from_val_with_from_str!(CheckoutCardPaymentMethodOptionsSetupFutureUsage);
836#[cfg(feature = "deserialize")]
837impl<'de> serde::Deserialize<'de> for CheckoutCardPaymentMethodOptionsSetupFutureUsage {
838    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
839        use std::str::FromStr;
840        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
841        Ok(Self::from_str(&s).expect("infallible"))
842    }
843}
stripe_shared/checkout_card_payment_method_options.rs

stripe_shared/
checkout_card_payment_method_options.rs
