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

stripe_shared/
issuing_card_shipping.rs
