stripe_shared/
transfer_schedule.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct TransferSchedule {
5    /// The number of days charges for the account will be held before being paid out.
6    pub delay_days: u32,
7    /// How frequently funds will be paid out.
8    /// One of `manual` (payouts only created via API call), `daily`, `weekly`, or `monthly`.
9    pub interval: String,
10    /// The day of the month funds will be paid out.
11    /// Only shown if `interval` is monthly.
12    /// Payouts scheduled between the 29th and 31st of the month are sent on the last day of shorter months.
13    pub monthly_anchor: Option<u8>,
14    /// The days of the month funds will be paid out.
15    /// Only shown if `interval` is monthly.
16    /// Payouts scheduled between the 29th and 31st of the month are sent on the last day of shorter months.
17    pub monthly_payout_days: Option<Vec<u32>>,
18    /// The day of the week funds will be paid out, of the style 'monday', 'tuesday', etc.
19    /// Only shown if `interval` is weekly.
20    pub weekly_anchor: Option<String>,
21    /// The days of the week when available funds are paid out, specified as an array, for example, [`monday`, `tuesday`].
22    /// Only shown if `interval` is weekly.
23    pub weekly_payout_days: Option<Vec<TransferScheduleWeeklyPayoutDays>>,
24}
25#[doc(hidden)]
26pub struct TransferScheduleBuilder {
27    delay_days: Option<u32>,
28    interval: Option<String>,
29    monthly_anchor: Option<Option<u8>>,
30    monthly_payout_days: Option<Option<Vec<u32>>>,
31    weekly_anchor: Option<Option<String>>,
32    weekly_payout_days: Option<Option<Vec<TransferScheduleWeeklyPayoutDays>>>,
33}
34
35#[allow(
36    unused_variables,
37    irrefutable_let_patterns,
38    clippy::let_unit_value,
39    clippy::match_single_binding,
40    clippy::single_match
41)]
42const _: () = {
43    use miniserde::de::{Map, Visitor};
44    use miniserde::json::Value;
45    use miniserde::{make_place, Deserialize, Result};
46    use stripe_types::miniserde_helpers::FromValueOpt;
47    use stripe_types::{MapBuilder, ObjectDeser};
48
49    make_place!(Place);
50
51    impl Deserialize for TransferSchedule {
52        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
53            Place::new(out)
54        }
55    }
56
57    struct Builder<'a> {
58        out: &'a mut Option<TransferSchedule>,
59        builder: TransferScheduleBuilder,
60    }
61
62    impl Visitor for Place<TransferSchedule> {
63        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
64            Ok(Box::new(Builder {
65                out: &mut self.out,
66                builder: TransferScheduleBuilder::deser_default(),
67            }))
68        }
69    }
70
71    impl MapBuilder for TransferScheduleBuilder {
72        type Out = TransferSchedule;
73        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
74            Ok(match k {
75                "delay_days" => Deserialize::begin(&mut self.delay_days),
76                "interval" => Deserialize::begin(&mut self.interval),
77                "monthly_anchor" => Deserialize::begin(&mut self.monthly_anchor),
78                "monthly_payout_days" => Deserialize::begin(&mut self.monthly_payout_days),
79                "weekly_anchor" => Deserialize::begin(&mut self.weekly_anchor),
80                "weekly_payout_days" => Deserialize::begin(&mut self.weekly_payout_days),
81
82                _ => <dyn Visitor>::ignore(),
83            })
84        }
85
86        fn deser_default() -> Self {
87            Self {
88                delay_days: Deserialize::default(),
89                interval: Deserialize::default(),
90                monthly_anchor: Deserialize::default(),
91                monthly_payout_days: Deserialize::default(),
92                weekly_anchor: Deserialize::default(),
93                weekly_payout_days: Deserialize::default(),
94            }
95        }
96
97        fn take_out(&mut self) -> Option<Self::Out> {
98            let (
99                Some(delay_days),
100                Some(interval),
101                Some(monthly_anchor),
102                Some(monthly_payout_days),
103                Some(weekly_anchor),
104                Some(weekly_payout_days),
105            ) = (
106                self.delay_days,
107                self.interval.take(),
108                self.monthly_anchor,
109                self.monthly_payout_days.take(),
110                self.weekly_anchor.take(),
111                self.weekly_payout_days.take(),
112            )
113            else {
114                return None;
115            };
116            Some(Self::Out {
117                delay_days,
118                interval,
119                monthly_anchor,
120                monthly_payout_days,
121                weekly_anchor,
122                weekly_payout_days,
123            })
124        }
125    }
126
127    impl Map for Builder<'_> {
128        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
129            self.builder.key(k)
130        }
131
132        fn finish(&mut self) -> Result<()> {
133            *self.out = self.builder.take_out();
134            Ok(())
135        }
136    }
137
138    impl ObjectDeser for TransferSchedule {
139        type Builder = TransferScheduleBuilder;
140    }
141
142    impl FromValueOpt for TransferSchedule {
143        fn from_value(v: Value) -> Option<Self> {
144            let Value::Object(obj) = v else {
145                return None;
146            };
147            let mut b = TransferScheduleBuilder::deser_default();
148            for (k, v) in obj {
149                match k.as_str() {
150                    "delay_days" => b.delay_days = FromValueOpt::from_value(v),
151                    "interval" => b.interval = FromValueOpt::from_value(v),
152                    "monthly_anchor" => b.monthly_anchor = FromValueOpt::from_value(v),
153                    "monthly_payout_days" => b.monthly_payout_days = FromValueOpt::from_value(v),
154                    "weekly_anchor" => b.weekly_anchor = FromValueOpt::from_value(v),
155                    "weekly_payout_days" => b.weekly_payout_days = FromValueOpt::from_value(v),
156
157                    _ => {}
158                }
159            }
160            b.take_out()
161        }
162    }
163};
164/// The days of the week when available funds are paid out, specified as an array, for example, [`monday`, `tuesday`].
165/// Only shown if `interval` is weekly.
166#[derive(Copy, Clone, Eq, PartialEq)]
167pub enum TransferScheduleWeeklyPayoutDays {
168    Friday,
169    Monday,
170    Saturday,
171    Sunday,
172    Thursday,
173    Tuesday,
174    Wednesday,
175}
176impl TransferScheduleWeeklyPayoutDays {
177    pub fn as_str(self) -> &'static str {
178        use TransferScheduleWeeklyPayoutDays::*;
179        match self {
180            Friday => "friday",
181            Monday => "monday",
182            Saturday => "saturday",
183            Sunday => "sunday",
184            Thursday => "thursday",
185            Tuesday => "tuesday",
186            Wednesday => "wednesday",
187        }
188    }
189}
190
191impl std::str::FromStr for TransferScheduleWeeklyPayoutDays {
192    type Err = stripe_types::StripeParseError;
193    fn from_str(s: &str) -> Result<Self, Self::Err> {
194        use TransferScheduleWeeklyPayoutDays::*;
195        match s {
196            "friday" => Ok(Friday),
197            "monday" => Ok(Monday),
198            "saturday" => Ok(Saturday),
199            "sunday" => Ok(Sunday),
200            "thursday" => Ok(Thursday),
201            "tuesday" => Ok(Tuesday),
202            "wednesday" => Ok(Wednesday),
203            _ => Err(stripe_types::StripeParseError),
204        }
205    }
206}
207impl std::fmt::Display for TransferScheduleWeeklyPayoutDays {
208    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
209        f.write_str(self.as_str())
210    }
211}
212
213impl std::fmt::Debug for TransferScheduleWeeklyPayoutDays {
214    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
215        f.write_str(self.as_str())
216    }
217}
218#[cfg(feature = "serialize")]
219impl serde::Serialize for TransferScheduleWeeklyPayoutDays {
220    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
221    where
222        S: serde::Serializer,
223    {
224        serializer.serialize_str(self.as_str())
225    }
226}
227impl miniserde::Deserialize for TransferScheduleWeeklyPayoutDays {
228    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
229        crate::Place::new(out)
230    }
231}
232
233impl miniserde::de::Visitor for crate::Place<TransferScheduleWeeklyPayoutDays> {
234    fn string(&mut self, s: &str) -> miniserde::Result<()> {
235        use std::str::FromStr;
236        self.out =
237            Some(TransferScheduleWeeklyPayoutDays::from_str(s).map_err(|_| miniserde::Error)?);
238        Ok(())
239    }
240}
241
242stripe_types::impl_from_val_with_from_str!(TransferScheduleWeeklyPayoutDays);
243#[cfg(feature = "deserialize")]
244impl<'de> serde::Deserialize<'de> for TransferScheduleWeeklyPayoutDays {
245    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
246        use std::str::FromStr;
247        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
248        Self::from_str(&s).map_err(|_| {
249            serde::de::Error::custom("Unknown value for TransferScheduleWeeklyPayoutDays")
250        })
251    }
252}
stripe_shared/transfer_schedule.rs

stripe_shared/
transfer_schedule.rs
