stripe_shared/
issuing_dispute_evidence.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct IssuingDisputeEvidence {
5    pub canceled: Option<stripe_shared::IssuingDisputeCanceledEvidence>,
6    pub duplicate: Option<stripe_shared::IssuingDisputeDuplicateEvidence>,
7    pub fraudulent: Option<stripe_shared::IssuingDisputeFraudulentEvidence>,
8    pub merchandise_not_as_described:
9        Option<stripe_shared::IssuingDisputeMerchandiseNotAsDescribedEvidence>,
10    pub no_valid_authorization: Option<stripe_shared::IssuingDisputeNoValidAuthorizationEvidence>,
11    pub not_received: Option<stripe_shared::IssuingDisputeNotReceivedEvidence>,
12    pub other: Option<stripe_shared::IssuingDisputeOtherEvidence>,
13    /// The reason for filing the dispute. Its value will match the field containing the evidence.
14    pub reason: IssuingDisputeEvidenceReason,
15    pub service_not_as_described:
16        Option<stripe_shared::IssuingDisputeServiceNotAsDescribedEvidence>,
17}
18#[doc(hidden)]
19pub struct IssuingDisputeEvidenceBuilder {
20    canceled: Option<Option<stripe_shared::IssuingDisputeCanceledEvidence>>,
21    duplicate: Option<Option<stripe_shared::IssuingDisputeDuplicateEvidence>>,
22    fraudulent: Option<Option<stripe_shared::IssuingDisputeFraudulentEvidence>>,
23    merchandise_not_as_described:
24        Option<Option<stripe_shared::IssuingDisputeMerchandiseNotAsDescribedEvidence>>,
25    no_valid_authorization:
26        Option<Option<stripe_shared::IssuingDisputeNoValidAuthorizationEvidence>>,
27    not_received: Option<Option<stripe_shared::IssuingDisputeNotReceivedEvidence>>,
28    other: Option<Option<stripe_shared::IssuingDisputeOtherEvidence>>,
29    reason: Option<IssuingDisputeEvidenceReason>,
30    service_not_as_described:
31        Option<Option<stripe_shared::IssuingDisputeServiceNotAsDescribedEvidence>>,
32}
33
34#[allow(
35    unused_variables,
36    irrefutable_let_patterns,
37    clippy::let_unit_value,
38    clippy::match_single_binding,
39    clippy::single_match
40)]
41const _: () = {
42    use miniserde::de::{Map, Visitor};
43    use miniserde::json::Value;
44    use miniserde::{Deserialize, Result, make_place};
45    use stripe_types::miniserde_helpers::FromValueOpt;
46    use stripe_types::{MapBuilder, ObjectDeser};
47
48    make_place!(Place);
49
50    impl Deserialize for IssuingDisputeEvidence {
51        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
52            Place::new(out)
53        }
54    }
55
56    struct Builder<'a> {
57        out: &'a mut Option<IssuingDisputeEvidence>,
58        builder: IssuingDisputeEvidenceBuilder,
59    }
60
61    impl Visitor for Place<IssuingDisputeEvidence> {
62        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
63            Ok(Box::new(Builder {
64                out: &mut self.out,
65                builder: IssuingDisputeEvidenceBuilder::deser_default(),
66            }))
67        }
68    }
69
70    impl MapBuilder for IssuingDisputeEvidenceBuilder {
71        type Out = IssuingDisputeEvidence;
72        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
73            Ok(match k {
74                "canceled" => Deserialize::begin(&mut self.canceled),
75                "duplicate" => Deserialize::begin(&mut self.duplicate),
76                "fraudulent" => Deserialize::begin(&mut self.fraudulent),
77                "merchandise_not_as_described" => {
78                    Deserialize::begin(&mut self.merchandise_not_as_described)
79                }
80                "no_valid_authorization" => Deserialize::begin(&mut self.no_valid_authorization),
81                "not_received" => Deserialize::begin(&mut self.not_received),
82                "other" => Deserialize::begin(&mut self.other),
83                "reason" => Deserialize::begin(&mut self.reason),
84                "service_not_as_described" => {
85                    Deserialize::begin(&mut self.service_not_as_described)
86                }
87
88                _ => <dyn Visitor>::ignore(),
89            })
90        }
91
92        fn deser_default() -> Self {
93            Self {
94                canceled: Deserialize::default(),
95                duplicate: Deserialize::default(),
96                fraudulent: Deserialize::default(),
97                merchandise_not_as_described: Deserialize::default(),
98                no_valid_authorization: Deserialize::default(),
99                not_received: Deserialize::default(),
100                other: Deserialize::default(),
101                reason: Deserialize::default(),
102                service_not_as_described: Deserialize::default(),
103            }
104        }
105
106        fn take_out(&mut self) -> Option<Self::Out> {
107            let (
108                Some(canceled),
109                Some(duplicate),
110                Some(fraudulent),
111                Some(merchandise_not_as_described),
112                Some(no_valid_authorization),
113                Some(not_received),
114                Some(other),
115                Some(reason),
116                Some(service_not_as_described),
117            ) = (
118                self.canceled.take(),
119                self.duplicate.take(),
120                self.fraudulent.take(),
121                self.merchandise_not_as_described.take(),
122                self.no_valid_authorization.take(),
123                self.not_received.take(),
124                self.other.take(),
125                self.reason,
126                self.service_not_as_described.take(),
127            )
128            else {
129                return None;
130            };
131            Some(Self::Out {
132                canceled,
133                duplicate,
134                fraudulent,
135                merchandise_not_as_described,
136                no_valid_authorization,
137                not_received,
138                other,
139                reason,
140                service_not_as_described,
141            })
142        }
143    }
144
145    impl Map for Builder<'_> {
146        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
147            self.builder.key(k)
148        }
149
150        fn finish(&mut self) -> Result<()> {
151            *self.out = self.builder.take_out();
152            Ok(())
153        }
154    }
155
156    impl ObjectDeser for IssuingDisputeEvidence {
157        type Builder = IssuingDisputeEvidenceBuilder;
158    }
159
160    impl FromValueOpt for IssuingDisputeEvidence {
161        fn from_value(v: Value) -> Option<Self> {
162            let Value::Object(obj) = v else {
163                return None;
164            };
165            let mut b = IssuingDisputeEvidenceBuilder::deser_default();
166            for (k, v) in obj {
167                match k.as_str() {
168                    "canceled" => b.canceled = FromValueOpt::from_value(v),
169                    "duplicate" => b.duplicate = FromValueOpt::from_value(v),
170                    "fraudulent" => b.fraudulent = FromValueOpt::from_value(v),
171                    "merchandise_not_as_described" => {
172                        b.merchandise_not_as_described = FromValueOpt::from_value(v)
173                    }
174                    "no_valid_authorization" => {
175                        b.no_valid_authorization = FromValueOpt::from_value(v)
176                    }
177                    "not_received" => b.not_received = FromValueOpt::from_value(v),
178                    "other" => b.other = FromValueOpt::from_value(v),
179                    "reason" => b.reason = FromValueOpt::from_value(v),
180                    "service_not_as_described" => {
181                        b.service_not_as_described = FromValueOpt::from_value(v)
182                    }
183
184                    _ => {}
185                }
186            }
187            b.take_out()
188        }
189    }
190};
191/// The reason for filing the dispute. Its value will match the field containing the evidence.
192#[derive(Copy, Clone, Eq, PartialEq)]
193pub enum IssuingDisputeEvidenceReason {
194    Canceled,
195    Duplicate,
196    Fraudulent,
197    MerchandiseNotAsDescribed,
198    NoValidAuthorization,
199    NotReceived,
200    Other,
201    ServiceNotAsDescribed,
202}
203impl IssuingDisputeEvidenceReason {
204    pub fn as_str(self) -> &'static str {
205        use IssuingDisputeEvidenceReason::*;
206        match self {
207            Canceled => "canceled",
208            Duplicate => "duplicate",
209            Fraudulent => "fraudulent",
210            MerchandiseNotAsDescribed => "merchandise_not_as_described",
211            NoValidAuthorization => "no_valid_authorization",
212            NotReceived => "not_received",
213            Other => "other",
214            ServiceNotAsDescribed => "service_not_as_described",
215        }
216    }
217}
218
219impl std::str::FromStr for IssuingDisputeEvidenceReason {
220    type Err = stripe_types::StripeParseError;
221    fn from_str(s: &str) -> Result<Self, Self::Err> {
222        use IssuingDisputeEvidenceReason::*;
223        match s {
224            "canceled" => Ok(Canceled),
225            "duplicate" => Ok(Duplicate),
226            "fraudulent" => Ok(Fraudulent),
227            "merchandise_not_as_described" => Ok(MerchandiseNotAsDescribed),
228            "no_valid_authorization" => Ok(NoValidAuthorization),
229            "not_received" => Ok(NotReceived),
230            "other" => Ok(Other),
231            "service_not_as_described" => Ok(ServiceNotAsDescribed),
232            _ => Err(stripe_types::StripeParseError),
233        }
234    }
235}
236impl std::fmt::Display for IssuingDisputeEvidenceReason {
237    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
238        f.write_str(self.as_str())
239    }
240}
241
242impl std::fmt::Debug for IssuingDisputeEvidenceReason {
243    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
244        f.write_str(self.as_str())
245    }
246}
247#[cfg(feature = "serialize")]
248impl serde::Serialize for IssuingDisputeEvidenceReason {
249    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
250    where
251        S: serde::Serializer,
252    {
253        serializer.serialize_str(self.as_str())
254    }
255}
256impl miniserde::Deserialize for IssuingDisputeEvidenceReason {
257    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
258        crate::Place::new(out)
259    }
260}
261
262impl miniserde::de::Visitor for crate::Place<IssuingDisputeEvidenceReason> {
263    fn string(&mut self, s: &str) -> miniserde::Result<()> {
264        use std::str::FromStr;
265        self.out = Some(IssuingDisputeEvidenceReason::from_str(s).map_err(|_| miniserde::Error)?);
266        Ok(())
267    }
268}
269
270stripe_types::impl_from_val_with_from_str!(IssuingDisputeEvidenceReason);
271#[cfg(feature = "deserialize")]
272impl<'de> serde::Deserialize<'de> for IssuingDisputeEvidenceReason {
273    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
274        use std::str::FromStr;
275        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
276        Self::from_str(&s)
277            .map_err(|_| serde::de::Error::custom("Unknown value for IssuingDisputeEvidenceReason"))
278    }
279}
stripe_shared/issuing_dispute_evidence.rs

stripe_shared/
issuing_dispute_evidence.rs
