stripe_shared/
subscriptions_resource_payment_settings.rs

1#[derive(Clone, Eq, PartialEq)]
2#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
3#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
4#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
5pub struct SubscriptionsResourcePaymentSettings {
6    /// Payment-method-specific configuration to provide to invoices created by the subscription.
7    pub payment_method_options: Option<stripe_shared::SubscriptionsResourcePaymentMethodOptions>,
8    /// The list of payment method types to provide to every invoice created by the subscription.
9    /// If not set, Stripe attempts to automatically determine the types to use by looking at the invoice’s default payment method, the subscription’s default payment method, the customer’s default payment method, and your [invoice template settings](https://dashboard.stripe.com/settings/billing/invoice).
10    pub payment_method_types: Option<Vec<SubscriptionsResourcePaymentSettingsPaymentMethodTypes>>,
11    /// Configure whether Stripe updates `subscription.default_payment_method` when payment succeeds.
12    /// Defaults to `off`.
13    pub save_default_payment_method:
14        Option<SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod>,
15}
16#[cfg(feature = "redact-generated-debug")]
17impl std::fmt::Debug for SubscriptionsResourcePaymentSettings {
18    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
19        f.debug_struct("SubscriptionsResourcePaymentSettings").finish_non_exhaustive()
20    }
21}
22#[doc(hidden)]
23pub struct SubscriptionsResourcePaymentSettingsBuilder {
24    payment_method_options:
25        Option<Option<stripe_shared::SubscriptionsResourcePaymentMethodOptions>>,
26    payment_method_types:
27        Option<Option<Vec<SubscriptionsResourcePaymentSettingsPaymentMethodTypes>>>,
28    save_default_payment_method:
29        Option<Option<SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod>>,
30}
31
32#[allow(
33    unused_variables,
34    irrefutable_let_patterns,
35    clippy::let_unit_value,
36    clippy::match_single_binding,
37    clippy::single_match
38)]
39const _: () = {
40    use miniserde::de::{Map, Visitor};
41    use miniserde::json::Value;
42    use miniserde::{Deserialize, Result, make_place};
43    use stripe_types::miniserde_helpers::FromValueOpt;
44    use stripe_types::{MapBuilder, ObjectDeser};
45
46    make_place!(Place);
47
48    impl Deserialize for SubscriptionsResourcePaymentSettings {
49        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
50            Place::new(out)
51        }
52    }
53
54    struct Builder<'a> {
55        out: &'a mut Option<SubscriptionsResourcePaymentSettings>,
56        builder: SubscriptionsResourcePaymentSettingsBuilder,
57    }
58
59    impl Visitor for Place<SubscriptionsResourcePaymentSettings> {
60        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
61            Ok(Box::new(Builder {
62                out: &mut self.out,
63                builder: SubscriptionsResourcePaymentSettingsBuilder::deser_default(),
64            }))
65        }
66    }
67
68    impl MapBuilder for SubscriptionsResourcePaymentSettingsBuilder {
69        type Out = SubscriptionsResourcePaymentSettings;
70        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
71            Ok(match k {
72                "payment_method_options" => Deserialize::begin(&mut self.payment_method_options),
73                "payment_method_types" => Deserialize::begin(&mut self.payment_method_types),
74                "save_default_payment_method" => {
75                    Deserialize::begin(&mut self.save_default_payment_method)
76                }
77                _ => <dyn Visitor>::ignore(),
78            })
79        }
80
81        fn deser_default() -> Self {
82            Self {
83                payment_method_options: Some(None),
84                payment_method_types: Some(None),
85                save_default_payment_method: Some(None),
86            }
87        }
88
89        fn take_out(&mut self) -> Option<Self::Out> {
90            let (
91                Some(payment_method_options),
92                Some(payment_method_types),
93                Some(save_default_payment_method),
94            ) = (
95                self.payment_method_options.take(),
96                self.payment_method_types.take(),
97                self.save_default_payment_method.take(),
98            )
99            else {
100                return None;
101            };
102            Some(Self::Out {
103                payment_method_options,
104                payment_method_types,
105                save_default_payment_method,
106            })
107        }
108    }
109
110    impl Map for Builder<'_> {
111        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
112            self.builder.key(k)
113        }
114
115        fn finish(&mut self) -> Result<()> {
116            *self.out = self.builder.take_out();
117            Ok(())
118        }
119    }
120
121    impl ObjectDeser for SubscriptionsResourcePaymentSettings {
122        type Builder = SubscriptionsResourcePaymentSettingsBuilder;
123    }
124
125    impl FromValueOpt for SubscriptionsResourcePaymentSettings {
126        fn from_value(v: Value) -> Option<Self> {
127            let Value::Object(obj) = v else {
128                return None;
129            };
130            let mut b = SubscriptionsResourcePaymentSettingsBuilder::deser_default();
131            for (k, v) in obj {
132                match k.as_str() {
133                    "payment_method_options" => {
134                        b.payment_method_options = FromValueOpt::from_value(v)
135                    }
136                    "payment_method_types" => b.payment_method_types = FromValueOpt::from_value(v),
137                    "save_default_payment_method" => {
138                        b.save_default_payment_method = FromValueOpt::from_value(v)
139                    }
140                    _ => {}
141                }
142            }
143            b.take_out()
144        }
145    }
146};
147/// The list of payment method types to provide to every invoice created by the subscription.
148/// If not set, Stripe attempts to automatically determine the types to use by looking at the invoice’s default payment method, the subscription’s default payment method, the customer’s default payment method, and your [invoice template settings](https://dashboard.stripe.com/settings/billing/invoice).
149#[derive(Clone, Eq, PartialEq)]
150#[non_exhaustive]
151pub enum SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
152    AchCreditTransfer,
153    AchDebit,
154    AcssDebit,
155    Affirm,
156    AmazonPay,
157    AuBecsDebit,
158    BacsDebit,
159    Bancontact,
160    Boleto,
161    Card,
162    Cashapp,
163    Crypto,
164    Custom,
165    CustomerBalance,
166    Eps,
167    Fpx,
168    Giropay,
169    Grabpay,
170    Ideal,
171    JpCreditTransfer,
172    KakaoPay,
173    Klarna,
174    Konbini,
175    KrCard,
176    Link,
177    Multibanco,
178    NaverPay,
179    NzBankAccount,
180    P24,
181    PayByBank,
182    Payco,
183    Paynow,
184    Paypal,
185    Payto,
186    Pix,
187    Promptpay,
188    RevolutPay,
189    SepaCreditTransfer,
190    SepaDebit,
191    Sofort,
192    Swish,
193    Upi,
194    UsBankAccount,
195    WechatPay,
196    /// An unrecognized value from Stripe. Should not be used as a request parameter.
197    Unknown(String),
198}
199impl SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
200    pub fn as_str(&self) -> &str {
201        use SubscriptionsResourcePaymentSettingsPaymentMethodTypes::*;
202        match self {
203            AchCreditTransfer => "ach_credit_transfer",
204            AchDebit => "ach_debit",
205            AcssDebit => "acss_debit",
206            Affirm => "affirm",
207            AmazonPay => "amazon_pay",
208            AuBecsDebit => "au_becs_debit",
209            BacsDebit => "bacs_debit",
210            Bancontact => "bancontact",
211            Boleto => "boleto",
212            Card => "card",
213            Cashapp => "cashapp",
214            Crypto => "crypto",
215            Custom => "custom",
216            CustomerBalance => "customer_balance",
217            Eps => "eps",
218            Fpx => "fpx",
219            Giropay => "giropay",
220            Grabpay => "grabpay",
221            Ideal => "ideal",
222            JpCreditTransfer => "jp_credit_transfer",
223            KakaoPay => "kakao_pay",
224            Klarna => "klarna",
225            Konbini => "konbini",
226            KrCard => "kr_card",
227            Link => "link",
228            Multibanco => "multibanco",
229            NaverPay => "naver_pay",
230            NzBankAccount => "nz_bank_account",
231            P24 => "p24",
232            PayByBank => "pay_by_bank",
233            Payco => "payco",
234            Paynow => "paynow",
235            Paypal => "paypal",
236            Payto => "payto",
237            Pix => "pix",
238            Promptpay => "promptpay",
239            RevolutPay => "revolut_pay",
240            SepaCreditTransfer => "sepa_credit_transfer",
241            SepaDebit => "sepa_debit",
242            Sofort => "sofort",
243            Swish => "swish",
244            Upi => "upi",
245            UsBankAccount => "us_bank_account",
246            WechatPay => "wechat_pay",
247            Unknown(v) => v,
248        }
249    }
250}
251
252impl std::str::FromStr for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
253    type Err = std::convert::Infallible;
254    fn from_str(s: &str) -> Result<Self, Self::Err> {
255        use SubscriptionsResourcePaymentSettingsPaymentMethodTypes::*;
256        match s {
257            "ach_credit_transfer" => Ok(AchCreditTransfer),
258            "ach_debit" => Ok(AchDebit),
259            "acss_debit" => Ok(AcssDebit),
260            "affirm" => Ok(Affirm),
261            "amazon_pay" => Ok(AmazonPay),
262            "au_becs_debit" => Ok(AuBecsDebit),
263            "bacs_debit" => Ok(BacsDebit),
264            "bancontact" => Ok(Bancontact),
265            "boleto" => Ok(Boleto),
266            "card" => Ok(Card),
267            "cashapp" => Ok(Cashapp),
268            "crypto" => Ok(Crypto),
269            "custom" => Ok(Custom),
270            "customer_balance" => Ok(CustomerBalance),
271            "eps" => Ok(Eps),
272            "fpx" => Ok(Fpx),
273            "giropay" => Ok(Giropay),
274            "grabpay" => Ok(Grabpay),
275            "ideal" => Ok(Ideal),
276            "jp_credit_transfer" => Ok(JpCreditTransfer),
277            "kakao_pay" => Ok(KakaoPay),
278            "klarna" => Ok(Klarna),
279            "konbini" => Ok(Konbini),
280            "kr_card" => Ok(KrCard),
281            "link" => Ok(Link),
282            "multibanco" => Ok(Multibanco),
283            "naver_pay" => Ok(NaverPay),
284            "nz_bank_account" => Ok(NzBankAccount),
285            "p24" => Ok(P24),
286            "pay_by_bank" => Ok(PayByBank),
287            "payco" => Ok(Payco),
288            "paynow" => Ok(Paynow),
289            "paypal" => Ok(Paypal),
290            "payto" => Ok(Payto),
291            "pix" => Ok(Pix),
292            "promptpay" => Ok(Promptpay),
293            "revolut_pay" => Ok(RevolutPay),
294            "sepa_credit_transfer" => Ok(SepaCreditTransfer),
295            "sepa_debit" => Ok(SepaDebit),
296            "sofort" => Ok(Sofort),
297            "swish" => Ok(Swish),
298            "upi" => Ok(Upi),
299            "us_bank_account" => Ok(UsBankAccount),
300            "wechat_pay" => Ok(WechatPay),
301            v => {
302                tracing::warn!(
303                    "Unknown value '{}' for enum '{}'",
304                    v,
305                    "SubscriptionsResourcePaymentSettingsPaymentMethodTypes"
306                );
307                Ok(Unknown(v.to_owned()))
308            }
309        }
310    }
311}
312impl std::fmt::Display for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
313    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
314        f.write_str(self.as_str())
315    }
316}
317
318#[cfg(not(feature = "redact-generated-debug"))]
319impl std::fmt::Debug for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
320    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
321        f.write_str(self.as_str())
322    }
323}
324#[cfg(feature = "redact-generated-debug")]
325impl std::fmt::Debug for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
326    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
327        f.debug_struct(stringify!(SubscriptionsResourcePaymentSettingsPaymentMethodTypes))
328            .finish_non_exhaustive()
329    }
330}
331#[cfg(feature = "serialize")]
332impl serde::Serialize for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
333    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
334    where
335        S: serde::Serializer,
336    {
337        serializer.serialize_str(self.as_str())
338    }
339}
340impl miniserde::Deserialize for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
341    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
342        crate::Place::new(out)
343    }
344}
345
346impl miniserde::de::Visitor
347    for crate::Place<SubscriptionsResourcePaymentSettingsPaymentMethodTypes>
348{
349    fn string(&mut self, s: &str) -> miniserde::Result<()> {
350        use std::str::FromStr;
351        self.out = Some(
352            SubscriptionsResourcePaymentSettingsPaymentMethodTypes::from_str(s)
353                .expect("infallible"),
354        );
355        Ok(())
356    }
357}
358
359stripe_types::impl_from_val_with_from_str!(SubscriptionsResourcePaymentSettingsPaymentMethodTypes);
360#[cfg(feature = "deserialize")]
361impl<'de> serde::Deserialize<'de> for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
362    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
363        use std::str::FromStr;
364        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
365        Ok(Self::from_str(&s).expect("infallible"))
366    }
367}
368/// Configure whether Stripe updates `subscription.default_payment_method` when payment succeeds.
369/// Defaults to `off`.
370#[derive(Clone, Eq, PartialEq)]
371#[non_exhaustive]
372pub enum SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
373    Off,
374    OnSubscription,
375    /// An unrecognized value from Stripe. Should not be used as a request parameter.
376    Unknown(String),
377}
378impl SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
379    pub fn as_str(&self) -> &str {
380        use SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod::*;
381        match self {
382            Off => "off",
383            OnSubscription => "on_subscription",
384            Unknown(v) => v,
385        }
386    }
387}
388
389impl std::str::FromStr for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
390    type Err = std::convert::Infallible;
391    fn from_str(s: &str) -> Result<Self, Self::Err> {
392        use SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod::*;
393        match s {
394            "off" => Ok(Off),
395            "on_subscription" => Ok(OnSubscription),
396            v => {
397                tracing::warn!(
398                    "Unknown value '{}' for enum '{}'",
399                    v,
400                    "SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod"
401                );
402                Ok(Unknown(v.to_owned()))
403            }
404        }
405    }
406}
407impl std::fmt::Display for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
408    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
409        f.write_str(self.as_str())
410    }
411}
412
413#[cfg(not(feature = "redact-generated-debug"))]
414impl std::fmt::Debug for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
415    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
416        f.write_str(self.as_str())
417    }
418}
419#[cfg(feature = "redact-generated-debug")]
420impl std::fmt::Debug for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
421    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
422        f.debug_struct(stringify!(SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod))
423            .finish_non_exhaustive()
424    }
425}
426#[cfg(feature = "serialize")]
427impl serde::Serialize for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
428    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
429    where
430        S: serde::Serializer,
431    {
432        serializer.serialize_str(self.as_str())
433    }
434}
435impl miniserde::Deserialize for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
436    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
437        crate::Place::new(out)
438    }
439}
440
441impl miniserde::de::Visitor
442    for crate::Place<SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod>
443{
444    fn string(&mut self, s: &str) -> miniserde::Result<()> {
445        use std::str::FromStr;
446        self.out = Some(
447            SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod::from_str(s)
448                .expect("infallible"),
449        );
450        Ok(())
451    }
452}
453
454stripe_types::impl_from_val_with_from_str!(
455    SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod
456);
457#[cfg(feature = "deserialize")]
458impl<'de> serde::Deserialize<'de> for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
459    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
460        use std::str::FromStr;
461        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
462        Ok(Self::from_str(&s).expect("infallible"))
463    }
464}
stripe_shared/subscriptions_resource_payment_settings.rs

stripe_shared/
subscriptions_resource_payment_settings.rs
