stripe_shared/
issuing_card.rs

1/// You can [create physical or virtual cards](https://stripe.com/docs/issuing) that are issued to cardholders.
2///
3/// For more details see <<https://stripe.com/docs/api/issuing/cards/object>>.
4#[derive(Clone, Debug)]
5#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
6pub struct IssuingCard {
7    /// The brand of the card.
8    pub brand: String,
9    /// The reason why the card was canceled.
10    pub cancellation_reason: Option<IssuingCardCancellationReason>,
11    pub cardholder: stripe_shared::IssuingCardholder,
12    /// Time at which the object was created. Measured in seconds since the Unix epoch.
13    pub created: stripe_types::Timestamp,
14    /// Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase.
15    /// Supported currencies are `usd` in the US, `eur` in the EU, and `gbp` in the UK.
16    pub currency: stripe_types::Currency,
17    /// The card's CVC.
18    /// For security reasons, this is only available for virtual cards, and will be omitted unless you explicitly request it with [the `expand` parameter](https://stripe.com/docs/api/expanding_objects).
19    /// Additionally, it's only available via the ["Retrieve a card" endpoint](https://stripe.com/docs/api/issuing/cards/retrieve), not via "List all cards" or any other endpoint.
20    pub cvc: Option<String>,
21    /// The expiration month of the card.
22    pub exp_month: i64,
23    /// The expiration year of the card.
24    pub exp_year: i64,
25    /// The financial account this card is attached to.
26    pub financial_account: Option<String>,
27    /// Unique identifier for the object.
28    pub id: stripe_shared::IssuingCardId,
29    /// The last 4 digits of the card number.
30    pub last4: String,
31    /// Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
32    pub livemode: bool,
33    /// Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object.
34    /// This can be useful for storing additional information about the object in a structured format.
35    pub metadata: std::collections::HashMap<String, String>,
36    /// The full unredacted card number.
37    /// For security reasons, this is only available for virtual cards, and will be omitted unless you explicitly request it with [the `expand` parameter](https://stripe.com/docs/api/expanding_objects).
38    /// Additionally, it's only available via the ["Retrieve a card" endpoint](https://stripe.com/docs/api/issuing/cards/retrieve), not via "List all cards" or any other endpoint.
39    pub number: Option<String>,
40    /// The personalization design object belonging to this card.
41    pub personalization_design:
42        Option<stripe_types::Expandable<stripe_shared::IssuingPersonalizationDesign>>,
43    /// The latest card that replaces this card, if any.
44    pub replaced_by: Option<stripe_types::Expandable<stripe_shared::IssuingCard>>,
45    /// The card this card replaces, if any.
46    pub replacement_for: Option<stripe_types::Expandable<stripe_shared::IssuingCard>>,
47    /// The reason why the previous card needed to be replaced.
48    pub replacement_reason: Option<stripe_shared::IssuingCardReplacementReason>,
49    /// Text separate from cardholder name, printed on the card.
50    pub second_line: Option<String>,
51    /// Where and how the card will be shipped.
52    pub shipping: Option<stripe_shared::IssuingCardShipping>,
53    pub spending_controls: stripe_shared::IssuingCardAuthorizationControls,
54    /// Whether authorizations can be approved on this card.
55    /// May be blocked from activating cards depending on past-due Cardholder requirements.
56    /// Defaults to `inactive`.
57    pub status: stripe_shared::IssuingCardStatus,
58    /// The type of the card.
59    #[cfg_attr(feature = "deserialize", serde(rename = "type"))]
60    pub type_: stripe_shared::IssuingCardType,
61    /// Information relating to digital wallets (like Apple Pay and Google Pay).
62    pub wallets: Option<stripe_shared::IssuingCardWallets>,
63}
64#[doc(hidden)]
65pub struct IssuingCardBuilder {
66    brand: Option<String>,
67    cancellation_reason: Option<Option<IssuingCardCancellationReason>>,
68    cardholder: Option<stripe_shared::IssuingCardholder>,
69    created: Option<stripe_types::Timestamp>,
70    currency: Option<stripe_types::Currency>,
71    cvc: Option<Option<String>>,
72    exp_month: Option<i64>,
73    exp_year: Option<i64>,
74    financial_account: Option<Option<String>>,
75    id: Option<stripe_shared::IssuingCardId>,
76    last4: Option<String>,
77    livemode: Option<bool>,
78    metadata: Option<std::collections::HashMap<String, String>>,
79    number: Option<Option<String>>,
80    personalization_design:
81        Option<Option<stripe_types::Expandable<stripe_shared::IssuingPersonalizationDesign>>>,
82    replaced_by: Option<Option<stripe_types::Expandable<stripe_shared::IssuingCard>>>,
83    replacement_for: Option<Option<stripe_types::Expandable<stripe_shared::IssuingCard>>>,
84    replacement_reason: Option<Option<stripe_shared::IssuingCardReplacementReason>>,
85    second_line: Option<Option<String>>,
86    shipping: Option<Option<stripe_shared::IssuingCardShipping>>,
87    spending_controls: Option<stripe_shared::IssuingCardAuthorizationControls>,
88    status: Option<stripe_shared::IssuingCardStatus>,
89    type_: Option<stripe_shared::IssuingCardType>,
90    wallets: Option<Option<stripe_shared::IssuingCardWallets>>,
91}
92
93#[allow(
94    unused_variables,
95    irrefutable_let_patterns,
96    clippy::let_unit_value,
97    clippy::match_single_binding,
98    clippy::single_match
99)]
100const _: () = {
101    use miniserde::de::{Map, Visitor};
102    use miniserde::json::Value;
103    use miniserde::{Deserialize, Result, make_place};
104    use stripe_types::miniserde_helpers::FromValueOpt;
105    use stripe_types::{MapBuilder, ObjectDeser};
106
107    make_place!(Place);
108
109    impl Deserialize for IssuingCard {
110        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
111            Place::new(out)
112        }
113    }
114
115    struct Builder<'a> {
116        out: &'a mut Option<IssuingCard>,
117        builder: IssuingCardBuilder,
118    }
119
120    impl Visitor for Place<IssuingCard> {
121        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
122            Ok(Box::new(Builder {
123                out: &mut self.out,
124                builder: IssuingCardBuilder::deser_default(),
125            }))
126        }
127    }
128
129    impl MapBuilder for IssuingCardBuilder {
130        type Out = IssuingCard;
131        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
132            Ok(match k {
133                "brand" => Deserialize::begin(&mut self.brand),
134                "cancellation_reason" => Deserialize::begin(&mut self.cancellation_reason),
135                "cardholder" => Deserialize::begin(&mut self.cardholder),
136                "created" => Deserialize::begin(&mut self.created),
137                "currency" => Deserialize::begin(&mut self.currency),
138                "cvc" => Deserialize::begin(&mut self.cvc),
139                "exp_month" => Deserialize::begin(&mut self.exp_month),
140                "exp_year" => Deserialize::begin(&mut self.exp_year),
141                "financial_account" => Deserialize::begin(&mut self.financial_account),
142                "id" => Deserialize::begin(&mut self.id),
143                "last4" => Deserialize::begin(&mut self.last4),
144                "livemode" => Deserialize::begin(&mut self.livemode),
145                "metadata" => Deserialize::begin(&mut self.metadata),
146                "number" => Deserialize::begin(&mut self.number),
147                "personalization_design" => Deserialize::begin(&mut self.personalization_design),
148                "replaced_by" => Deserialize::begin(&mut self.replaced_by),
149                "replacement_for" => Deserialize::begin(&mut self.replacement_for),
150                "replacement_reason" => Deserialize::begin(&mut self.replacement_reason),
151                "second_line" => Deserialize::begin(&mut self.second_line),
152                "shipping" => Deserialize::begin(&mut self.shipping),
153                "spending_controls" => Deserialize::begin(&mut self.spending_controls),
154                "status" => Deserialize::begin(&mut self.status),
155                "type" => Deserialize::begin(&mut self.type_),
156                "wallets" => Deserialize::begin(&mut self.wallets),
157
158                _ => <dyn Visitor>::ignore(),
159            })
160        }
161
162        fn deser_default() -> Self {
163            Self {
164                brand: Deserialize::default(),
165                cancellation_reason: Deserialize::default(),
166                cardholder: Deserialize::default(),
167                created: Deserialize::default(),
168                currency: Deserialize::default(),
169                cvc: Deserialize::default(),
170                exp_month: Deserialize::default(),
171                exp_year: Deserialize::default(),
172                financial_account: Deserialize::default(),
173                id: Deserialize::default(),
174                last4: Deserialize::default(),
175                livemode: Deserialize::default(),
176                metadata: Deserialize::default(),
177                number: Deserialize::default(),
178                personalization_design: Deserialize::default(),
179                replaced_by: Deserialize::default(),
180                replacement_for: Deserialize::default(),
181                replacement_reason: Deserialize::default(),
182                second_line: Deserialize::default(),
183                shipping: Deserialize::default(),
184                spending_controls: Deserialize::default(),
185                status: Deserialize::default(),
186                type_: Deserialize::default(),
187                wallets: Deserialize::default(),
188            }
189        }
190
191        fn take_out(&mut self) -> Option<Self::Out> {
192            let (
193                Some(brand),
194                Some(cancellation_reason),
195                Some(cardholder),
196                Some(created),
197                Some(currency),
198                Some(cvc),
199                Some(exp_month),
200                Some(exp_year),
201                Some(financial_account),
202                Some(id),
203                Some(last4),
204                Some(livemode),
205                Some(metadata),
206                Some(number),
207                Some(personalization_design),
208                Some(replaced_by),
209                Some(replacement_for),
210                Some(replacement_reason),
211                Some(second_line),
212                Some(shipping),
213                Some(spending_controls),
214                Some(status),
215                Some(type_),
216                Some(wallets),
217            ) = (
218                self.brand.take(),
219                self.cancellation_reason,
220                self.cardholder.take(),
221                self.created,
222                self.currency.take(),
223                self.cvc.take(),
224                self.exp_month,
225                self.exp_year,
226                self.financial_account.take(),
227                self.id.take(),
228                self.last4.take(),
229                self.livemode,
230                self.metadata.take(),
231                self.number.take(),
232                self.personalization_design.take(),
233                self.replaced_by.take(),
234                self.replacement_for.take(),
235                self.replacement_reason,
236                self.second_line.take(),
237                self.shipping.take(),
238                self.spending_controls.take(),
239                self.status,
240                self.type_,
241                self.wallets.take(),
242            )
243            else {
244                return None;
245            };
246            Some(Self::Out {
247                brand,
248                cancellation_reason,
249                cardholder,
250                created,
251                currency,
252                cvc,
253                exp_month,
254                exp_year,
255                financial_account,
256                id,
257                last4,
258                livemode,
259                metadata,
260                number,
261                personalization_design,
262                replaced_by,
263                replacement_for,
264                replacement_reason,
265                second_line,
266                shipping,
267                spending_controls,
268                status,
269                type_,
270                wallets,
271            })
272        }
273    }
274
275    impl Map for Builder<'_> {
276        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
277            self.builder.key(k)
278        }
279
280        fn finish(&mut self) -> Result<()> {
281            *self.out = self.builder.take_out();
282            Ok(())
283        }
284    }
285
286    impl ObjectDeser for IssuingCard {
287        type Builder = IssuingCardBuilder;
288    }
289
290    impl FromValueOpt for IssuingCard {
291        fn from_value(v: Value) -> Option<Self> {
292            let Value::Object(obj) = v else {
293                return None;
294            };
295            let mut b = IssuingCardBuilder::deser_default();
296            for (k, v) in obj {
297                match k.as_str() {
298                    "brand" => b.brand = FromValueOpt::from_value(v),
299                    "cancellation_reason" => b.cancellation_reason = FromValueOpt::from_value(v),
300                    "cardholder" => b.cardholder = FromValueOpt::from_value(v),
301                    "created" => b.created = FromValueOpt::from_value(v),
302                    "currency" => b.currency = FromValueOpt::from_value(v),
303                    "cvc" => b.cvc = FromValueOpt::from_value(v),
304                    "exp_month" => b.exp_month = FromValueOpt::from_value(v),
305                    "exp_year" => b.exp_year = FromValueOpt::from_value(v),
306                    "financial_account" => b.financial_account = FromValueOpt::from_value(v),
307                    "id" => b.id = FromValueOpt::from_value(v),
308                    "last4" => b.last4 = FromValueOpt::from_value(v),
309                    "livemode" => b.livemode = FromValueOpt::from_value(v),
310                    "metadata" => b.metadata = FromValueOpt::from_value(v),
311                    "number" => b.number = FromValueOpt::from_value(v),
312                    "personalization_design" => {
313                        b.personalization_design = FromValueOpt::from_value(v)
314                    }
315                    "replaced_by" => b.replaced_by = FromValueOpt::from_value(v),
316                    "replacement_for" => b.replacement_for = FromValueOpt::from_value(v),
317                    "replacement_reason" => b.replacement_reason = FromValueOpt::from_value(v),
318                    "second_line" => b.second_line = FromValueOpt::from_value(v),
319                    "shipping" => b.shipping = FromValueOpt::from_value(v),
320                    "spending_controls" => b.spending_controls = FromValueOpt::from_value(v),
321                    "status" => b.status = FromValueOpt::from_value(v),
322                    "type" => b.type_ = FromValueOpt::from_value(v),
323                    "wallets" => b.wallets = FromValueOpt::from_value(v),
324
325                    _ => {}
326                }
327            }
328            b.take_out()
329        }
330    }
331};
332#[cfg(feature = "serialize")]
333impl serde::Serialize for IssuingCard {
334    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
335        use serde::ser::SerializeStruct;
336        let mut s = s.serialize_struct("IssuingCard", 25)?;
337        s.serialize_field("brand", &self.brand)?;
338        s.serialize_field("cancellation_reason", &self.cancellation_reason)?;
339        s.serialize_field("cardholder", &self.cardholder)?;
340        s.serialize_field("created", &self.created)?;
341        s.serialize_field("currency", &self.currency)?;
342        s.serialize_field("cvc", &self.cvc)?;
343        s.serialize_field("exp_month", &self.exp_month)?;
344        s.serialize_field("exp_year", &self.exp_year)?;
345        s.serialize_field("financial_account", &self.financial_account)?;
346        s.serialize_field("id", &self.id)?;
347        s.serialize_field("last4", &self.last4)?;
348        s.serialize_field("livemode", &self.livemode)?;
349        s.serialize_field("metadata", &self.metadata)?;
350        s.serialize_field("number", &self.number)?;
351        s.serialize_field("personalization_design", &self.personalization_design)?;
352        s.serialize_field("replaced_by", &self.replaced_by)?;
353        s.serialize_field("replacement_for", &self.replacement_for)?;
354        s.serialize_field("replacement_reason", &self.replacement_reason)?;
355        s.serialize_field("second_line", &self.second_line)?;
356        s.serialize_field("shipping", &self.shipping)?;
357        s.serialize_field("spending_controls", &self.spending_controls)?;
358        s.serialize_field("status", &self.status)?;
359        s.serialize_field("type", &self.type_)?;
360        s.serialize_field("wallets", &self.wallets)?;
361
362        s.serialize_field("object", "issuing.card")?;
363        s.end()
364    }
365}
366/// The reason why the card was canceled.
367#[derive(Copy, Clone, Eq, PartialEq)]
368pub enum IssuingCardCancellationReason {
369    DesignRejected,
370    Lost,
371    Stolen,
372}
373impl IssuingCardCancellationReason {
374    pub fn as_str(self) -> &'static str {
375        use IssuingCardCancellationReason::*;
376        match self {
377            DesignRejected => "design_rejected",
378            Lost => "lost",
379            Stolen => "stolen",
380        }
381    }
382}
383
384impl std::str::FromStr for IssuingCardCancellationReason {
385    type Err = stripe_types::StripeParseError;
386    fn from_str(s: &str) -> Result<Self, Self::Err> {
387        use IssuingCardCancellationReason::*;
388        match s {
389            "design_rejected" => Ok(DesignRejected),
390            "lost" => Ok(Lost),
391            "stolen" => Ok(Stolen),
392            _ => Err(stripe_types::StripeParseError),
393        }
394    }
395}
396impl std::fmt::Display for IssuingCardCancellationReason {
397    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
398        f.write_str(self.as_str())
399    }
400}
401
402impl std::fmt::Debug for IssuingCardCancellationReason {
403    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
404        f.write_str(self.as_str())
405    }
406}
407#[cfg(feature = "serialize")]
408impl serde::Serialize for IssuingCardCancellationReason {
409    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
410    where
411        S: serde::Serializer,
412    {
413        serializer.serialize_str(self.as_str())
414    }
415}
416impl miniserde::Deserialize for IssuingCardCancellationReason {
417    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
418        crate::Place::new(out)
419    }
420}
421
422impl miniserde::de::Visitor for crate::Place<IssuingCardCancellationReason> {
423    fn string(&mut self, s: &str) -> miniserde::Result<()> {
424        use std::str::FromStr;
425        self.out = Some(IssuingCardCancellationReason::from_str(s).map_err(|_| miniserde::Error)?);
426        Ok(())
427    }
428}
429
430stripe_types::impl_from_val_with_from_str!(IssuingCardCancellationReason);
431#[cfg(feature = "deserialize")]
432impl<'de> serde::Deserialize<'de> for IssuingCardCancellationReason {
433    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
434        use std::str::FromStr;
435        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
436        Self::from_str(&s).map_err(|_| {
437            serde::de::Error::custom("Unknown value for IssuingCardCancellationReason")
438        })
439    }
440}
441impl stripe_types::Object for IssuingCard {
442    type Id = stripe_shared::IssuingCardId;
443    fn id(&self) -> &Self::Id {
444        &self.id
445    }
446
447    fn into_id(self) -> Self::Id {
448        self.id
449    }
450}
451stripe_types::def_id!(IssuingCardId);
452#[derive(Copy, Clone, Eq, PartialEq)]
453pub enum IssuingCardReplacementReason {
454    Damaged,
455    Expired,
456    Lost,
457    Stolen,
458}
459impl IssuingCardReplacementReason {
460    pub fn as_str(self) -> &'static str {
461        use IssuingCardReplacementReason::*;
462        match self {
463            Damaged => "damaged",
464            Expired => "expired",
465            Lost => "lost",
466            Stolen => "stolen",
467        }
468    }
469}
470
471impl std::str::FromStr for IssuingCardReplacementReason {
472    type Err = stripe_types::StripeParseError;
473    fn from_str(s: &str) -> Result<Self, Self::Err> {
474        use IssuingCardReplacementReason::*;
475        match s {
476            "damaged" => Ok(Damaged),
477            "expired" => Ok(Expired),
478            "lost" => Ok(Lost),
479            "stolen" => Ok(Stolen),
480            _ => Err(stripe_types::StripeParseError),
481        }
482    }
483}
484impl std::fmt::Display for IssuingCardReplacementReason {
485    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
486        f.write_str(self.as_str())
487    }
488}
489
490impl std::fmt::Debug for IssuingCardReplacementReason {
491    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
492        f.write_str(self.as_str())
493    }
494}
495impl serde::Serialize for IssuingCardReplacementReason {
496    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
497    where
498        S: serde::Serializer,
499    {
500        serializer.serialize_str(self.as_str())
501    }
502}
503impl miniserde::Deserialize for IssuingCardReplacementReason {
504    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
505        crate::Place::new(out)
506    }
507}
508
509impl miniserde::de::Visitor for crate::Place<IssuingCardReplacementReason> {
510    fn string(&mut self, s: &str) -> miniserde::Result<()> {
511        use std::str::FromStr;
512        self.out = Some(IssuingCardReplacementReason::from_str(s).map_err(|_| miniserde::Error)?);
513        Ok(())
514    }
515}
516
517stripe_types::impl_from_val_with_from_str!(IssuingCardReplacementReason);
518#[cfg(feature = "deserialize")]
519impl<'de> serde::Deserialize<'de> for IssuingCardReplacementReason {
520    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
521        use std::str::FromStr;
522        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
523        Self::from_str(&s)
524            .map_err(|_| serde::de::Error::custom("Unknown value for IssuingCardReplacementReason"))
525    }
526}
527#[derive(Copy, Clone, Eq, PartialEq)]
528pub enum IssuingCardStatus {
529    Active,
530    Canceled,
531    Inactive,
532}
533impl IssuingCardStatus {
534    pub fn as_str(self) -> &'static str {
535        use IssuingCardStatus::*;
536        match self {
537            Active => "active",
538            Canceled => "canceled",
539            Inactive => "inactive",
540        }
541    }
542}
543
544impl std::str::FromStr for IssuingCardStatus {
545    type Err = stripe_types::StripeParseError;
546    fn from_str(s: &str) -> Result<Self, Self::Err> {
547        use IssuingCardStatus::*;
548        match s {
549            "active" => Ok(Active),
550            "canceled" => Ok(Canceled),
551            "inactive" => Ok(Inactive),
552            _ => Err(stripe_types::StripeParseError),
553        }
554    }
555}
556impl std::fmt::Display for IssuingCardStatus {
557    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
558        f.write_str(self.as_str())
559    }
560}
561
562impl std::fmt::Debug for IssuingCardStatus {
563    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
564        f.write_str(self.as_str())
565    }
566}
567impl serde::Serialize for IssuingCardStatus {
568    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
569    where
570        S: serde::Serializer,
571    {
572        serializer.serialize_str(self.as_str())
573    }
574}
575impl miniserde::Deserialize for IssuingCardStatus {
576    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
577        crate::Place::new(out)
578    }
579}
580
581impl miniserde::de::Visitor for crate::Place<IssuingCardStatus> {
582    fn string(&mut self, s: &str) -> miniserde::Result<()> {
583        use std::str::FromStr;
584        self.out = Some(IssuingCardStatus::from_str(s).map_err(|_| miniserde::Error)?);
585        Ok(())
586    }
587}
588
589stripe_types::impl_from_val_with_from_str!(IssuingCardStatus);
590#[cfg(feature = "deserialize")]
591impl<'de> serde::Deserialize<'de> for IssuingCardStatus {
592    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
593        use std::str::FromStr;
594        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
595        Self::from_str(&s)
596            .map_err(|_| serde::de::Error::custom("Unknown value for IssuingCardStatus"))
597    }
598}
599#[derive(Copy, Clone, Eq, PartialEq)]
600pub enum IssuingCardType {
601    Physical,
602    Virtual,
603}
604impl IssuingCardType {
605    pub fn as_str(self) -> &'static str {
606        use IssuingCardType::*;
607        match self {
608            Physical => "physical",
609            Virtual => "virtual",
610        }
611    }
612}
613
614impl std::str::FromStr for IssuingCardType {
615    type Err = stripe_types::StripeParseError;
616    fn from_str(s: &str) -> Result<Self, Self::Err> {
617        use IssuingCardType::*;
618        match s {
619            "physical" => Ok(Physical),
620            "virtual" => Ok(Virtual),
621            _ => Err(stripe_types::StripeParseError),
622        }
623    }
624}
625impl std::fmt::Display for IssuingCardType {
626    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
627        f.write_str(self.as_str())
628    }
629}
630
631impl std::fmt::Debug for IssuingCardType {
632    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
633        f.write_str(self.as_str())
634    }
635}
636impl serde::Serialize for IssuingCardType {
637    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
638    where
639        S: serde::Serializer,
640    {
641        serializer.serialize_str(self.as_str())
642    }
643}
644impl miniserde::Deserialize for IssuingCardType {
645    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
646        crate::Place::new(out)
647    }
648}
649
650impl miniserde::de::Visitor for crate::Place<IssuingCardType> {
651    fn string(&mut self, s: &str) -> miniserde::Result<()> {
652        use std::str::FromStr;
653        self.out = Some(IssuingCardType::from_str(s).map_err(|_| miniserde::Error)?);
654        Ok(())
655    }
656}
657
658stripe_types::impl_from_val_with_from_str!(IssuingCardType);
659#[cfg(feature = "deserialize")]
660impl<'de> serde::Deserialize<'de> for IssuingCardType {
661    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
662        use std::str::FromStr;
663        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
664        Self::from_str(&s)
665            .map_err(|_| serde::de::Error::custom("Unknown value for IssuingCardType"))
666    }
667}
stripe_shared/issuing_card.rs

stripe_shared/
issuing_card.rs
