1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct PaymentMethodCardWallet {
5 pub amex_express_checkout: Option<stripe_shared::PaymentMethodCardWalletAmexExpressCheckout>,
6 pub apple_pay: Option<stripe_shared::PaymentMethodCardWalletApplePay>,
7 pub dynamic_last4: Option<String>,
9 pub google_pay: Option<stripe_shared::PaymentMethodCardWalletGooglePay>,
10 pub link: Option<stripe_shared::PaymentMethodCardWalletLink>,
11 pub masterpass: Option<stripe_shared::PaymentMethodCardWalletMasterpass>,
12 pub samsung_pay: Option<stripe_shared::PaymentMethodCardWalletSamsungPay>,
13 #[cfg_attr(any(feature = "deserialize", feature = "serialize"), serde(rename = "type"))]
17 pub type_: PaymentMethodCardWalletType,
18 pub visa_checkout: Option<stripe_shared::PaymentMethodCardWalletVisaCheckout>,
19}
20#[doc(hidden)]
21pub struct PaymentMethodCardWalletBuilder {
22 amex_express_checkout:
23 Option<Option<stripe_shared::PaymentMethodCardWalletAmexExpressCheckout>>,
24 apple_pay: Option<Option<stripe_shared::PaymentMethodCardWalletApplePay>>,
25 dynamic_last4: Option<Option<String>>,
26 google_pay: Option<Option<stripe_shared::PaymentMethodCardWalletGooglePay>>,
27 link: Option<Option<stripe_shared::PaymentMethodCardWalletLink>>,
28 masterpass: Option<Option<stripe_shared::PaymentMethodCardWalletMasterpass>>,
29 samsung_pay: Option<Option<stripe_shared::PaymentMethodCardWalletSamsungPay>>,
30 type_: Option<PaymentMethodCardWalletType>,
31 visa_checkout: Option<Option<stripe_shared::PaymentMethodCardWalletVisaCheckout>>,
32}
33
34#[allow(
35 unused_variables,
36 irrefutable_let_patterns,
37 clippy::let_unit_value,
38 clippy::match_single_binding,
39 clippy::single_match
40)]
41const _: () = {
42 use miniserde::de::{Map, Visitor};
43 use miniserde::json::Value;
44 use miniserde::{make_place, Deserialize, Result};
45 use stripe_types::miniserde_helpers::FromValueOpt;
46 use stripe_types::{MapBuilder, ObjectDeser};
47
48 make_place!(Place);
49
50 impl Deserialize for PaymentMethodCardWallet {
51 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
52 Place::new(out)
53 }
54 }
55
56 struct Builder<'a> {
57 out: &'a mut Option<PaymentMethodCardWallet>,
58 builder: PaymentMethodCardWalletBuilder,
59 }
60
61 impl Visitor for Place<PaymentMethodCardWallet> {
62 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
63 Ok(Box::new(Builder {
64 out: &mut self.out,
65 builder: PaymentMethodCardWalletBuilder::deser_default(),
66 }))
67 }
68 }
69
70 impl MapBuilder for PaymentMethodCardWalletBuilder {
71 type Out = PaymentMethodCardWallet;
72 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
73 Ok(match k {
74 "amex_express_checkout" => Deserialize::begin(&mut self.amex_express_checkout),
75 "apple_pay" => Deserialize::begin(&mut self.apple_pay),
76 "dynamic_last4" => Deserialize::begin(&mut self.dynamic_last4),
77 "google_pay" => Deserialize::begin(&mut self.google_pay),
78 "link" => Deserialize::begin(&mut self.link),
79 "masterpass" => Deserialize::begin(&mut self.masterpass),
80 "samsung_pay" => Deserialize::begin(&mut self.samsung_pay),
81 "type" => Deserialize::begin(&mut self.type_),
82 "visa_checkout" => Deserialize::begin(&mut self.visa_checkout),
83
84 _ => <dyn Visitor>::ignore(),
85 })
86 }
87
88 fn deser_default() -> Self {
89 Self {
90 amex_express_checkout: Deserialize::default(),
91 apple_pay: Deserialize::default(),
92 dynamic_last4: Deserialize::default(),
93 google_pay: Deserialize::default(),
94 link: Deserialize::default(),
95 masterpass: Deserialize::default(),
96 samsung_pay: Deserialize::default(),
97 type_: Deserialize::default(),
98 visa_checkout: Deserialize::default(),
99 }
100 }
101
102 fn take_out(&mut self) -> Option<Self::Out> {
103 let (
104 Some(amex_express_checkout),
105 Some(apple_pay),
106 Some(dynamic_last4),
107 Some(google_pay),
108 Some(link),
109 Some(masterpass),
110 Some(samsung_pay),
111 Some(type_),
112 Some(visa_checkout),
113 ) = (
114 self.amex_express_checkout,
115 self.apple_pay,
116 self.dynamic_last4.take(),
117 self.google_pay,
118 self.link,
119 self.masterpass.take(),
120 self.samsung_pay,
121 self.type_,
122 self.visa_checkout.take(),
123 )
124 else {
125 return None;
126 };
127 Some(Self::Out {
128 amex_express_checkout,
129 apple_pay,
130 dynamic_last4,
131 google_pay,
132 link,
133 masterpass,
134 samsung_pay,
135 type_,
136 visa_checkout,
137 })
138 }
139 }
140
141 impl<'a> Map for Builder<'a> {
142 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
143 self.builder.key(k)
144 }
145
146 fn finish(&mut self) -> Result<()> {
147 *self.out = self.builder.take_out();
148 Ok(())
149 }
150 }
151
152 impl ObjectDeser for PaymentMethodCardWallet {
153 type Builder = PaymentMethodCardWalletBuilder;
154 }
155
156 impl FromValueOpt for PaymentMethodCardWallet {
157 fn from_value(v: Value) -> Option<Self> {
158 let Value::Object(obj) = v else {
159 return None;
160 };
161 let mut b = PaymentMethodCardWalletBuilder::deser_default();
162 for (k, v) in obj {
163 match k.as_str() {
164 "amex_express_checkout" => {
165 b.amex_express_checkout = FromValueOpt::from_value(v)
166 }
167 "apple_pay" => b.apple_pay = FromValueOpt::from_value(v),
168 "dynamic_last4" => b.dynamic_last4 = FromValueOpt::from_value(v),
169 "google_pay" => b.google_pay = FromValueOpt::from_value(v),
170 "link" => b.link = FromValueOpt::from_value(v),
171 "masterpass" => b.masterpass = FromValueOpt::from_value(v),
172 "samsung_pay" => b.samsung_pay = FromValueOpt::from_value(v),
173 "type" => b.type_ = FromValueOpt::from_value(v),
174 "visa_checkout" => b.visa_checkout = FromValueOpt::from_value(v),
175
176 _ => {}
177 }
178 }
179 b.take_out()
180 }
181 }
182};
183#[derive(Copy, Clone, Eq, PartialEq)]
187pub enum PaymentMethodCardWalletType {
188 AmexExpressCheckout,
189 ApplePay,
190 GooglePay,
191 Link,
192 Masterpass,
193 SamsungPay,
194 VisaCheckout,
195}
196impl PaymentMethodCardWalletType {
197 pub fn as_str(self) -> &'static str {
198 use PaymentMethodCardWalletType::*;
199 match self {
200 AmexExpressCheckout => "amex_express_checkout",
201 ApplePay => "apple_pay",
202 GooglePay => "google_pay",
203 Link => "link",
204 Masterpass => "masterpass",
205 SamsungPay => "samsung_pay",
206 VisaCheckout => "visa_checkout",
207 }
208 }
209}
210
211impl std::str::FromStr for PaymentMethodCardWalletType {
212 type Err = stripe_types::StripeParseError;
213 fn from_str(s: &str) -> Result<Self, Self::Err> {
214 use PaymentMethodCardWalletType::*;
215 match s {
216 "amex_express_checkout" => Ok(AmexExpressCheckout),
217 "apple_pay" => Ok(ApplePay),
218 "google_pay" => Ok(GooglePay),
219 "link" => Ok(Link),
220 "masterpass" => Ok(Masterpass),
221 "samsung_pay" => Ok(SamsungPay),
222 "visa_checkout" => Ok(VisaCheckout),
223 _ => Err(stripe_types::StripeParseError),
224 }
225 }
226}
227impl std::fmt::Display for PaymentMethodCardWalletType {
228 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
229 f.write_str(self.as_str())
230 }
231}
232
233impl std::fmt::Debug for PaymentMethodCardWalletType {
234 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
235 f.write_str(self.as_str())
236 }
237}
238#[cfg(feature = "serialize")]
239impl serde::Serialize for PaymentMethodCardWalletType {
240 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
241 where
242 S: serde::Serializer,
243 {
244 serializer.serialize_str(self.as_str())
245 }
246}
247impl miniserde::Deserialize for PaymentMethodCardWalletType {
248 fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
249 crate::Place::new(out)
250 }
251}
252
253impl miniserde::de::Visitor for crate::Place<PaymentMethodCardWalletType> {
254 fn string(&mut self, s: &str) -> miniserde::Result<()> {
255 use std::str::FromStr;
256 self.out = Some(PaymentMethodCardWalletType::from_str(s).map_err(|_| miniserde::Error)?);
257 Ok(())
258 }
259}
260
261stripe_types::impl_from_val_with_from_str!(PaymentMethodCardWalletType);
262#[cfg(feature = "deserialize")]
263impl<'de> serde::Deserialize<'de> for PaymentMethodCardWalletType {
264 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
265 use std::str::FromStr;
266 let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
267 Self::from_str(&s)
268 .map_err(|_| serde::de::Error::custom("Unknown value for PaymentMethodCardWalletType"))
269 }
270}