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                _ => <dyn Visitor>::ignore(),
88            })
89        }
90
91        fn deser_default() -> Self {
92            Self {
93                canceled: Deserialize::default(),
94                duplicate: Deserialize::default(),
95                fraudulent: Deserialize::default(),
96                merchandise_not_as_described: Deserialize::default(),
97                no_valid_authorization: Deserialize::default(),
98                not_received: Deserialize::default(),
99                other: Deserialize::default(),
100                reason: Deserialize::default(),
101                service_not_as_described: Deserialize::default(),
102            }
103        }
104
105        fn take_out(&mut self) -> Option<Self::Out> {
106            let (
107                Some(canceled),
108                Some(duplicate),
109                Some(fraudulent),
110                Some(merchandise_not_as_described),
111                Some(no_valid_authorization),
112                Some(not_received),
113                Some(other),
114                Some(reason),
115                Some(service_not_as_described),
116            ) = (
117                self.canceled.take(),
118                self.duplicate.take(),
119                self.fraudulent.take(),
120                self.merchandise_not_as_described.take(),
121                self.no_valid_authorization.take(),
122                self.not_received.take(),
123                self.other.take(),
124                self.reason,
125                self.service_not_as_described.take(),
126            )
127            else {
128                return None;
129            };
130            Some(Self::Out {
131                canceled,
132                duplicate,
133                fraudulent,
134                merchandise_not_as_described,
135                no_valid_authorization,
136                not_received,
137                other,
138                reason,
139                service_not_as_described,
140            })
141        }
142    }
143
144    impl Map for Builder<'_> {
145        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
146            self.builder.key(k)
147        }
148
149        fn finish(&mut self) -> Result<()> {
150            *self.out = self.builder.take_out();
151            Ok(())
152        }
153    }
154
155    impl ObjectDeser for IssuingDisputeEvidence {
156        type Builder = IssuingDisputeEvidenceBuilder;
157    }
158
159    impl FromValueOpt for IssuingDisputeEvidence {
160        fn from_value(v: Value) -> Option<Self> {
161            let Value::Object(obj) = v else {
162                return None;
163            };
164            let mut b = IssuingDisputeEvidenceBuilder::deser_default();
165            for (k, v) in obj {
166                match k.as_str() {
167                    "canceled" => b.canceled = FromValueOpt::from_value(v),
168                    "duplicate" => b.duplicate = FromValueOpt::from_value(v),
169                    "fraudulent" => b.fraudulent = FromValueOpt::from_value(v),
170                    "merchandise_not_as_described" => {
171                        b.merchandise_not_as_described = FromValueOpt::from_value(v)
172                    }
173                    "no_valid_authorization" => {
174                        b.no_valid_authorization = FromValueOpt::from_value(v)
175                    }
176                    "not_received" => b.not_received = FromValueOpt::from_value(v),
177                    "other" => b.other = FromValueOpt::from_value(v),
178                    "reason" => b.reason = FromValueOpt::from_value(v),
179                    "service_not_as_described" => {
180                        b.service_not_as_described = FromValueOpt::from_value(v)
181                    }
182                    _ => {}
183                }
184            }
185            b.take_out()
186        }
187    }
188};
189/// The reason for filing the dispute. Its value will match the field containing the evidence.
190#[derive(Copy, Clone, Eq, PartialEq)]
191pub enum IssuingDisputeEvidenceReason {
192    Canceled,
193    Duplicate,
194    Fraudulent,
195    MerchandiseNotAsDescribed,
196    NoValidAuthorization,
197    NotReceived,
198    Other,
199    ServiceNotAsDescribed,
200}
201impl IssuingDisputeEvidenceReason {
202    pub fn as_str(self) -> &'static str {
203        use IssuingDisputeEvidenceReason::*;
204        match self {
205            Canceled => "canceled",
206            Duplicate => "duplicate",
207            Fraudulent => "fraudulent",
208            MerchandiseNotAsDescribed => "merchandise_not_as_described",
209            NoValidAuthorization => "no_valid_authorization",
210            NotReceived => "not_received",
211            Other => "other",
212            ServiceNotAsDescribed => "service_not_as_described",
213        }
214    }
215}
216
217impl std::str::FromStr for IssuingDisputeEvidenceReason {
218    type Err = stripe_types::StripeParseError;
219    fn from_str(s: &str) -> Result<Self, Self::Err> {
220        use IssuingDisputeEvidenceReason::*;
221        match s {
222            "canceled" => Ok(Canceled),
223            "duplicate" => Ok(Duplicate),
224            "fraudulent" => Ok(Fraudulent),
225            "merchandise_not_as_described" => Ok(MerchandiseNotAsDescribed),
226            "no_valid_authorization" => Ok(NoValidAuthorization),
227            "not_received" => Ok(NotReceived),
228            "other" => Ok(Other),
229            "service_not_as_described" => Ok(ServiceNotAsDescribed),
230            _ => Err(stripe_types::StripeParseError),
231        }
232    }
233}
234impl std::fmt::Display for IssuingDisputeEvidenceReason {
235    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
236        f.write_str(self.as_str())
237    }
238}
239
240impl std::fmt::Debug for IssuingDisputeEvidenceReason {
241    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
242        f.write_str(self.as_str())
243    }
244}
245#[cfg(feature = "serialize")]
246impl serde::Serialize for IssuingDisputeEvidenceReason {
247    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
248    where
249        S: serde::Serializer,
250    {
251        serializer.serialize_str(self.as_str())
252    }
253}
254impl miniserde::Deserialize for IssuingDisputeEvidenceReason {
255    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
256        crate::Place::new(out)
257    }
258}
259
260impl miniserde::de::Visitor for crate::Place<IssuingDisputeEvidenceReason> {
261    fn string(&mut self, s: &str) -> miniserde::Result<()> {
262        use std::str::FromStr;
263        self.out = Some(IssuingDisputeEvidenceReason::from_str(s).map_err(|_| miniserde::Error)?);
264        Ok(())
265    }
266}
267
268stripe_types::impl_from_val_with_from_str!(IssuingDisputeEvidenceReason);
269#[cfg(feature = "deserialize")]
270impl<'de> serde::Deserialize<'de> for IssuingDisputeEvidenceReason {
271    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
272        use std::str::FromStr;
273        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
274        Self::from_str(&s)
275            .map_err(|_| serde::de::Error::custom("Unknown value for IssuingDisputeEvidenceReason"))
276    }
277}
stripe_shared/issuing_dispute_evidence.rs

stripe_shared/
issuing_dispute_evidence.rs
