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                _ => <dyn Visitor>::ignore(),
116            })
117        }
118
119        fn deser_default() -> Self {
120            Self {
121                adjusted_for_overdraft: Deserialize::default(),
122                applied_to_payment: Deserialize::default(),
123                created: Deserialize::default(),
124                currency: Deserialize::default(),
125                customer: Deserialize::default(),
126                ending_balance: Deserialize::default(),
127                funded: Deserialize::default(),
128                id: Deserialize::default(),
129                livemode: Deserialize::default(),
130                net_amount: Deserialize::default(),
131                refunded_from_payment: Deserialize::default(),
132                transferred_to_balance: Deserialize::default(),
133                type_: Deserialize::default(),
134                unapplied_from_payment: Deserialize::default(),
135            }
136        }
137
138        fn take_out(&mut self) -> Option<Self::Out> {
139            let (
140                Some(adjusted_for_overdraft),
141                Some(applied_to_payment),
142                Some(created),
143                Some(currency),
144                Some(customer),
145                Some(ending_balance),
146                Some(funded),
147                Some(id),
148                Some(livemode),
149                Some(net_amount),
150                Some(refunded_from_payment),
151                Some(transferred_to_balance),
152                Some(type_),
153                Some(unapplied_from_payment),
154            ) = (
155                self.adjusted_for_overdraft.take(),
156                self.applied_to_payment.take(),
157                self.created,
158                self.currency.take(),
159                self.customer.take(),
160                self.ending_balance,
161                self.funded.take(),
162                self.id.take(),
163                self.livemode,
164                self.net_amount,
165                self.refunded_from_payment.take(),
166                self.transferred_to_balance.take(),
167                self.type_.take(),
168                self.unapplied_from_payment.take(),
169            )
170            else {
171                return None;
172            };
173            Some(Self::Out {
174                adjusted_for_overdraft,
175                applied_to_payment,
176                created,
177                currency,
178                customer,
179                ending_balance,
180                funded,
181                id,
182                livemode,
183                net_amount,
184                refunded_from_payment,
185                transferred_to_balance,
186                type_,
187                unapplied_from_payment,
188            })
189        }
190    }
191
192    impl Map for Builder<'_> {
193        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
194            self.builder.key(k)
195        }
196
197        fn finish(&mut self) -> Result<()> {
198            *self.out = self.builder.take_out();
199            Ok(())
200        }
201    }
202
203    impl ObjectDeser for CustomerCashBalanceTransaction {
204        type Builder = CustomerCashBalanceTransactionBuilder;
205    }
206
207    impl FromValueOpt for CustomerCashBalanceTransaction {
208        fn from_value(v: Value) -> Option<Self> {
209            let Value::Object(obj) = v else {
210                return None;
211            };
212            let mut b = CustomerCashBalanceTransactionBuilder::deser_default();
213            for (k, v) in obj {
214                match k.as_str() {
215                    "adjusted_for_overdraft" => {
216                        b.adjusted_for_overdraft = FromValueOpt::from_value(v)
217                    }
218                    "applied_to_payment" => b.applied_to_payment = FromValueOpt::from_value(v),
219                    "created" => b.created = FromValueOpt::from_value(v),
220                    "currency" => b.currency = FromValueOpt::from_value(v),
221                    "customer" => b.customer = FromValueOpt::from_value(v),
222                    "ending_balance" => b.ending_balance = FromValueOpt::from_value(v),
223                    "funded" => b.funded = FromValueOpt::from_value(v),
224                    "id" => b.id = FromValueOpt::from_value(v),
225                    "livemode" => b.livemode = FromValueOpt::from_value(v),
226                    "net_amount" => b.net_amount = FromValueOpt::from_value(v),
227                    "refunded_from_payment" => {
228                        b.refunded_from_payment = FromValueOpt::from_value(v)
229                    }
230                    "transferred_to_balance" => {
231                        b.transferred_to_balance = FromValueOpt::from_value(v)
232                    }
233                    "type" => b.type_ = FromValueOpt::from_value(v),
234                    "unapplied_from_payment" => {
235                        b.unapplied_from_payment = FromValueOpt::from_value(v)
236                    }
237                    _ => {}
238                }
239            }
240            b.take_out()
241        }
242    }
243};
244#[cfg(feature = "serialize")]
245impl serde::Serialize for CustomerCashBalanceTransaction {
246    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
247        use serde::ser::SerializeStruct;
248        let mut s = s.serialize_struct("CustomerCashBalanceTransaction", 15)?;
249        s.serialize_field("adjusted_for_overdraft", &self.adjusted_for_overdraft)?;
250        s.serialize_field("applied_to_payment", &self.applied_to_payment)?;
251        s.serialize_field("created", &self.created)?;
252        s.serialize_field("currency", &self.currency)?;
253        s.serialize_field("customer", &self.customer)?;
254        s.serialize_field("ending_balance", &self.ending_balance)?;
255        s.serialize_field("funded", &self.funded)?;
256        s.serialize_field("id", &self.id)?;
257        s.serialize_field("livemode", &self.livemode)?;
258        s.serialize_field("net_amount", &self.net_amount)?;
259        s.serialize_field("refunded_from_payment", &self.refunded_from_payment)?;
260        s.serialize_field("transferred_to_balance", &self.transferred_to_balance)?;
261        s.serialize_field("type", &self.type_)?;
262        s.serialize_field("unapplied_from_payment", &self.unapplied_from_payment)?;
263
264        s.serialize_field("object", "customer_cash_balance_transaction")?;
265        s.end()
266    }
267}
268/// The type of the cash balance transaction.
269/// New types may be added in future.
270/// See [Customer Balance](https://stripe.com/docs/payments/customer-balance#types) to learn more about these types.
271#[derive(Clone, Eq, PartialEq)]
272#[non_exhaustive]
273pub enum CustomerCashBalanceTransactionType {
274    AdjustedForOverdraft,
275    AppliedToPayment,
276    Funded,
277    FundingReversed,
278    RefundedFromPayment,
279    ReturnCanceled,
280    ReturnInitiated,
281    TransferredToBalance,
282    UnappliedFromPayment,
283    /// An unrecognized value from Stripe. Should not be used as a request parameter.
284    Unknown(String),
285}
286impl CustomerCashBalanceTransactionType {
287    pub fn as_str(&self) -> &str {
288        use CustomerCashBalanceTransactionType::*;
289        match self {
290            AdjustedForOverdraft => "adjusted_for_overdraft",
291            AppliedToPayment => "applied_to_payment",
292            Funded => "funded",
293            FundingReversed => "funding_reversed",
294            RefundedFromPayment => "refunded_from_payment",
295            ReturnCanceled => "return_canceled",
296            ReturnInitiated => "return_initiated",
297            TransferredToBalance => "transferred_to_balance",
298            UnappliedFromPayment => "unapplied_from_payment",
299            Unknown(v) => v,
300        }
301    }
302}
303
304impl std::str::FromStr for CustomerCashBalanceTransactionType {
305    type Err = std::convert::Infallible;
306    fn from_str(s: &str) -> Result<Self, Self::Err> {
307        use CustomerCashBalanceTransactionType::*;
308        match s {
309            "adjusted_for_overdraft" => Ok(AdjustedForOverdraft),
310            "applied_to_payment" => Ok(AppliedToPayment),
311            "funded" => Ok(Funded),
312            "funding_reversed" => Ok(FundingReversed),
313            "refunded_from_payment" => Ok(RefundedFromPayment),
314            "return_canceled" => Ok(ReturnCanceled),
315            "return_initiated" => Ok(ReturnInitiated),
316            "transferred_to_balance" => Ok(TransferredToBalance),
317            "unapplied_from_payment" => Ok(UnappliedFromPayment),
318            v => {
319                tracing::warn!(
320                    "Unknown value '{}' for enum '{}'",
321                    v,
322                    "CustomerCashBalanceTransactionType"
323                );
324                Ok(Unknown(v.to_owned()))
325            }
326        }
327    }
328}
329impl std::fmt::Display for CustomerCashBalanceTransactionType {
330    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
331        f.write_str(self.as_str())
332    }
333}
334
335impl std::fmt::Debug for CustomerCashBalanceTransactionType {
336    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
337        f.write_str(self.as_str())
338    }
339}
340#[cfg(feature = "serialize")]
341impl serde::Serialize for CustomerCashBalanceTransactionType {
342    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
343    where
344        S: serde::Serializer,
345    {
346        serializer.serialize_str(self.as_str())
347    }
348}
349impl miniserde::Deserialize for CustomerCashBalanceTransactionType {
350    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
351        crate::Place::new(out)
352    }
353}
354
355impl miniserde::de::Visitor for crate::Place<CustomerCashBalanceTransactionType> {
356    fn string(&mut self, s: &str) -> miniserde::Result<()> {
357        use std::str::FromStr;
358        self.out = Some(CustomerCashBalanceTransactionType::from_str(s).expect("infallible"));
359        Ok(())
360    }
361}
362
363stripe_types::impl_from_val_with_from_str!(CustomerCashBalanceTransactionType);
364#[cfg(feature = "deserialize")]
365impl<'de> serde::Deserialize<'de> for CustomerCashBalanceTransactionType {
366    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
367        use std::str::FromStr;
368        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
369        Ok(Self::from_str(&s).expect("infallible"))
370    }
371}
372impl stripe_types::Object for CustomerCashBalanceTransaction {
373    type Id = stripe_shared::CustomerCashBalanceTransactionId;
374    fn id(&self) -> &Self::Id {
375        &self.id
376    }
377
378    fn into_id(self) -> Self::Id {
379        self.id
380    }
381}
382stripe_types::def_id!(CustomerCashBalanceTransactionId);
stripe_shared/customer_cash_balance_transaction.rs

stripe_shared/
customer_cash_balance_transaction.rs
