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    Alipay,
157    AmazonPay,
158    AuBecsDebit,
159    BacsDebit,
160    Bancontact,
161    Boleto,
162    Card,
163    Cashapp,
164    Crypto,
165    Custom,
166    CustomerBalance,
167    Eps,
168    Fpx,
169    Giropay,
170    Grabpay,
171    Ideal,
172    JpCreditTransfer,
173    KakaoPay,
174    Klarna,
175    Konbini,
176    KrCard,
177    Link,
178    MbWay,
179    Multibanco,
180    NaverPay,
181    NzBankAccount,
182    P24,
183    PayByBank,
184    Payco,
185    Paynow,
186    Paypal,
187    Payto,
188    Pix,
189    Promptpay,
190    RevolutPay,
191    Satispay,
192    SepaCreditTransfer,
193    SepaDebit,
194    Sofort,
195    Swish,
196    Twint,
197    Upi,
198    UsBankAccount,
199    WechatPay,
200    /// An unrecognized value from Stripe. Should not be used as a request parameter.
201    Unknown(String),
202}
203impl SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
204    pub fn as_str(&self) -> &str {
205        use SubscriptionsResourcePaymentSettingsPaymentMethodTypes::*;
206        match self {
207            AchCreditTransfer => "ach_credit_transfer",
208            AchDebit => "ach_debit",
209            AcssDebit => "acss_debit",
210            Affirm => "affirm",
211            Alipay => "alipay",
212            AmazonPay => "amazon_pay",
213            AuBecsDebit => "au_becs_debit",
214            BacsDebit => "bacs_debit",
215            Bancontact => "bancontact",
216            Boleto => "boleto",
217            Card => "card",
218            Cashapp => "cashapp",
219            Crypto => "crypto",
220            Custom => "custom",
221            CustomerBalance => "customer_balance",
222            Eps => "eps",
223            Fpx => "fpx",
224            Giropay => "giropay",
225            Grabpay => "grabpay",
226            Ideal => "ideal",
227            JpCreditTransfer => "jp_credit_transfer",
228            KakaoPay => "kakao_pay",
229            Klarna => "klarna",
230            Konbini => "konbini",
231            KrCard => "kr_card",
232            Link => "link",
233            MbWay => "mb_way",
234            Multibanco => "multibanco",
235            NaverPay => "naver_pay",
236            NzBankAccount => "nz_bank_account",
237            P24 => "p24",
238            PayByBank => "pay_by_bank",
239            Payco => "payco",
240            Paynow => "paynow",
241            Paypal => "paypal",
242            Payto => "payto",
243            Pix => "pix",
244            Promptpay => "promptpay",
245            RevolutPay => "revolut_pay",
246            Satispay => "satispay",
247            SepaCreditTransfer => "sepa_credit_transfer",
248            SepaDebit => "sepa_debit",
249            Sofort => "sofort",
250            Swish => "swish",
251            Twint => "twint",
252            Upi => "upi",
253            UsBankAccount => "us_bank_account",
254            WechatPay => "wechat_pay",
255            Unknown(v) => v,
256        }
257    }
258}
259
260impl std::str::FromStr for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
261    type Err = std::convert::Infallible;
262    fn from_str(s: &str) -> Result<Self, Self::Err> {
263        use SubscriptionsResourcePaymentSettingsPaymentMethodTypes::*;
264        match s {
265            "ach_credit_transfer" => Ok(AchCreditTransfer),
266            "ach_debit" => Ok(AchDebit),
267            "acss_debit" => Ok(AcssDebit),
268            "affirm" => Ok(Affirm),
269            "alipay" => Ok(Alipay),
270            "amazon_pay" => Ok(AmazonPay),
271            "au_becs_debit" => Ok(AuBecsDebit),
272            "bacs_debit" => Ok(BacsDebit),
273            "bancontact" => Ok(Bancontact),
274            "boleto" => Ok(Boleto),
275            "card" => Ok(Card),
276            "cashapp" => Ok(Cashapp),
277            "crypto" => Ok(Crypto),
278            "custom" => Ok(Custom),
279            "customer_balance" => Ok(CustomerBalance),
280            "eps" => Ok(Eps),
281            "fpx" => Ok(Fpx),
282            "giropay" => Ok(Giropay),
283            "grabpay" => Ok(Grabpay),
284            "ideal" => Ok(Ideal),
285            "jp_credit_transfer" => Ok(JpCreditTransfer),
286            "kakao_pay" => Ok(KakaoPay),
287            "klarna" => Ok(Klarna),
288            "konbini" => Ok(Konbini),
289            "kr_card" => Ok(KrCard),
290            "link" => Ok(Link),
291            "mb_way" => Ok(MbWay),
292            "multibanco" => Ok(Multibanco),
293            "naver_pay" => Ok(NaverPay),
294            "nz_bank_account" => Ok(NzBankAccount),
295            "p24" => Ok(P24),
296            "pay_by_bank" => Ok(PayByBank),
297            "payco" => Ok(Payco),
298            "paynow" => Ok(Paynow),
299            "paypal" => Ok(Paypal),
300            "payto" => Ok(Payto),
301            "pix" => Ok(Pix),
302            "promptpay" => Ok(Promptpay),
303            "revolut_pay" => Ok(RevolutPay),
304            "satispay" => Ok(Satispay),
305            "sepa_credit_transfer" => Ok(SepaCreditTransfer),
306            "sepa_debit" => Ok(SepaDebit),
307            "sofort" => Ok(Sofort),
308            "swish" => Ok(Swish),
309            "twint" => Ok(Twint),
310            "upi" => Ok(Upi),
311            "us_bank_account" => Ok(UsBankAccount),
312            "wechat_pay" => Ok(WechatPay),
313            v => {
314                tracing::warn!(
315                    "Unknown value '{}' for enum '{}'",
316                    v,
317                    "SubscriptionsResourcePaymentSettingsPaymentMethodTypes"
318                );
319                Ok(Unknown(v.to_owned()))
320            }
321        }
322    }
323}
324impl std::fmt::Display for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
325    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
326        f.write_str(self.as_str())
327    }
328}
329
330#[cfg(not(feature = "redact-generated-debug"))]
331impl std::fmt::Debug for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
332    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
333        f.write_str(self.as_str())
334    }
335}
336#[cfg(feature = "redact-generated-debug")]
337impl std::fmt::Debug for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
338    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
339        f.debug_struct(stringify!(SubscriptionsResourcePaymentSettingsPaymentMethodTypes))
340            .finish_non_exhaustive()
341    }
342}
343#[cfg(feature = "serialize")]
344impl serde::Serialize for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
345    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
346    where
347        S: serde::Serializer,
348    {
349        serializer.serialize_str(self.as_str())
350    }
351}
352impl miniserde::Deserialize for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
353    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
354        crate::Place::new(out)
355    }
356}
357
358impl miniserde::de::Visitor
359    for crate::Place<SubscriptionsResourcePaymentSettingsPaymentMethodTypes>
360{
361    fn string(&mut self, s: &str) -> miniserde::Result<()> {
362        use std::str::FromStr;
363        self.out = Some(
364            SubscriptionsResourcePaymentSettingsPaymentMethodTypes::from_str(s)
365                .expect("infallible"),
366        );
367        Ok(())
368    }
369}
370
371stripe_types::impl_from_val_with_from_str!(SubscriptionsResourcePaymentSettingsPaymentMethodTypes);
372#[cfg(feature = "deserialize")]
373impl<'de> serde::Deserialize<'de> for SubscriptionsResourcePaymentSettingsPaymentMethodTypes {
374    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
375        use std::str::FromStr;
376        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
377        Ok(Self::from_str(&s).expect("infallible"))
378    }
379}
380/// Configure whether Stripe updates `subscription.default_payment_method` when payment succeeds.
381/// Defaults to `off`.
382#[derive(Clone, Eq, PartialEq)]
383#[non_exhaustive]
384pub enum SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
385    Off,
386    OnSubscription,
387    /// An unrecognized value from Stripe. Should not be used as a request parameter.
388    Unknown(String),
389}
390impl SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
391    pub fn as_str(&self) -> &str {
392        use SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod::*;
393        match self {
394            Off => "off",
395            OnSubscription => "on_subscription",
396            Unknown(v) => v,
397        }
398    }
399}
400
401impl std::str::FromStr for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
402    type Err = std::convert::Infallible;
403    fn from_str(s: &str) -> Result<Self, Self::Err> {
404        use SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod::*;
405        match s {
406            "off" => Ok(Off),
407            "on_subscription" => Ok(OnSubscription),
408            v => {
409                tracing::warn!(
410                    "Unknown value '{}' for enum '{}'",
411                    v,
412                    "SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod"
413                );
414                Ok(Unknown(v.to_owned()))
415            }
416        }
417    }
418}
419impl std::fmt::Display for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
420    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
421        f.write_str(self.as_str())
422    }
423}
424
425#[cfg(not(feature = "redact-generated-debug"))]
426impl std::fmt::Debug for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
427    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
428        f.write_str(self.as_str())
429    }
430}
431#[cfg(feature = "redact-generated-debug")]
432impl std::fmt::Debug for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
433    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
434        f.debug_struct(stringify!(SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod))
435            .finish_non_exhaustive()
436    }
437}
438#[cfg(feature = "serialize")]
439impl serde::Serialize for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
440    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
441    where
442        S: serde::Serializer,
443    {
444        serializer.serialize_str(self.as_str())
445    }
446}
447impl miniserde::Deserialize for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
448    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
449        crate::Place::new(out)
450    }
451}
452
453impl miniserde::de::Visitor
454    for crate::Place<SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod>
455{
456    fn string(&mut self, s: &str) -> miniserde::Result<()> {
457        use std::str::FromStr;
458        self.out = Some(
459            SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod::from_str(s)
460                .expect("infallible"),
461        );
462        Ok(())
463    }
464}
465
466stripe_types::impl_from_val_with_from_str!(
467    SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod
468);
469#[cfg(feature = "deserialize")]
470impl<'de> serde::Deserialize<'de> for SubscriptionsResourcePaymentSettingsSaveDefaultPaymentMethod {
471    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
472        use std::str::FromStr;
473        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
474        Ok(Self::from_str(&s).expect("infallible"))
475    }
476}
stripe_shared/subscriptions_resource_payment_settings.rs

stripe_shared/
subscriptions_resource_payment_settings.rs
