1#[derive(Clone, Debug)]
17#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
18pub struct TransferReversal {
19 pub amount: i64,
21 pub balance_transaction: Option<stripe_types::Expandable<stripe_shared::BalanceTransaction>>,
23 pub created: stripe_types::Timestamp,
25 pub currency: stripe_types::Currency,
28 pub destination_payment_refund: Option<stripe_types::Expandable<stripe_shared::Refund>>,
30 pub id: stripe_shared::TransferReversalId,
32 pub metadata: Option<std::collections::HashMap<String, String>>,
35 pub source_refund: Option<stripe_types::Expandable<stripe_shared::Refund>>,
37 pub transfer: stripe_types::Expandable<stripe_shared::Transfer>,
39}
40#[doc(hidden)]
41pub struct TransferReversalBuilder {
42 amount: Option<i64>,
43 balance_transaction:
44 Option<Option<stripe_types::Expandable<stripe_shared::BalanceTransaction>>>,
45 created: Option<stripe_types::Timestamp>,
46 currency: Option<stripe_types::Currency>,
47 destination_payment_refund: Option<Option<stripe_types::Expandable<stripe_shared::Refund>>>,
48 id: Option<stripe_shared::TransferReversalId>,
49 metadata: Option<Option<std::collections::HashMap<String, String>>>,
50 source_refund: Option<Option<stripe_types::Expandable<stripe_shared::Refund>>>,
51 transfer: Option<stripe_types::Expandable<stripe_shared::Transfer>>,
52}
53
54#[allow(
55 unused_variables,
56 irrefutable_let_patterns,
57 clippy::let_unit_value,
58 clippy::match_single_binding,
59 clippy::single_match
60)]
61const _: () = {
62 use miniserde::de::{Map, Visitor};
63 use miniserde::json::Value;
64 use miniserde::{make_place, Deserialize, Result};
65 use stripe_types::miniserde_helpers::FromValueOpt;
66 use stripe_types::{MapBuilder, ObjectDeser};
67
68 make_place!(Place);
69
70 impl Deserialize for TransferReversal {
71 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
72 Place::new(out)
73 }
74 }
75
76 struct Builder<'a> {
77 out: &'a mut Option<TransferReversal>,
78 builder: TransferReversalBuilder,
79 }
80
81 impl Visitor for Place<TransferReversal> {
82 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
83 Ok(Box::new(Builder {
84 out: &mut self.out,
85 builder: TransferReversalBuilder::deser_default(),
86 }))
87 }
88 }
89
90 impl MapBuilder for TransferReversalBuilder {
91 type Out = TransferReversal;
92 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
93 Ok(match k {
94 "amount" => Deserialize::begin(&mut self.amount),
95 "balance_transaction" => Deserialize::begin(&mut self.balance_transaction),
96 "created" => Deserialize::begin(&mut self.created),
97 "currency" => Deserialize::begin(&mut self.currency),
98 "destination_payment_refund" => {
99 Deserialize::begin(&mut self.destination_payment_refund)
100 }
101 "id" => Deserialize::begin(&mut self.id),
102 "metadata" => Deserialize::begin(&mut self.metadata),
103 "source_refund" => Deserialize::begin(&mut self.source_refund),
104 "transfer" => Deserialize::begin(&mut self.transfer),
105
106 _ => <dyn Visitor>::ignore(),
107 })
108 }
109
110 fn deser_default() -> Self {
111 Self {
112 amount: Deserialize::default(),
113 balance_transaction: Deserialize::default(),
114 created: Deserialize::default(),
115 currency: Deserialize::default(),
116 destination_payment_refund: Deserialize::default(),
117 id: Deserialize::default(),
118 metadata: Deserialize::default(),
119 source_refund: Deserialize::default(),
120 transfer: Deserialize::default(),
121 }
122 }
123
124 fn take_out(&mut self) -> Option<Self::Out> {
125 let (
126 Some(amount),
127 Some(balance_transaction),
128 Some(created),
129 Some(currency),
130 Some(destination_payment_refund),
131 Some(id),
132 Some(metadata),
133 Some(source_refund),
134 Some(transfer),
135 ) = (
136 self.amount,
137 self.balance_transaction.take(),
138 self.created,
139 self.currency,
140 self.destination_payment_refund.take(),
141 self.id.take(),
142 self.metadata.take(),
143 self.source_refund.take(),
144 self.transfer.take(),
145 )
146 else {
147 return None;
148 };
149 Some(Self::Out {
150 amount,
151 balance_transaction,
152 created,
153 currency,
154 destination_payment_refund,
155 id,
156 metadata,
157 source_refund,
158 transfer,
159 })
160 }
161 }
162
163 impl<'a> Map for Builder<'a> {
164 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
165 self.builder.key(k)
166 }
167
168 fn finish(&mut self) -> Result<()> {
169 *self.out = self.builder.take_out();
170 Ok(())
171 }
172 }
173
174 impl ObjectDeser for TransferReversal {
175 type Builder = TransferReversalBuilder;
176 }
177
178 impl FromValueOpt for TransferReversal {
179 fn from_value(v: Value) -> Option<Self> {
180 let Value::Object(obj) = v else {
181 return None;
182 };
183 let mut b = TransferReversalBuilder::deser_default();
184 for (k, v) in obj {
185 match k.as_str() {
186 "amount" => b.amount = FromValueOpt::from_value(v),
187 "balance_transaction" => b.balance_transaction = FromValueOpt::from_value(v),
188 "created" => b.created = FromValueOpt::from_value(v),
189 "currency" => b.currency = FromValueOpt::from_value(v),
190 "destination_payment_refund" => {
191 b.destination_payment_refund = FromValueOpt::from_value(v)
192 }
193 "id" => b.id = FromValueOpt::from_value(v),
194 "metadata" => b.metadata = FromValueOpt::from_value(v),
195 "source_refund" => b.source_refund = FromValueOpt::from_value(v),
196 "transfer" => b.transfer = FromValueOpt::from_value(v),
197
198 _ => {}
199 }
200 }
201 b.take_out()
202 }
203 }
204};
205#[cfg(feature = "serialize")]
206impl serde::Serialize for TransferReversal {
207 fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
208 use serde::ser::SerializeStruct;
209 let mut s = s.serialize_struct("TransferReversal", 10)?;
210 s.serialize_field("amount", &self.amount)?;
211 s.serialize_field("balance_transaction", &self.balance_transaction)?;
212 s.serialize_field("created", &self.created)?;
213 s.serialize_field("currency", &self.currency)?;
214 s.serialize_field("destination_payment_refund", &self.destination_payment_refund)?;
215 s.serialize_field("id", &self.id)?;
216 s.serialize_field("metadata", &self.metadata)?;
217 s.serialize_field("source_refund", &self.source_refund)?;
218 s.serialize_field("transfer", &self.transfer)?;
219
220 s.serialize_field("object", "transfer_reversal")?;
221 s.end()
222 }
223}
224impl stripe_types::Object for TransferReversal {
225 type Id = stripe_shared::TransferReversalId;
226 fn id(&self) -> &Self::Id {
227 &self.id
228 }
229
230 fn into_id(self) -> Self::Id {
231 self.id
232 }
233}
234stripe_types::def_id!(TransferReversalId);