async-stripe-shared 1.0.0-rc.6

API bindings for the Stripe HTTP API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

#[derive(Copy, Clone, Eq, PartialEq)]
#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
pub struct SubscriptionsResourceBillingCycleAnchorConfig {
    /// The day of the month of the billing_cycle_anchor.
    pub day_of_month: i64,
    /// The hour of the day of the billing_cycle_anchor.
    pub hour: Option<i64>,
    /// The minute of the hour of the billing_cycle_anchor.
    pub minute: Option<i64>,
    /// The month to start full cycle billing periods.
    pub month: Option<i64>,
    /// The second of the minute of the billing_cycle_anchor.
    pub second: Option<i64>,
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for SubscriptionsResourceBillingCycleAnchorConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("SubscriptionsResourceBillingCycleAnchorConfig").finish_non_exhaustive()
    }
}
#[doc(hidden)]
pub struct SubscriptionsResourceBillingCycleAnchorConfigBuilder {
    day_of_month: Option<i64>,
    hour: Option<Option<i64>>,
    minute: Option<Option<i64>>,
    month: Option<Option<i64>>,
    second: Option<Option<i64>>,
}

#[allow(
    unused_variables,
    irrefutable_let_patterns,
    clippy::let_unit_value,
    clippy::match_single_binding,
    clippy::single_match
)]
const _: () = {
    use miniserde::de::{Map, Visitor};
    use miniserde::json::Value;
    use miniserde::{Deserialize, Result, make_place};
    use stripe_types::miniserde_helpers::FromValueOpt;
    use stripe_types::{MapBuilder, ObjectDeser};

    make_place!(Place);

    impl Deserialize for SubscriptionsResourceBillingCycleAnchorConfig {
        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
            Place::new(out)
        }
    }

    struct Builder<'a> {
        out: &'a mut Option<SubscriptionsResourceBillingCycleAnchorConfig>,
        builder: SubscriptionsResourceBillingCycleAnchorConfigBuilder,
    }

    impl Visitor for Place<SubscriptionsResourceBillingCycleAnchorConfig> {
        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
            Ok(Box::new(Builder {
                out: &mut self.out,
                builder: SubscriptionsResourceBillingCycleAnchorConfigBuilder::deser_default(),
            }))
        }
    }

    impl MapBuilder for SubscriptionsResourceBillingCycleAnchorConfigBuilder {
        type Out = SubscriptionsResourceBillingCycleAnchorConfig;
        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
            Ok(match k {
                "day_of_month" => Deserialize::begin(&mut self.day_of_month),
                "hour" => Deserialize::begin(&mut self.hour),
                "minute" => Deserialize::begin(&mut self.minute),
                "month" => Deserialize::begin(&mut self.month),
                "second" => Deserialize::begin(&mut self.second),
                _ => <dyn Visitor>::ignore(),
            })
        }

        fn deser_default() -> Self {
            Self {
                day_of_month: None,
                hour: Some(None),
                minute: Some(None),
                month: Some(None),
                second: Some(None),
            }
        }

        fn take_out(&mut self) -> Option<Self::Out> {
            let (Some(day_of_month), Some(hour), Some(minute), Some(month), Some(second)) =
                (self.day_of_month, self.hour, self.minute, self.month, self.second)
            else {
                return None;
            };
            Some(Self::Out { day_of_month, hour, minute, month, second })
        }
    }

    impl Map for Builder<'_> {
        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
            self.builder.key(k)
        }

        fn finish(&mut self) -> Result<()> {
            *self.out = self.builder.take_out();
            Ok(())
        }
    }

    impl ObjectDeser for SubscriptionsResourceBillingCycleAnchorConfig {
        type Builder = SubscriptionsResourceBillingCycleAnchorConfigBuilder;
    }

    impl FromValueOpt for SubscriptionsResourceBillingCycleAnchorConfig {
        fn from_value(v: Value) -> Option<Self> {
            let Value::Object(obj) = v else {
                return None;
            };
            let mut b = SubscriptionsResourceBillingCycleAnchorConfigBuilder::deser_default();
            for (k, v) in obj {
                match k.as_str() {
                    "day_of_month" => b.day_of_month = FromValueOpt::from_value(v),
                    "hour" => b.hour = FromValueOpt::from_value(v),
                    "minute" => b.minute = FromValueOpt::from_value(v),
                    "month" => b.month = FromValueOpt::from_value(v),
                    "second" => b.second = FromValueOpt::from_value(v),
                    _ => {}
                }
            }
            b.take_out()
        }
    }
};