stripe_shared/
issuing_card_shipping.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 IssuingCardShipping {
6    pub address: stripe_shared::Address,
7    /// Address validation details for the shipment.
8    pub address_validation: Option<stripe_shared::IssuingCardShippingAddressValidation>,
9    /// The delivery company that shipped a card.
10    pub carrier: Option<IssuingCardShippingCarrier>,
11    /// Additional information that may be required for clearing customs.
12    pub customs: Option<stripe_shared::IssuingCardShippingCustoms>,
13    /// A unix timestamp representing a best estimate of when the card will be delivered.
14    pub eta: Option<stripe_types::Timestamp>,
15    /// Recipient name.
16    pub name: String,
17    /// The phone number of the receiver of the shipment.
18    /// Our courier partners will use this number to contact you in the event of card delivery issues.
19    /// For individual shipments to the EU/UK, if this field is empty, we will provide them with the phone number provided when the cardholder was initially created.
20    pub phone_number: Option<String>,
21    /// Whether a signature is required for card delivery.
22    /// This feature is only supported for US users.
23    /// Standard shipping service does not support signature on delivery.
24    /// The default value for standard shipping service is false and for express and priority services is true.
25    pub require_signature: Option<bool>,
26    /// Shipment service, such as `standard` or `express`.
27    pub service: IssuingCardShippingService,
28    /// The delivery status of the card.
29    pub status: Option<IssuingCardShippingStatus>,
30    /// A tracking number for a card shipment.
31    pub tracking_number: Option<String>,
32    /// A link to the shipping carrier's site where you can view detailed information about a card shipment.
33    pub tracking_url: Option<String>,
34    /// Packaging options.
35    #[cfg_attr(any(feature = "deserialize", feature = "serialize"), serde(rename = "type"))]
36    pub type_: IssuingCardShippingType,
37}
38#[cfg(feature = "redact-generated-debug")]
39impl std::fmt::Debug for IssuingCardShipping {
40    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
41        f.debug_struct("IssuingCardShipping").finish_non_exhaustive()
42    }
43}
44#[doc(hidden)]
45pub struct IssuingCardShippingBuilder {
46    address: Option<stripe_shared::Address>,
47    address_validation: Option<Option<stripe_shared::IssuingCardShippingAddressValidation>>,
48    carrier: Option<Option<IssuingCardShippingCarrier>>,
49    customs: Option<Option<stripe_shared::IssuingCardShippingCustoms>>,
50    eta: Option<Option<stripe_types::Timestamp>>,
51    name: Option<String>,
52    phone_number: Option<Option<String>>,
53    require_signature: Option<Option<bool>>,
54    service: Option<IssuingCardShippingService>,
55    status: Option<Option<IssuingCardShippingStatus>>,
56    tracking_number: Option<Option<String>>,
57    tracking_url: Option<Option<String>>,
58    type_: Option<IssuingCardShippingType>,
59}
60
61#[allow(
62    unused_variables,
63    irrefutable_let_patterns,
64    clippy::let_unit_value,
65    clippy::match_single_binding,
66    clippy::single_match
67)]
68const _: () = {
69    use miniserde::de::{Map, Visitor};
70    use miniserde::json::Value;
71    use miniserde::{Deserialize, Result, make_place};
72    use stripe_types::miniserde_helpers::FromValueOpt;
73    use stripe_types::{MapBuilder, ObjectDeser};
74
75    make_place!(Place);
76
77    impl Deserialize for IssuingCardShipping {
78        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
79            Place::new(out)
80        }
81    }
82
83    struct Builder<'a> {
84        out: &'a mut Option<IssuingCardShipping>,
85        builder: IssuingCardShippingBuilder,
86    }
87
88    impl Visitor for Place<IssuingCardShipping> {
89        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
90            Ok(Box::new(Builder {
91                out: &mut self.out,
92                builder: IssuingCardShippingBuilder::deser_default(),
93            }))
94        }
95    }
96
97    impl MapBuilder for IssuingCardShippingBuilder {
98        type Out = IssuingCardShipping;
99        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
100            Ok(match k {
101                "address" => Deserialize::begin(&mut self.address),
102                "address_validation" => Deserialize::begin(&mut self.address_validation),
103                "carrier" => Deserialize::begin(&mut self.carrier),
104                "customs" => Deserialize::begin(&mut self.customs),
105                "eta" => Deserialize::begin(&mut self.eta),
106                "name" => Deserialize::begin(&mut self.name),
107                "phone_number" => Deserialize::begin(&mut self.phone_number),
108                "require_signature" => Deserialize::begin(&mut self.require_signature),
109                "service" => Deserialize::begin(&mut self.service),
110                "status" => Deserialize::begin(&mut self.status),
111                "tracking_number" => Deserialize::begin(&mut self.tracking_number),
112                "tracking_url" => Deserialize::begin(&mut self.tracking_url),
113                "type" => Deserialize::begin(&mut self.type_),
114                _ => <dyn Visitor>::ignore(),
115            })
116        }
117
118        fn deser_default() -> Self {
119            Self {
120                address: None,
121                address_validation: Some(None),
122                carrier: Some(None),
123                customs: Some(None),
124                eta: Some(None),
125                name: None,
126                phone_number: Some(None),
127                require_signature: Some(None),
128                service: None,
129                status: Some(None),
130                tracking_number: Some(None),
131                tracking_url: Some(None),
132                type_: None,
133            }
134        }
135
136        fn take_out(&mut self) -> Option<Self::Out> {
137            let (
138                Some(address),
139                Some(address_validation),
140                Some(carrier),
141                Some(customs),
142                Some(eta),
143                Some(name),
144                Some(phone_number),
145                Some(require_signature),
146                Some(service),
147                Some(status),
148                Some(tracking_number),
149                Some(tracking_url),
150                Some(type_),
151            ) = (
152                self.address.take(),
153                self.address_validation.take(),
154                self.carrier.take(),
155                self.customs.take(),
156                self.eta,
157                self.name.take(),
158                self.phone_number.take(),
159                self.require_signature,
160                self.service.take(),
161                self.status.take(),
162                self.tracking_number.take(),
163                self.tracking_url.take(),
164                self.type_.take(),
165            )
166            else {
167                return None;
168            };
169            Some(Self::Out {
170                address,
171                address_validation,
172                carrier,
173                customs,
174                eta,
175                name,
176                phone_number,
177                require_signature,
178                service,
179                status,
180                tracking_number,
181                tracking_url,
182                type_,
183            })
184        }
185    }
186
187    impl Map for Builder<'_> {
188        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
189            self.builder.key(k)
190        }
191
192        fn finish(&mut self) -> Result<()> {
193            *self.out = self.builder.take_out();
194            Ok(())
195        }
196    }
197
198    impl ObjectDeser for IssuingCardShipping {
199        type Builder = IssuingCardShippingBuilder;
200    }
201
202    impl FromValueOpt for IssuingCardShipping {
203        fn from_value(v: Value) -> Option<Self> {
204            let Value::Object(obj) = v else {
205                return None;
206            };
207            let mut b = IssuingCardShippingBuilder::deser_default();
208            for (k, v) in obj {
209                match k.as_str() {
210                    "address" => b.address = FromValueOpt::from_value(v),
211                    "address_validation" => b.address_validation = FromValueOpt::from_value(v),
212                    "carrier" => b.carrier = FromValueOpt::from_value(v),
213                    "customs" => b.customs = FromValueOpt::from_value(v),
214                    "eta" => b.eta = FromValueOpt::from_value(v),
215                    "name" => b.name = FromValueOpt::from_value(v),
216                    "phone_number" => b.phone_number = FromValueOpt::from_value(v),
217                    "require_signature" => b.require_signature = FromValueOpt::from_value(v),
218                    "service" => b.service = FromValueOpt::from_value(v),
219                    "status" => b.status = FromValueOpt::from_value(v),
220                    "tracking_number" => b.tracking_number = FromValueOpt::from_value(v),
221                    "tracking_url" => b.tracking_url = FromValueOpt::from_value(v),
222                    "type" => b.type_ = FromValueOpt::from_value(v),
223                    _ => {}
224                }
225            }
226            b.take_out()
227        }
228    }
229};
230/// The delivery company that shipped a card.
231#[derive(Clone, Eq, PartialEq)]
232#[non_exhaustive]
233pub enum IssuingCardShippingCarrier {
234    Dhl,
235    Fedex,
236    RoyalMail,
237    Usps,
238    /// An unrecognized value from Stripe. Should not be used as a request parameter.
239    Unknown(String),
240}
241impl IssuingCardShippingCarrier {
242    pub fn as_str(&self) -> &str {
243        use IssuingCardShippingCarrier::*;
244        match self {
245            Dhl => "dhl",
246            Fedex => "fedex",
247            RoyalMail => "royal_mail",
248            Usps => "usps",
249            Unknown(v) => v,
250        }
251    }
252}
253
254impl std::str::FromStr for IssuingCardShippingCarrier {
255    type Err = std::convert::Infallible;
256    fn from_str(s: &str) -> Result<Self, Self::Err> {
257        use IssuingCardShippingCarrier::*;
258        match s {
259            "dhl" => Ok(Dhl),
260            "fedex" => Ok(Fedex),
261            "royal_mail" => Ok(RoyalMail),
262            "usps" => Ok(Usps),
263            v => {
264                tracing::warn!("Unknown value '{}' for enum '{}'", v, "IssuingCardShippingCarrier");
265                Ok(Unknown(v.to_owned()))
266            }
267        }
268    }
269}
270impl std::fmt::Display for IssuingCardShippingCarrier {
271    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
272        f.write_str(self.as_str())
273    }
274}
275
276#[cfg(not(feature = "redact-generated-debug"))]
277impl std::fmt::Debug for IssuingCardShippingCarrier {
278    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
279        f.write_str(self.as_str())
280    }
281}
282#[cfg(feature = "redact-generated-debug")]
283impl std::fmt::Debug for IssuingCardShippingCarrier {
284    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
285        f.debug_struct(stringify!(IssuingCardShippingCarrier)).finish_non_exhaustive()
286    }
287}
288#[cfg(feature = "serialize")]
289impl serde::Serialize for IssuingCardShippingCarrier {
290    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
291    where
292        S: serde::Serializer,
293    {
294        serializer.serialize_str(self.as_str())
295    }
296}
297impl miniserde::Deserialize for IssuingCardShippingCarrier {
298    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
299        crate::Place::new(out)
300    }
301}
302
303impl miniserde::de::Visitor for crate::Place<IssuingCardShippingCarrier> {
304    fn string(&mut self, s: &str) -> miniserde::Result<()> {
305        use std::str::FromStr;
306        self.out = Some(IssuingCardShippingCarrier::from_str(s).expect("infallible"));
307        Ok(())
308    }
309}
310
311stripe_types::impl_from_val_with_from_str!(IssuingCardShippingCarrier);
312#[cfg(feature = "deserialize")]
313impl<'de> serde::Deserialize<'de> for IssuingCardShippingCarrier {
314    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
315        use std::str::FromStr;
316        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
317        Ok(Self::from_str(&s).expect("infallible"))
318    }
319}
320/// Shipment service, such as `standard` or `express`.
321#[derive(Clone, Eq, PartialEq)]
322#[non_exhaustive]
323pub enum IssuingCardShippingService {
324    Express,
325    Priority,
326    Standard,
327    /// An unrecognized value from Stripe. Should not be used as a request parameter.
328    Unknown(String),
329}
330impl IssuingCardShippingService {
331    pub fn as_str(&self) -> &str {
332        use IssuingCardShippingService::*;
333        match self {
334            Express => "express",
335            Priority => "priority",
336            Standard => "standard",
337            Unknown(v) => v,
338        }
339    }
340}
341
342impl std::str::FromStr for IssuingCardShippingService {
343    type Err = std::convert::Infallible;
344    fn from_str(s: &str) -> Result<Self, Self::Err> {
345        use IssuingCardShippingService::*;
346        match s {
347            "express" => Ok(Express),
348            "priority" => Ok(Priority),
349            "standard" => Ok(Standard),
350            v => {
351                tracing::warn!("Unknown value '{}' for enum '{}'", v, "IssuingCardShippingService");
352                Ok(Unknown(v.to_owned()))
353            }
354        }
355    }
356}
357impl std::fmt::Display for IssuingCardShippingService {
358    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
359        f.write_str(self.as_str())
360    }
361}
362
363#[cfg(not(feature = "redact-generated-debug"))]
364impl std::fmt::Debug for IssuingCardShippingService {
365    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
366        f.write_str(self.as_str())
367    }
368}
369#[cfg(feature = "redact-generated-debug")]
370impl std::fmt::Debug for IssuingCardShippingService {
371    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
372        f.debug_struct(stringify!(IssuingCardShippingService)).finish_non_exhaustive()
373    }
374}
375#[cfg(feature = "serialize")]
376impl serde::Serialize for IssuingCardShippingService {
377    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
378    where
379        S: serde::Serializer,
380    {
381        serializer.serialize_str(self.as_str())
382    }
383}
384impl miniserde::Deserialize for IssuingCardShippingService {
385    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
386        crate::Place::new(out)
387    }
388}
389
390impl miniserde::de::Visitor for crate::Place<IssuingCardShippingService> {
391    fn string(&mut self, s: &str) -> miniserde::Result<()> {
392        use std::str::FromStr;
393        self.out = Some(IssuingCardShippingService::from_str(s).expect("infallible"));
394        Ok(())
395    }
396}
397
398stripe_types::impl_from_val_with_from_str!(IssuingCardShippingService);
399#[cfg(feature = "deserialize")]
400impl<'de> serde::Deserialize<'de> for IssuingCardShippingService {
401    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
402        use std::str::FromStr;
403        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
404        Ok(Self::from_str(&s).expect("infallible"))
405    }
406}
407/// The delivery status of the card.
408#[derive(Clone, Eq, PartialEq)]
409#[non_exhaustive]
410pub enum IssuingCardShippingStatus {
411    Canceled,
412    Delivered,
413    Failure,
414    Pending,
415    Returned,
416    Shipped,
417    Submitted,
418    /// An unrecognized value from Stripe. Should not be used as a request parameter.
419    Unknown(String),
420}
421impl IssuingCardShippingStatus {
422    pub fn as_str(&self) -> &str {
423        use IssuingCardShippingStatus::*;
424        match self {
425            Canceled => "canceled",
426            Delivered => "delivered",
427            Failure => "failure",
428            Pending => "pending",
429            Returned => "returned",
430            Shipped => "shipped",
431            Submitted => "submitted",
432            Unknown(v) => v,
433        }
434    }
435}
436
437impl std::str::FromStr for IssuingCardShippingStatus {
438    type Err = std::convert::Infallible;
439    fn from_str(s: &str) -> Result<Self, Self::Err> {
440        use IssuingCardShippingStatus::*;
441        match s {
442            "canceled" => Ok(Canceled),
443            "delivered" => Ok(Delivered),
444            "failure" => Ok(Failure),
445            "pending" => Ok(Pending),
446            "returned" => Ok(Returned),
447            "shipped" => Ok(Shipped),
448            "submitted" => Ok(Submitted),
449            v => {
450                tracing::warn!("Unknown value '{}' for enum '{}'", v, "IssuingCardShippingStatus");
451                Ok(Unknown(v.to_owned()))
452            }
453        }
454    }
455}
456impl std::fmt::Display for IssuingCardShippingStatus {
457    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
458        f.write_str(self.as_str())
459    }
460}
461
462#[cfg(not(feature = "redact-generated-debug"))]
463impl std::fmt::Debug for IssuingCardShippingStatus {
464    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
465        f.write_str(self.as_str())
466    }
467}
468#[cfg(feature = "redact-generated-debug")]
469impl std::fmt::Debug for IssuingCardShippingStatus {
470    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
471        f.debug_struct(stringify!(IssuingCardShippingStatus)).finish_non_exhaustive()
472    }
473}
474#[cfg(feature = "serialize")]
475impl serde::Serialize for IssuingCardShippingStatus {
476    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
477    where
478        S: serde::Serializer,
479    {
480        serializer.serialize_str(self.as_str())
481    }
482}
483impl miniserde::Deserialize for IssuingCardShippingStatus {
484    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
485        crate::Place::new(out)
486    }
487}
488
489impl miniserde::de::Visitor for crate::Place<IssuingCardShippingStatus> {
490    fn string(&mut self, s: &str) -> miniserde::Result<()> {
491        use std::str::FromStr;
492        self.out = Some(IssuingCardShippingStatus::from_str(s).expect("infallible"));
493        Ok(())
494    }
495}
496
497stripe_types::impl_from_val_with_from_str!(IssuingCardShippingStatus);
498#[cfg(feature = "deserialize")]
499impl<'de> serde::Deserialize<'de> for IssuingCardShippingStatus {
500    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
501        use std::str::FromStr;
502        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
503        Ok(Self::from_str(&s).expect("infallible"))
504    }
505}
506/// Packaging options.
507#[derive(Clone, Eq, PartialEq)]
508#[non_exhaustive]
509pub enum IssuingCardShippingType {
510    Bulk,
511    Individual,
512    /// An unrecognized value from Stripe. Should not be used as a request parameter.
513    Unknown(String),
514}
515impl IssuingCardShippingType {
516    pub fn as_str(&self) -> &str {
517        use IssuingCardShippingType::*;
518        match self {
519            Bulk => "bulk",
520            Individual => "individual",
521            Unknown(v) => v,
522        }
523    }
524}
525
526impl std::str::FromStr for IssuingCardShippingType {
527    type Err = std::convert::Infallible;
528    fn from_str(s: &str) -> Result<Self, Self::Err> {
529        use IssuingCardShippingType::*;
530        match s {
531            "bulk" => Ok(Bulk),
532            "individual" => Ok(Individual),
533            v => {
534                tracing::warn!("Unknown value '{}' for enum '{}'", v, "IssuingCardShippingType");
535                Ok(Unknown(v.to_owned()))
536            }
537        }
538    }
539}
540impl std::fmt::Display for IssuingCardShippingType {
541    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
542        f.write_str(self.as_str())
543    }
544}
545
546#[cfg(not(feature = "redact-generated-debug"))]
547impl std::fmt::Debug for IssuingCardShippingType {
548    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
549        f.write_str(self.as_str())
550    }
551}
552#[cfg(feature = "redact-generated-debug")]
553impl std::fmt::Debug for IssuingCardShippingType {
554    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
555        f.debug_struct(stringify!(IssuingCardShippingType)).finish_non_exhaustive()
556    }
557}
558#[cfg(feature = "serialize")]
559impl serde::Serialize for IssuingCardShippingType {
560    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
561    where
562        S: serde::Serializer,
563    {
564        serializer.serialize_str(self.as_str())
565    }
566}
567impl miniserde::Deserialize for IssuingCardShippingType {
568    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
569        crate::Place::new(out)
570    }
571}
572
573impl miniserde::de::Visitor for crate::Place<IssuingCardShippingType> {
574    fn string(&mut self, s: &str) -> miniserde::Result<()> {
575        use std::str::FromStr;
576        self.out = Some(IssuingCardShippingType::from_str(s).expect("infallible"));
577        Ok(())
578    }
579}
580
581stripe_types::impl_from_val_with_from_str!(IssuingCardShippingType);
582#[cfg(feature = "deserialize")]
583impl<'de> serde::Deserialize<'de> for IssuingCardShippingType {
584    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
585        use std::str::FromStr;
586        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
587        Ok(Self::from_str(&s).expect("infallible"))
588    }
589}
stripe_shared/issuing_card_shipping.rs

stripe_shared/
issuing_card_shipping.rs
