stripe_shared/
issuing_card_shipping_address_validation.rs

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

stripe_shared/
issuing_card_shipping_address_validation.rs
