stripe_shared/
payment_method_options_card_mandate_options.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct PaymentMethodOptionsCardMandateOptions {
5    /// Amount to be charged for future payments.
6    pub amount: i64,
7    /// One of `fixed` or `maximum`.
8    /// If `fixed`, the `amount` param refers to the exact amount to be charged in future payments.
9    /// If `maximum`, the amount charged can be up to the value passed for the `amount` param.
10    pub amount_type: PaymentMethodOptionsCardMandateOptionsAmountType,
11    /// A description of the mandate or subscription that is meant to be displayed to the customer.
12    pub description: Option<String>,
13    /// End date of the mandate or subscription.
14    /// If not provided, the mandate will be active until canceled.
15    /// If provided, end date should be after start date.
16    pub end_date: Option<stripe_types::Timestamp>,
17    /// Specifies payment frequency. One of `day`, `week`, `month`, `year`, or `sporadic`.
18    pub interval: PaymentMethodOptionsCardMandateOptionsInterval,
19    /// The number of intervals between payments.
20    /// For example, `interval=month` and `interval_count=3` indicates one payment every three months.
21    /// Maximum of one year interval allowed (1 year, 12 months, or 52 weeks).
22    /// This parameter is optional when `interval=sporadic`.
23    pub interval_count: Option<u64>,
24    /// Unique identifier for the mandate or subscription.
25    pub reference: String,
26    /// Start date of the mandate or subscription. Start date should not be lesser than yesterday.
27    pub start_date: stripe_types::Timestamp,
28    /// Specifies the type of mandates supported. Possible values are `india`.
29    pub supported_types: Option<Vec<PaymentMethodOptionsCardMandateOptionsSupportedTypes>>,
30}
31#[doc(hidden)]
32pub struct PaymentMethodOptionsCardMandateOptionsBuilder {
33    amount: Option<i64>,
34    amount_type: Option<PaymentMethodOptionsCardMandateOptionsAmountType>,
35    description: Option<Option<String>>,
36    end_date: Option<Option<stripe_types::Timestamp>>,
37    interval: Option<PaymentMethodOptionsCardMandateOptionsInterval>,
38    interval_count: Option<Option<u64>>,
39    reference: Option<String>,
40    start_date: Option<stripe_types::Timestamp>,
41    supported_types: Option<Option<Vec<PaymentMethodOptionsCardMandateOptionsSupportedTypes>>>,
42}
43
44#[allow(
45    unused_variables,
46    irrefutable_let_patterns,
47    clippy::let_unit_value,
48    clippy::match_single_binding,
49    clippy::single_match
50)]
51const _: () = {
52    use miniserde::de::{Map, Visitor};
53    use miniserde::json::Value;
54    use miniserde::{Deserialize, Result, make_place};
55    use stripe_types::miniserde_helpers::FromValueOpt;
56    use stripe_types::{MapBuilder, ObjectDeser};
57
58    make_place!(Place);
59
60    impl Deserialize for PaymentMethodOptionsCardMandateOptions {
61        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
62            Place::new(out)
63        }
64    }
65
66    struct Builder<'a> {
67        out: &'a mut Option<PaymentMethodOptionsCardMandateOptions>,
68        builder: PaymentMethodOptionsCardMandateOptionsBuilder,
69    }
70
71    impl Visitor for Place<PaymentMethodOptionsCardMandateOptions> {
72        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
73            Ok(Box::new(Builder {
74                out: &mut self.out,
75                builder: PaymentMethodOptionsCardMandateOptionsBuilder::deser_default(),
76            }))
77        }
78    }
79
80    impl MapBuilder for PaymentMethodOptionsCardMandateOptionsBuilder {
81        type Out = PaymentMethodOptionsCardMandateOptions;
82        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
83            Ok(match k {
84                "amount" => Deserialize::begin(&mut self.amount),
85                "amount_type" => Deserialize::begin(&mut self.amount_type),
86                "description" => Deserialize::begin(&mut self.description),
87                "end_date" => Deserialize::begin(&mut self.end_date),
88                "interval" => Deserialize::begin(&mut self.interval),
89                "interval_count" => Deserialize::begin(&mut self.interval_count),
90                "reference" => Deserialize::begin(&mut self.reference),
91                "start_date" => Deserialize::begin(&mut self.start_date),
92                "supported_types" => Deserialize::begin(&mut self.supported_types),
93                _ => <dyn Visitor>::ignore(),
94            })
95        }
96
97        fn deser_default() -> Self {
98            Self {
99                amount: Deserialize::default(),
100                amount_type: Deserialize::default(),
101                description: Deserialize::default(),
102                end_date: Deserialize::default(),
103                interval: Deserialize::default(),
104                interval_count: Deserialize::default(),
105                reference: Deserialize::default(),
106                start_date: Deserialize::default(),
107                supported_types: Deserialize::default(),
108            }
109        }
110
111        fn take_out(&mut self) -> Option<Self::Out> {
112            let (
113                Some(amount),
114                Some(amount_type),
115                Some(description),
116                Some(end_date),
117                Some(interval),
118                Some(interval_count),
119                Some(reference),
120                Some(start_date),
121                Some(supported_types),
122            ) = (
123                self.amount,
124                self.amount_type,
125                self.description.take(),
126                self.end_date,
127                self.interval,
128                self.interval_count,
129                self.reference.take(),
130                self.start_date,
131                self.supported_types.take(),
132            )
133            else {
134                return None;
135            };
136            Some(Self::Out {
137                amount,
138                amount_type,
139                description,
140                end_date,
141                interval,
142                interval_count,
143                reference,
144                start_date,
145                supported_types,
146            })
147        }
148    }
149
150    impl Map for Builder<'_> {
151        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
152            self.builder.key(k)
153        }
154
155        fn finish(&mut self) -> Result<()> {
156            *self.out = self.builder.take_out();
157            Ok(())
158        }
159    }
160
161    impl ObjectDeser for PaymentMethodOptionsCardMandateOptions {
162        type Builder = PaymentMethodOptionsCardMandateOptionsBuilder;
163    }
164
165    impl FromValueOpt for PaymentMethodOptionsCardMandateOptions {
166        fn from_value(v: Value) -> Option<Self> {
167            let Value::Object(obj) = v else {
168                return None;
169            };
170            let mut b = PaymentMethodOptionsCardMandateOptionsBuilder::deser_default();
171            for (k, v) in obj {
172                match k.as_str() {
173                    "amount" => b.amount = FromValueOpt::from_value(v),
174                    "amount_type" => b.amount_type = FromValueOpt::from_value(v),
175                    "description" => b.description = FromValueOpt::from_value(v),
176                    "end_date" => b.end_date = FromValueOpt::from_value(v),
177                    "interval" => b.interval = FromValueOpt::from_value(v),
178                    "interval_count" => b.interval_count = FromValueOpt::from_value(v),
179                    "reference" => b.reference = FromValueOpt::from_value(v),
180                    "start_date" => b.start_date = FromValueOpt::from_value(v),
181                    "supported_types" => b.supported_types = FromValueOpt::from_value(v),
182                    _ => {}
183                }
184            }
185            b.take_out()
186        }
187    }
188};
189/// One of `fixed` or `maximum`.
190/// If `fixed`, the `amount` param refers to the exact amount to be charged in future payments.
191/// If `maximum`, the amount charged can be up to the value passed for the `amount` param.
192#[derive(Copy, Clone, Eq, PartialEq)]
193pub enum PaymentMethodOptionsCardMandateOptionsAmountType {
194    Fixed,
195    Maximum,
196}
197impl PaymentMethodOptionsCardMandateOptionsAmountType {
198    pub fn as_str(self) -> &'static str {
199        use PaymentMethodOptionsCardMandateOptionsAmountType::*;
200        match self {
201            Fixed => "fixed",
202            Maximum => "maximum",
203        }
204    }
205}
206
207impl std::str::FromStr for PaymentMethodOptionsCardMandateOptionsAmountType {
208    type Err = stripe_types::StripeParseError;
209    fn from_str(s: &str) -> Result<Self, Self::Err> {
210        use PaymentMethodOptionsCardMandateOptionsAmountType::*;
211        match s {
212            "fixed" => Ok(Fixed),
213            "maximum" => Ok(Maximum),
214            _ => Err(stripe_types::StripeParseError),
215        }
216    }
217}
218impl std::fmt::Display for PaymentMethodOptionsCardMandateOptionsAmountType {
219    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
220        f.write_str(self.as_str())
221    }
222}
223
224impl std::fmt::Debug for PaymentMethodOptionsCardMandateOptionsAmountType {
225    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
226        f.write_str(self.as_str())
227    }
228}
229#[cfg(feature = "serialize")]
230impl serde::Serialize for PaymentMethodOptionsCardMandateOptionsAmountType {
231    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
232    where
233        S: serde::Serializer,
234    {
235        serializer.serialize_str(self.as_str())
236    }
237}
238impl miniserde::Deserialize for PaymentMethodOptionsCardMandateOptionsAmountType {
239    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
240        crate::Place::new(out)
241    }
242}
243
244impl miniserde::de::Visitor for crate::Place<PaymentMethodOptionsCardMandateOptionsAmountType> {
245    fn string(&mut self, s: &str) -> miniserde::Result<()> {
246        use std::str::FromStr;
247        self.out = Some(
248            PaymentMethodOptionsCardMandateOptionsAmountType::from_str(s)
249                .map_err(|_| miniserde::Error)?,
250        );
251        Ok(())
252    }
253}
254
255stripe_types::impl_from_val_with_from_str!(PaymentMethodOptionsCardMandateOptionsAmountType);
256#[cfg(feature = "deserialize")]
257impl<'de> serde::Deserialize<'de> for PaymentMethodOptionsCardMandateOptionsAmountType {
258    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
259        use std::str::FromStr;
260        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
261        Self::from_str(&s).map_err(|_| {
262            serde::de::Error::custom(
263                "Unknown value for PaymentMethodOptionsCardMandateOptionsAmountType",
264            )
265        })
266    }
267}
268/// Specifies payment frequency. One of `day`, `week`, `month`, `year`, or `sporadic`.
269#[derive(Copy, Clone, Eq, PartialEq)]
270pub enum PaymentMethodOptionsCardMandateOptionsInterval {
271    Day,
272    Month,
273    Sporadic,
274    Week,
275    Year,
276}
277impl PaymentMethodOptionsCardMandateOptionsInterval {
278    pub fn as_str(self) -> &'static str {
279        use PaymentMethodOptionsCardMandateOptionsInterval::*;
280        match self {
281            Day => "day",
282            Month => "month",
283            Sporadic => "sporadic",
284            Week => "week",
285            Year => "year",
286        }
287    }
288}
289
290impl std::str::FromStr for PaymentMethodOptionsCardMandateOptionsInterval {
291    type Err = stripe_types::StripeParseError;
292    fn from_str(s: &str) -> Result<Self, Self::Err> {
293        use PaymentMethodOptionsCardMandateOptionsInterval::*;
294        match s {
295            "day" => Ok(Day),
296            "month" => Ok(Month),
297            "sporadic" => Ok(Sporadic),
298            "week" => Ok(Week),
299            "year" => Ok(Year),
300            _ => Err(stripe_types::StripeParseError),
301        }
302    }
303}
304impl std::fmt::Display for PaymentMethodOptionsCardMandateOptionsInterval {
305    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
306        f.write_str(self.as_str())
307    }
308}
309
310impl std::fmt::Debug for PaymentMethodOptionsCardMandateOptionsInterval {
311    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
312        f.write_str(self.as_str())
313    }
314}
315#[cfg(feature = "serialize")]
316impl serde::Serialize for PaymentMethodOptionsCardMandateOptionsInterval {
317    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
318    where
319        S: serde::Serializer,
320    {
321        serializer.serialize_str(self.as_str())
322    }
323}
324impl miniserde::Deserialize for PaymentMethodOptionsCardMandateOptionsInterval {
325    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
326        crate::Place::new(out)
327    }
328}
329
330impl miniserde::de::Visitor for crate::Place<PaymentMethodOptionsCardMandateOptionsInterval> {
331    fn string(&mut self, s: &str) -> miniserde::Result<()> {
332        use std::str::FromStr;
333        self.out = Some(
334            PaymentMethodOptionsCardMandateOptionsInterval::from_str(s)
335                .map_err(|_| miniserde::Error)?,
336        );
337        Ok(())
338    }
339}
340
341stripe_types::impl_from_val_with_from_str!(PaymentMethodOptionsCardMandateOptionsInterval);
342#[cfg(feature = "deserialize")]
343impl<'de> serde::Deserialize<'de> for PaymentMethodOptionsCardMandateOptionsInterval {
344    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
345        use std::str::FromStr;
346        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
347        Self::from_str(&s).map_err(|_| {
348            serde::de::Error::custom(
349                "Unknown value for PaymentMethodOptionsCardMandateOptionsInterval",
350            )
351        })
352    }
353}
354/// Specifies the type of mandates supported. Possible values are `india`.
355#[derive(Copy, Clone, Eq, PartialEq)]
356pub enum PaymentMethodOptionsCardMandateOptionsSupportedTypes {
357    India,
358}
359impl PaymentMethodOptionsCardMandateOptionsSupportedTypes {
360    pub fn as_str(self) -> &'static str {
361        use PaymentMethodOptionsCardMandateOptionsSupportedTypes::*;
362        match self {
363            India => "india",
364        }
365    }
366}
367
368impl std::str::FromStr for PaymentMethodOptionsCardMandateOptionsSupportedTypes {
369    type Err = stripe_types::StripeParseError;
370    fn from_str(s: &str) -> Result<Self, Self::Err> {
371        use PaymentMethodOptionsCardMandateOptionsSupportedTypes::*;
372        match s {
373            "india" => Ok(India),
374            _ => Err(stripe_types::StripeParseError),
375        }
376    }
377}
378impl std::fmt::Display for PaymentMethodOptionsCardMandateOptionsSupportedTypes {
379    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
380        f.write_str(self.as_str())
381    }
382}
383
384impl std::fmt::Debug for PaymentMethodOptionsCardMandateOptionsSupportedTypes {
385    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
386        f.write_str(self.as_str())
387    }
388}
389#[cfg(feature = "serialize")]
390impl serde::Serialize for PaymentMethodOptionsCardMandateOptionsSupportedTypes {
391    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
392    where
393        S: serde::Serializer,
394    {
395        serializer.serialize_str(self.as_str())
396    }
397}
398impl miniserde::Deserialize for PaymentMethodOptionsCardMandateOptionsSupportedTypes {
399    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
400        crate::Place::new(out)
401    }
402}
403
404impl miniserde::de::Visitor for crate::Place<PaymentMethodOptionsCardMandateOptionsSupportedTypes> {
405    fn string(&mut self, s: &str) -> miniserde::Result<()> {
406        use std::str::FromStr;
407        self.out = Some(
408            PaymentMethodOptionsCardMandateOptionsSupportedTypes::from_str(s)
409                .map_err(|_| miniserde::Error)?,
410        );
411        Ok(())
412    }
413}
414
415stripe_types::impl_from_val_with_from_str!(PaymentMethodOptionsCardMandateOptionsSupportedTypes);
416#[cfg(feature = "deserialize")]
417impl<'de> serde::Deserialize<'de> for PaymentMethodOptionsCardMandateOptionsSupportedTypes {
418    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
419        use std::str::FromStr;
420        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
421        Self::from_str(&s).map_err(|_| {
422            serde::de::Error::custom(
423                "Unknown value for PaymentMethodOptionsCardMandateOptionsSupportedTypes",
424            )
425        })
426    }
427}
stripe_shared/payment_method_options_card_mandate_options.rs

stripe_shared/
payment_method_options_card_mandate_options.rs
