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

stripe_shared/
payment_method_details_kr_card.rs
