stripe_shared/
payment_method_kr_card.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct PaymentMethodKrCard {
5    /// The local credit or debit card brand.
6    pub brand: Option<PaymentMethodKrCardBrand>,
7    /// The last four digits of the card. This may not be present for American Express cards.
8    pub last4: Option<String>,
9}
10#[doc(hidden)]
11pub struct PaymentMethodKrCardBuilder {
12    brand: Option<Option<PaymentMethodKrCardBrand>>,
13    last4: Option<Option<String>>,
14}
15
16#[allow(
17    unused_variables,
18    irrefutable_let_patterns,
19    clippy::let_unit_value,
20    clippy::match_single_binding,
21    clippy::single_match
22)]
23const _: () = {
24    use miniserde::de::{Map, Visitor};
25    use miniserde::json::Value;
26    use miniserde::{make_place, Deserialize, Result};
27    use stripe_types::miniserde_helpers::FromValueOpt;
28    use stripe_types::{MapBuilder, ObjectDeser};
29
30    make_place!(Place);
31
32    impl Deserialize for PaymentMethodKrCard {
33        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
34            Place::new(out)
35        }
36    }
37
38    struct Builder<'a> {
39        out: &'a mut Option<PaymentMethodKrCard>,
40        builder: PaymentMethodKrCardBuilder,
41    }
42
43    impl Visitor for Place<PaymentMethodKrCard> {
44        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
45            Ok(Box::new(Builder {
46                out: &mut self.out,
47                builder: PaymentMethodKrCardBuilder::deser_default(),
48            }))
49        }
50    }
51
52    impl MapBuilder for PaymentMethodKrCardBuilder {
53        type Out = PaymentMethodKrCard;
54        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
55            Ok(match k {
56                "brand" => Deserialize::begin(&mut self.brand),
57                "last4" => Deserialize::begin(&mut self.last4),
58
59                _ => <dyn Visitor>::ignore(),
60            })
61        }
62
63        fn deser_default() -> Self {
64            Self { brand: Deserialize::default(), last4: Deserialize::default() }
65        }
66
67        fn take_out(&mut self) -> Option<Self::Out> {
68            let (Some(brand), Some(last4)) = (self.brand.take(), self.last4.take()) else {
69                return None;
70            };
71            Some(Self::Out { brand, last4 })
72        }
73    }
74
75    impl<'a> Map for Builder<'a> {
76        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
77            self.builder.key(k)
78        }
79
80        fn finish(&mut self) -> Result<()> {
81            *self.out = self.builder.take_out();
82            Ok(())
83        }
84    }
85
86    impl ObjectDeser for PaymentMethodKrCard {
87        type Builder = PaymentMethodKrCardBuilder;
88    }
89
90    impl FromValueOpt for PaymentMethodKrCard {
91        fn from_value(v: Value) -> Option<Self> {
92            let Value::Object(obj) = v else {
93                return None;
94            };
95            let mut b = PaymentMethodKrCardBuilder::deser_default();
96            for (k, v) in obj {
97                match k.as_str() {
98                    "brand" => b.brand = FromValueOpt::from_value(v),
99                    "last4" => b.last4 = FromValueOpt::from_value(v),
100
101                    _ => {}
102                }
103            }
104            b.take_out()
105        }
106    }
107};
108/// The local credit or debit card brand.
109#[derive(Clone, Eq, PartialEq)]
110#[non_exhaustive]
111pub enum PaymentMethodKrCardBrand {
112    Bc,
113    Citi,
114    Hana,
115    Hyundai,
116    Jeju,
117    Jeonbuk,
118    Kakaobank,
119    Kbank,
120    Kdbbank,
121    Kookmin,
122    Kwangju,
123    Lotte,
124    Mg,
125    Nh,
126    Post,
127    Samsung,
128    Savingsbank,
129    Shinhan,
130    Shinhyup,
131    Suhyup,
132    Tossbank,
133    Woori,
134    /// An unrecognized value from Stripe. Should not be used as a request parameter.
135    Unknown(String),
136}
137impl PaymentMethodKrCardBrand {
138    pub fn as_str(&self) -> &str {
139        use PaymentMethodKrCardBrand::*;
140        match self {
141            Bc => "bc",
142            Citi => "citi",
143            Hana => "hana",
144            Hyundai => "hyundai",
145            Jeju => "jeju",
146            Jeonbuk => "jeonbuk",
147            Kakaobank => "kakaobank",
148            Kbank => "kbank",
149            Kdbbank => "kdbbank",
150            Kookmin => "kookmin",
151            Kwangju => "kwangju",
152            Lotte => "lotte",
153            Mg => "mg",
154            Nh => "nh",
155            Post => "post",
156            Samsung => "samsung",
157            Savingsbank => "savingsbank",
158            Shinhan => "shinhan",
159            Shinhyup => "shinhyup",
160            Suhyup => "suhyup",
161            Tossbank => "tossbank",
162            Woori => "woori",
163            Unknown(v) => v,
164        }
165    }
166}
167
168impl std::str::FromStr for PaymentMethodKrCardBrand {
169    type Err = std::convert::Infallible;
170    fn from_str(s: &str) -> Result<Self, Self::Err> {
171        use PaymentMethodKrCardBrand::*;
172        match s {
173            "bc" => Ok(Bc),
174            "citi" => Ok(Citi),
175            "hana" => Ok(Hana),
176            "hyundai" => Ok(Hyundai),
177            "jeju" => Ok(Jeju),
178            "jeonbuk" => Ok(Jeonbuk),
179            "kakaobank" => Ok(Kakaobank),
180            "kbank" => Ok(Kbank),
181            "kdbbank" => Ok(Kdbbank),
182            "kookmin" => Ok(Kookmin),
183            "kwangju" => Ok(Kwangju),
184            "lotte" => Ok(Lotte),
185            "mg" => Ok(Mg),
186            "nh" => Ok(Nh),
187            "post" => Ok(Post),
188            "samsung" => Ok(Samsung),
189            "savingsbank" => Ok(Savingsbank),
190            "shinhan" => Ok(Shinhan),
191            "shinhyup" => Ok(Shinhyup),
192            "suhyup" => Ok(Suhyup),
193            "tossbank" => Ok(Tossbank),
194            "woori" => Ok(Woori),
195            v => Ok(Unknown(v.to_owned())),
196        }
197    }
198}
199impl std::fmt::Display for PaymentMethodKrCardBrand {
200    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
201        f.write_str(self.as_str())
202    }
203}
204
205impl std::fmt::Debug for PaymentMethodKrCardBrand {
206    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
207        f.write_str(self.as_str())
208    }
209}
210#[cfg(feature = "serialize")]
211impl serde::Serialize for PaymentMethodKrCardBrand {
212    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
213    where
214        S: serde::Serializer,
215    {
216        serializer.serialize_str(self.as_str())
217    }
218}
219impl miniserde::Deserialize for PaymentMethodKrCardBrand {
220    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
221        crate::Place::new(out)
222    }
223}
224
225impl miniserde::de::Visitor for crate::Place<PaymentMethodKrCardBrand> {
226    fn string(&mut self, s: &str) -> miniserde::Result<()> {
227        use std::str::FromStr;
228        self.out = Some(PaymentMethodKrCardBrand::from_str(s).unwrap());
229        Ok(())
230    }
231}
232
233stripe_types::impl_from_val_with_from_str!(PaymentMethodKrCardBrand);
234#[cfg(feature = "deserialize")]
235impl<'de> serde::Deserialize<'de> for PaymentMethodKrCardBrand {
236    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
237        use std::str::FromStr;
238        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
239        Ok(Self::from_str(&s).unwrap())
240    }
241}
stripe_shared/payment_method_kr_card.rs

stripe_shared/
payment_method_kr_card.rs
