stripe_shared/
balance_transaction_source.rs

1/// The resource representing a Stripe Polymorphic
2#[derive(Clone)]
3#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
4#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
5#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
6#[cfg_attr(any(feature = "deserialize", feature = "serialize"), serde(tag = "object"))]
7pub enum BalanceTransactionSource {
8    #[cfg_attr(
9        any(feature = "deserialize", feature = "serialize"),
10        serde(rename = "application_fee")
11    )]
12    ApplicationFee(stripe_shared::ApplicationFee),
13    #[cfg_attr(any(feature = "deserialize", feature = "serialize"), serde(rename = "charge"))]
14    Charge(stripe_shared::Charge),
15    #[cfg_attr(
16        any(feature = "deserialize", feature = "serialize"),
17        serde(rename = "connect_collection_transfer")
18    )]
19    ConnectCollectionTransfer(stripe_shared::ConnectCollectionTransfer),
20    #[cfg_attr(
21        any(feature = "deserialize", feature = "serialize"),
22        serde(rename = "customer_cash_balance_transaction")
23    )]
24    CustomerCashBalanceTransaction(stripe_shared::CustomerCashBalanceTransaction),
25    #[cfg_attr(any(feature = "deserialize", feature = "serialize"), serde(rename = "dispute"))]
26    Dispute(stripe_shared::Dispute),
27    #[cfg_attr(any(feature = "deserialize", feature = "serialize"), serde(rename = "fee_refund"))]
28    ApplicationFeeRefund(stripe_shared::ApplicationFeeRefund),
29    #[cfg_attr(
30        any(feature = "deserialize", feature = "serialize"),
31        serde(rename = "issuing.authorization")
32    )]
33    IssuingAuthorization(stripe_shared::IssuingAuthorization),
34    #[cfg_attr(
35        any(feature = "deserialize", feature = "serialize"),
36        serde(rename = "issuing.dispute")
37    )]
38    IssuingDispute(stripe_shared::IssuingDispute),
39    #[cfg_attr(
40        any(feature = "deserialize", feature = "serialize"),
41        serde(rename = "issuing.transaction")
42    )]
43    IssuingTransaction(stripe_shared::IssuingTransaction),
44    #[cfg_attr(any(feature = "deserialize", feature = "serialize"), serde(rename = "payout"))]
45    Payout(stripe_shared::Payout),
46    #[cfg_attr(any(feature = "deserialize", feature = "serialize"), serde(rename = "refund"))]
47    Refund(stripe_shared::Refund),
48    #[cfg_attr(
49        any(feature = "deserialize", feature = "serialize"),
50        serde(rename = "reserve_transaction")
51    )]
52    ReserveTransaction(stripe_shared::ReserveTransaction),
53    #[cfg_attr(
54        any(feature = "deserialize", feature = "serialize"),
55        serde(rename = "tax_deducted_at_source")
56    )]
57    TaxDeductedAtSource(stripe_shared::TaxDeductedAtSource),
58    #[cfg_attr(any(feature = "deserialize", feature = "serialize"), serde(rename = "topup"))]
59    Topup(stripe_shared::Topup),
60    #[cfg_attr(any(feature = "deserialize", feature = "serialize"), serde(rename = "transfer"))]
61    Transfer(stripe_shared::Transfer),
62    #[cfg_attr(
63        any(feature = "deserialize", feature = "serialize"),
64        serde(rename = "transfer_reversal")
65    )]
66    TransferReversal(stripe_shared::TransferReversal),
67}
68
69#[derive(Default)]
70pub struct BalanceTransactionSourceBuilder {
71    inner: stripe_types::miniserde_helpers::ObjectBuilderInner,
72}
73
74const _: () = {
75    use miniserde::de::{Map, Visitor};
76    use miniserde::json::Value;
77    use miniserde::{Deserialize, Result, make_place};
78    use stripe_types::MapBuilder;
79    use stripe_types::miniserde_helpers::FromValueOpt;
80
81    use super::*;
82
83    make_place!(Place);
84
85    struct Builder<'a> {
86        out: &'a mut Option<BalanceTransactionSource>,
87        builder: BalanceTransactionSourceBuilder,
88    }
89
90    impl Deserialize for BalanceTransactionSource {
91        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
92            Place::new(out)
93        }
94    }
95
96    impl Visitor for Place<BalanceTransactionSource> {
97        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
98            Ok(Box::new(Builder { out: &mut self.out, builder: Default::default() }))
99        }
100    }
101
102    impl Map for Builder<'_> {
103        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
104            self.builder.key(k)
105        }
106
107        fn finish(&mut self) -> Result<()> {
108            *self.out = self.builder.take_out();
109            Ok(())
110        }
111    }
112
113    impl MapBuilder for BalanceTransactionSourceBuilder {
114        type Out = BalanceTransactionSource;
115        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
116            self.inner.key_inner(k)
117        }
118
119        fn deser_default() -> Self {
120            Self::default()
121        }
122
123        fn take_out(&mut self) -> Option<Self::Out> {
124            let (k, o) = self.inner.finish_inner()?;
125            BalanceTransactionSource::construct(&k, o)
126        }
127    }
128
129    impl stripe_types::ObjectDeser for BalanceTransactionSource {
130        type Builder = BalanceTransactionSourceBuilder;
131    }
132    impl BalanceTransactionSource {
133        fn construct(key: &str, o: miniserde::json::Object) -> Option<Self> {
134            Some(match key {
135                "application_fee" => {
136                    Self::ApplicationFee(FromValueOpt::from_value(Value::Object(o))?)
137                }
138                "charge" => Self::Charge(FromValueOpt::from_value(Value::Object(o))?),
139                "connect_collection_transfer" => {
140                    Self::ConnectCollectionTransfer(FromValueOpt::from_value(Value::Object(o))?)
141                }
142                "customer_cash_balance_transaction" => Self::CustomerCashBalanceTransaction(
143                    FromValueOpt::from_value(Value::Object(o))?,
144                ),
145                "dispute" => Self::Dispute(FromValueOpt::from_value(Value::Object(o))?),
146                "fee_refund" => {
147                    Self::ApplicationFeeRefund(FromValueOpt::from_value(Value::Object(o))?)
148                }
149                "issuing.authorization" => {
150                    Self::IssuingAuthorization(FromValueOpt::from_value(Value::Object(o))?)
151                }
152                "issuing.dispute" => {
153                    Self::IssuingDispute(FromValueOpt::from_value(Value::Object(o))?)
154                }
155                "issuing.transaction" => {
156                    Self::IssuingTransaction(FromValueOpt::from_value(Value::Object(o))?)
157                }
158                "payout" => Self::Payout(FromValueOpt::from_value(Value::Object(o))?),
159                "refund" => Self::Refund(FromValueOpt::from_value(Value::Object(o))?),
160                "reserve_transaction" => {
161                    Self::ReserveTransaction(FromValueOpt::from_value(Value::Object(o))?)
162                }
163                "tax_deducted_at_source" => {
164                    Self::TaxDeductedAtSource(FromValueOpt::from_value(Value::Object(o))?)
165                }
166                "topup" => Self::Topup(FromValueOpt::from_value(Value::Object(o))?),
167                "transfer" => Self::Transfer(FromValueOpt::from_value(Value::Object(o))?),
168                "transfer_reversal" => {
169                    Self::TransferReversal(FromValueOpt::from_value(Value::Object(o))?)
170                }
171
172                _ => {
173                    tracing::warn!(
174                        "Unknown object type '{}' for enum '{}'",
175                        key,
176                        "BalanceTransactionSource"
177                    );
178                    return None;
179                }
180            })
181        }
182    }
183
184    impl FromValueOpt for BalanceTransactionSource {
185        fn from_value(v: Value) -> Option<Self> {
186            let (typ, obj) = stripe_types::miniserde_helpers::extract_object_discr(v)?;
187            Self::construct(&typ, obj)
188        }
189    }
190};
191
192#[cfg(feature = "redact-generated-debug")]
193impl std::fmt::Debug for BalanceTransactionSource {
194    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
195        f.debug_struct("BalanceTransactionSource").finish_non_exhaustive()
196    }
197}
198impl stripe_types::Object for BalanceTransactionSource {
199    type Id = smol_str::SmolStr;
200    fn id(&self) -> &Self::Id {
201        match self {
202            Self::ApplicationFee(v) => v.id.inner(),
203            Self::Charge(v) => v.id.inner(),
204            Self::ConnectCollectionTransfer(v) => v.id.inner(),
205            Self::CustomerCashBalanceTransaction(v) => v.id.inner(),
206            Self::Dispute(v) => v.id.inner(),
207            Self::ApplicationFeeRefund(v) => v.id.inner(),
208            Self::IssuingAuthorization(v) => v.id.inner(),
209            Self::IssuingDispute(v) => v.id.inner(),
210            Self::IssuingTransaction(v) => v.id.inner(),
211            Self::Payout(v) => v.id.inner(),
212            Self::Refund(v) => v.id.inner(),
213            Self::ReserveTransaction(v) => v.id.inner(),
214            Self::TaxDeductedAtSource(v) => v.id.inner(),
215            Self::Topup(v) => v.id.inner(),
216            Self::Transfer(v) => v.id.inner(),
217            Self::TransferReversal(v) => v.id.inner(),
218        }
219    }
220
221    fn into_id(self) -> Self::Id {
222        match self {
223            Self::ApplicationFee(v) => v.id.into_inner(),
224            Self::Charge(v) => v.id.into_inner(),
225            Self::ConnectCollectionTransfer(v) => v.id.into_inner(),
226            Self::CustomerCashBalanceTransaction(v) => v.id.into_inner(),
227            Self::Dispute(v) => v.id.into_inner(),
228            Self::ApplicationFeeRefund(v) => v.id.into_inner(),
229            Self::IssuingAuthorization(v) => v.id.into_inner(),
230            Self::IssuingDispute(v) => v.id.into_inner(),
231            Self::IssuingTransaction(v) => v.id.into_inner(),
232            Self::Payout(v) => v.id.into_inner(),
233            Self::Refund(v) => v.id.into_inner(),
234            Self::ReserveTransaction(v) => v.id.into_inner(),
235            Self::TaxDeductedAtSource(v) => v.id.into_inner(),
236            Self::Topup(v) => v.id.into_inner(),
237            Self::Transfer(v) => v.id.into_inner(),
238            Self::TransferReversal(v) => v.id.into_inner(),
239        }
240    }
241}
stripe_shared/balance_transaction_source.rs

stripe_shared/
balance_transaction_source.rs
