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

stripe_shared/
payment_method_kr_card.rs
