stripe_shared/
issuing_dispute_evidence.rs

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

stripe_shared/
issuing_dispute_evidence.rs
