stripe_shared/
customer_cash_balance_transaction.rs

1/// Customers with certain payments enabled have a cash balance, representing funds that were paid
2/// by the customer to a merchant, but have not yet been allocated to a payment.
3/// Cash Balance Transactions.
4/// represent when funds are moved into or out of this balance.
5/// This includes funding by the customer, allocation.
6/// to payments, and refunds to the customer.
7///
8/// For more details see <<https://stripe.com/docs/api/cash_balance_transactions/object>>.
9#[derive(Clone, Debug)]
10#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
11pub struct CustomerCashBalanceTransaction {
12pub adjusted_for_overdraft: Option<stripe_shared::CustomerBalanceResourceCashBalanceTransactionResourceAdjustedForOverdraft>,
13pub applied_to_payment: Option<stripe_shared::CustomerBalanceResourceCashBalanceTransactionResourceAppliedToPaymentTransaction>,
14    /// Time at which the object was created. Measured in seconds since the Unix epoch.
15pub created: stripe_types::Timestamp,
16        /// Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase.
17    /// Must be a [supported currency](https://stripe.com/docs/currencies).
18pub currency: stripe_types::Currency,
19    /// The customer whose available cash balance changed as a result of this transaction.
20pub customer: stripe_types::Expandable<stripe_shared::Customer>,
21        /// The total available cash balance for the specified currency after this transaction was applied.
22    /// Represented in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal).
23pub ending_balance: i64,
24pub funded: Option<stripe_shared::CustomerBalanceResourceCashBalanceTransactionResourceFundedTransaction>,
25    /// Unique identifier for the object.
26pub id: stripe_shared::CustomerCashBalanceTransactionId,
27        /// Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
28pub livemode: bool,
29        /// The amount by which the cash balance changed, represented in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal).
30    /// A positive value represents funds being added to the cash balance, a negative value represents funds being removed from the cash balance.
31pub net_amount: i64,
32pub refunded_from_payment: Option<stripe_shared::CustomerBalanceResourceCashBalanceTransactionResourceRefundedFromPaymentTransaction>,
33pub transferred_to_balance: Option<stripe_shared::CustomerBalanceResourceCashBalanceTransactionResourceTransferredToBalance>,
34        /// The type of the cash balance transaction.
35    /// New types may be added in future.
36    /// See [Customer Balance](https://stripe.com/docs/payments/customer-balance#types) to learn more about these types.
37#[cfg_attr(feature = "deserialize", serde(rename = "type"))]
38pub type_: CustomerCashBalanceTransactionType,
39pub unapplied_from_payment: Option<stripe_shared::CustomerBalanceResourceCashBalanceTransactionResourceUnappliedFromPaymentTransaction>,
40
41}
42#[doc(hidden)]
43pub struct CustomerCashBalanceTransactionBuilder {
44    adjusted_for_overdraft: Option<Option<stripe_shared::CustomerBalanceResourceCashBalanceTransactionResourceAdjustedForOverdraft>>,
45applied_to_payment: Option<Option<stripe_shared::CustomerBalanceResourceCashBalanceTransactionResourceAppliedToPaymentTransaction>>,
46created: Option<stripe_types::Timestamp>,
47currency: Option<stripe_types::Currency>,
48customer: Option<stripe_types::Expandable<stripe_shared::Customer>>,
49ending_balance: Option<i64>,
50funded: Option<Option<stripe_shared::CustomerBalanceResourceCashBalanceTransactionResourceFundedTransaction>>,
51id: Option<stripe_shared::CustomerCashBalanceTransactionId>,
52livemode: Option<bool>,
53net_amount: Option<i64>,
54refunded_from_payment: Option<Option<stripe_shared::CustomerBalanceResourceCashBalanceTransactionResourceRefundedFromPaymentTransaction>>,
55transferred_to_balance: Option<Option<stripe_shared::CustomerBalanceResourceCashBalanceTransactionResourceTransferredToBalance>>,
56type_: Option<CustomerCashBalanceTransactionType>,
57unapplied_from_payment: Option<Option<stripe_shared::CustomerBalanceResourceCashBalanceTransactionResourceUnappliedFromPaymentTransaction>>,
58
59}
60
61#[allow(
62    unused_variables,
63    irrefutable_let_patterns,
64    clippy::let_unit_value,
65    clippy::match_single_binding,
66    clippy::single_match
67)]
68const _: () = {
69    use miniserde::de::{Map, Visitor};
70    use miniserde::json::Value;
71    use miniserde::{Deserialize, Result, make_place};
72    use stripe_types::miniserde_helpers::FromValueOpt;
73    use stripe_types::{MapBuilder, ObjectDeser};
74
75    make_place!(Place);
76
77    impl Deserialize for CustomerCashBalanceTransaction {
78        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
79            Place::new(out)
80        }
81    }
82
83    struct Builder<'a> {
84        out: &'a mut Option<CustomerCashBalanceTransaction>,
85        builder: CustomerCashBalanceTransactionBuilder,
86    }
87
88    impl Visitor for Place<CustomerCashBalanceTransaction> {
89        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
90            Ok(Box::new(Builder {
91                out: &mut self.out,
92                builder: CustomerCashBalanceTransactionBuilder::deser_default(),
93            }))
94        }
95    }
96
97    impl MapBuilder for CustomerCashBalanceTransactionBuilder {
98        type Out = CustomerCashBalanceTransaction;
99        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
100            Ok(match k {
101                "adjusted_for_overdraft" => Deserialize::begin(&mut self.adjusted_for_overdraft),
102                "applied_to_payment" => Deserialize::begin(&mut self.applied_to_payment),
103                "created" => Deserialize::begin(&mut self.created),
104                "currency" => Deserialize::begin(&mut self.currency),
105                "customer" => Deserialize::begin(&mut self.customer),
106                "ending_balance" => Deserialize::begin(&mut self.ending_balance),
107                "funded" => Deserialize::begin(&mut self.funded),
108                "id" => Deserialize::begin(&mut self.id),
109                "livemode" => Deserialize::begin(&mut self.livemode),
110                "net_amount" => Deserialize::begin(&mut self.net_amount),
111                "refunded_from_payment" => Deserialize::begin(&mut self.refunded_from_payment),
112                "transferred_to_balance" => Deserialize::begin(&mut self.transferred_to_balance),
113                "type" => Deserialize::begin(&mut self.type_),
114                "unapplied_from_payment" => Deserialize::begin(&mut self.unapplied_from_payment),
115
116                _ => <dyn Visitor>::ignore(),
117            })
118        }
119
120        fn deser_default() -> Self {
121            Self {
122                adjusted_for_overdraft: Deserialize::default(),
123                applied_to_payment: Deserialize::default(),
124                created: Deserialize::default(),
125                currency: Deserialize::default(),
126                customer: Deserialize::default(),
127                ending_balance: Deserialize::default(),
128                funded: Deserialize::default(),
129                id: Deserialize::default(),
130                livemode: Deserialize::default(),
131                net_amount: Deserialize::default(),
132                refunded_from_payment: Deserialize::default(),
133                transferred_to_balance: Deserialize::default(),
134                type_: Deserialize::default(),
135                unapplied_from_payment: Deserialize::default(),
136            }
137        }
138
139        fn take_out(&mut self) -> Option<Self::Out> {
140            let (
141                Some(adjusted_for_overdraft),
142                Some(applied_to_payment),
143                Some(created),
144                Some(currency),
145                Some(customer),
146                Some(ending_balance),
147                Some(funded),
148                Some(id),
149                Some(livemode),
150                Some(net_amount),
151                Some(refunded_from_payment),
152                Some(transferred_to_balance),
153                Some(type_),
154                Some(unapplied_from_payment),
155            ) = (
156                self.adjusted_for_overdraft.take(),
157                self.applied_to_payment.take(),
158                self.created,
159                self.currency.take(),
160                self.customer.take(),
161                self.ending_balance,
162                self.funded.take(),
163                self.id.take(),
164                self.livemode,
165                self.net_amount,
166                self.refunded_from_payment.take(),
167                self.transferred_to_balance.take(),
168                self.type_,
169                self.unapplied_from_payment.take(),
170            )
171            else {
172                return None;
173            };
174            Some(Self::Out {
175                adjusted_for_overdraft,
176                applied_to_payment,
177                created,
178                currency,
179                customer,
180                ending_balance,
181                funded,
182                id,
183                livemode,
184                net_amount,
185                refunded_from_payment,
186                transferred_to_balance,
187                type_,
188                unapplied_from_payment,
189            })
190        }
191    }
192
193    impl Map for Builder<'_> {
194        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
195            self.builder.key(k)
196        }
197
198        fn finish(&mut self) -> Result<()> {
199            *self.out = self.builder.take_out();
200            Ok(())
201        }
202    }
203
204    impl ObjectDeser for CustomerCashBalanceTransaction {
205        type Builder = CustomerCashBalanceTransactionBuilder;
206    }
207
208    impl FromValueOpt for CustomerCashBalanceTransaction {
209        fn from_value(v: Value) -> Option<Self> {
210            let Value::Object(obj) = v else {
211                return None;
212            };
213            let mut b = CustomerCashBalanceTransactionBuilder::deser_default();
214            for (k, v) in obj {
215                match k.as_str() {
216                    "adjusted_for_overdraft" => {
217                        b.adjusted_for_overdraft = FromValueOpt::from_value(v)
218                    }
219                    "applied_to_payment" => b.applied_to_payment = FromValueOpt::from_value(v),
220                    "created" => b.created = FromValueOpt::from_value(v),
221                    "currency" => b.currency = FromValueOpt::from_value(v),
222                    "customer" => b.customer = FromValueOpt::from_value(v),
223                    "ending_balance" => b.ending_balance = FromValueOpt::from_value(v),
224                    "funded" => b.funded = FromValueOpt::from_value(v),
225                    "id" => b.id = FromValueOpt::from_value(v),
226                    "livemode" => b.livemode = FromValueOpt::from_value(v),
227                    "net_amount" => b.net_amount = FromValueOpt::from_value(v),
228                    "refunded_from_payment" => {
229                        b.refunded_from_payment = FromValueOpt::from_value(v)
230                    }
231                    "transferred_to_balance" => {
232                        b.transferred_to_balance = FromValueOpt::from_value(v)
233                    }
234                    "type" => b.type_ = FromValueOpt::from_value(v),
235                    "unapplied_from_payment" => {
236                        b.unapplied_from_payment = FromValueOpt::from_value(v)
237                    }
238
239                    _ => {}
240                }
241            }
242            b.take_out()
243        }
244    }
245};
246#[cfg(feature = "serialize")]
247impl serde::Serialize for CustomerCashBalanceTransaction {
248    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
249        use serde::ser::SerializeStruct;
250        let mut s = s.serialize_struct("CustomerCashBalanceTransaction", 15)?;
251        s.serialize_field("adjusted_for_overdraft", &self.adjusted_for_overdraft)?;
252        s.serialize_field("applied_to_payment", &self.applied_to_payment)?;
253        s.serialize_field("created", &self.created)?;
254        s.serialize_field("currency", &self.currency)?;
255        s.serialize_field("customer", &self.customer)?;
256        s.serialize_field("ending_balance", &self.ending_balance)?;
257        s.serialize_field("funded", &self.funded)?;
258        s.serialize_field("id", &self.id)?;
259        s.serialize_field("livemode", &self.livemode)?;
260        s.serialize_field("net_amount", &self.net_amount)?;
261        s.serialize_field("refunded_from_payment", &self.refunded_from_payment)?;
262        s.serialize_field("transferred_to_balance", &self.transferred_to_balance)?;
263        s.serialize_field("type", &self.type_)?;
264        s.serialize_field("unapplied_from_payment", &self.unapplied_from_payment)?;
265
266        s.serialize_field("object", "customer_cash_balance_transaction")?;
267        s.end()
268    }
269}
270/// The type of the cash balance transaction.
271/// New types may be added in future.
272/// See [Customer Balance](https://stripe.com/docs/payments/customer-balance#types) to learn more about these types.
273#[derive(Copy, Clone, Eq, PartialEq)]
274pub enum CustomerCashBalanceTransactionType {
275    AdjustedForOverdraft,
276    AppliedToPayment,
277    Funded,
278    FundingReversed,
279    RefundedFromPayment,
280    ReturnCanceled,
281    ReturnInitiated,
282    TransferredToBalance,
283    UnappliedFromPayment,
284}
285impl CustomerCashBalanceTransactionType {
286    pub fn as_str(self) -> &'static str {
287        use CustomerCashBalanceTransactionType::*;
288        match self {
289            AdjustedForOverdraft => "adjusted_for_overdraft",
290            AppliedToPayment => "applied_to_payment",
291            Funded => "funded",
292            FundingReversed => "funding_reversed",
293            RefundedFromPayment => "refunded_from_payment",
294            ReturnCanceled => "return_canceled",
295            ReturnInitiated => "return_initiated",
296            TransferredToBalance => "transferred_to_balance",
297            UnappliedFromPayment => "unapplied_from_payment",
298        }
299    }
300}
301
302impl std::str::FromStr for CustomerCashBalanceTransactionType {
303    type Err = stripe_types::StripeParseError;
304    fn from_str(s: &str) -> Result<Self, Self::Err> {
305        use CustomerCashBalanceTransactionType::*;
306        match s {
307            "adjusted_for_overdraft" => Ok(AdjustedForOverdraft),
308            "applied_to_payment" => Ok(AppliedToPayment),
309            "funded" => Ok(Funded),
310            "funding_reversed" => Ok(FundingReversed),
311            "refunded_from_payment" => Ok(RefundedFromPayment),
312            "return_canceled" => Ok(ReturnCanceled),
313            "return_initiated" => Ok(ReturnInitiated),
314            "transferred_to_balance" => Ok(TransferredToBalance),
315            "unapplied_from_payment" => Ok(UnappliedFromPayment),
316            _ => Err(stripe_types::StripeParseError),
317        }
318    }
319}
320impl std::fmt::Display for CustomerCashBalanceTransactionType {
321    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
322        f.write_str(self.as_str())
323    }
324}
325
326impl std::fmt::Debug for CustomerCashBalanceTransactionType {
327    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
328        f.write_str(self.as_str())
329    }
330}
331#[cfg(feature = "serialize")]
332impl serde::Serialize for CustomerCashBalanceTransactionType {
333    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
334    where
335        S: serde::Serializer,
336    {
337        serializer.serialize_str(self.as_str())
338    }
339}
340impl miniserde::Deserialize for CustomerCashBalanceTransactionType {
341    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
342        crate::Place::new(out)
343    }
344}
345
346impl miniserde::de::Visitor for crate::Place<CustomerCashBalanceTransactionType> {
347    fn string(&mut self, s: &str) -> miniserde::Result<()> {
348        use std::str::FromStr;
349        self.out =
350            Some(CustomerCashBalanceTransactionType::from_str(s).map_err(|_| miniserde::Error)?);
351        Ok(())
352    }
353}
354
355stripe_types::impl_from_val_with_from_str!(CustomerCashBalanceTransactionType);
356#[cfg(feature = "deserialize")]
357impl<'de> serde::Deserialize<'de> for CustomerCashBalanceTransactionType {
358    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
359        use std::str::FromStr;
360        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
361        Self::from_str(&s).map_err(|_| {
362            serde::de::Error::custom("Unknown value for CustomerCashBalanceTransactionType")
363        })
364    }
365}
366impl stripe_types::Object for CustomerCashBalanceTransaction {
367    type Id = stripe_shared::CustomerCashBalanceTransactionId;
368    fn id(&self) -> &Self::Id {
369        &self.id
370    }
371
372    fn into_id(self) -> Self::Id {
373        self.id
374    }
375}
376stripe_types::def_id!(CustomerCashBalanceTransactionId);
stripe_shared/customer_cash_balance_transaction.rs

stripe_shared/
customer_cash_balance_transaction.rs
