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

#[derive(Clone)]
#[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 BillingBillResourceInvoicingParentsInvoiceSubscriptionParent {
    /// Set of [key-value pairs](https://docs.stripe.com/api/metadata) defined as subscription metadata when an invoice is created.
    /// Becomes an immutable snapshot of the subscription metadata at the time of invoice finalization.
    ///  *Note: This attribute is populated only for invoices created on or after June 29, 2023.*
    pub metadata: Option<std::collections::HashMap<String, String>>,
    /// The subscription that generated this invoice
    pub subscription: stripe_types::Expandable<stripe_shared::Subscription>,
    /// Only set for upcoming invoices that preview prorations. The time used to calculate prorations.
    pub subscription_proration_date: Option<stripe_types::Timestamp>,
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for BillingBillResourceInvoicingParentsInvoiceSubscriptionParent {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("BillingBillResourceInvoicingParentsInvoiceSubscriptionParent")
            .finish_non_exhaustive()
    }
}
#[doc(hidden)]
pub struct BillingBillResourceInvoicingParentsInvoiceSubscriptionParentBuilder {
    metadata: Option<Option<std::collections::HashMap<String, String>>>,
    subscription: Option<stripe_types::Expandable<stripe_shared::Subscription>>,
    subscription_proration_date: Option<Option<stripe_types::Timestamp>>,
}

#[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 BillingBillResourceInvoicingParentsInvoiceSubscriptionParent {
        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
            Place::new(out)
        }
    }

    struct Builder<'a> {
        out: &'a mut Option<BillingBillResourceInvoicingParentsInvoiceSubscriptionParent>,
        builder: BillingBillResourceInvoicingParentsInvoiceSubscriptionParentBuilder,
    }

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

    impl MapBuilder for BillingBillResourceInvoicingParentsInvoiceSubscriptionParentBuilder {
        type Out = BillingBillResourceInvoicingParentsInvoiceSubscriptionParent;
        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
            Ok(match k {
                "metadata" => Deserialize::begin(&mut self.metadata),
                "subscription" => Deserialize::begin(&mut self.subscription),
                "subscription_proration_date" => {
                    Deserialize::begin(&mut self.subscription_proration_date)
                }
                _ => <dyn Visitor>::ignore(),
            })
        }

        fn deser_default() -> Self {
            Self {
                metadata: Some(None),
                subscription: None,
                subscription_proration_date: Some(None),
            }
        }

        fn take_out(&mut self) -> Option<Self::Out> {
            let (Some(metadata), Some(subscription), Some(subscription_proration_date)) =
                (self.metadata.take(), self.subscription.take(), self.subscription_proration_date)
            else {
                return None;
            };
            Some(Self::Out { metadata, subscription, subscription_proration_date })
        }
    }

    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 BillingBillResourceInvoicingParentsInvoiceSubscriptionParent {
        type Builder = BillingBillResourceInvoicingParentsInvoiceSubscriptionParentBuilder;
    }

    impl FromValueOpt for BillingBillResourceInvoicingParentsInvoiceSubscriptionParent {
        fn from_value(v: Value) -> Option<Self> {
            let Value::Object(obj) = v else {
                return None;
            };
            let mut b =
                BillingBillResourceInvoicingParentsInvoiceSubscriptionParentBuilder::deser_default(
                );
            for (k, v) in obj {
                match k.as_str() {
                    "metadata" => b.metadata = FromValueOpt::from_value(v),
                    "subscription" => b.subscription = FromValueOpt::from_value(v),
                    "subscription_proration_date" => {
                        b.subscription_proration_date = FromValueOpt::from_value(v)
                    }
                    _ => {}
                }
            }
            b.take_out()
        }
    }
};