1#[derive(Clone, Debug)]
6#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
7pub struct IssuingToken {
8 pub card: stripe_types::Expandable<stripe_shared::IssuingCard>,
10 pub created: stripe_types::Timestamp,
12 pub device_fingerprint: Option<String>,
14 pub id: stripe_shared::IssuingTokenId,
16 pub last4: Option<String>,
18 pub livemode: bool,
20 pub network: IssuingTokenNetwork,
22 pub network_data: Option<stripe_shared::IssuingNetworkTokenNetworkData>,
23 pub network_updated_at: stripe_types::Timestamp,
26 pub status: stripe_shared::IssuingTokenStatus,
28 pub wallet_provider: Option<IssuingTokenWalletProvider>,
30}
31#[doc(hidden)]
32pub struct IssuingTokenBuilder {
33 card: Option<stripe_types::Expandable<stripe_shared::IssuingCard>>,
34 created: Option<stripe_types::Timestamp>,
35 device_fingerprint: Option<Option<String>>,
36 id: Option<stripe_shared::IssuingTokenId>,
37 last4: Option<Option<String>>,
38 livemode: Option<bool>,
39 network: Option<IssuingTokenNetwork>,
40 network_data: Option<Option<stripe_shared::IssuingNetworkTokenNetworkData>>,
41 network_updated_at: Option<stripe_types::Timestamp>,
42 status: Option<stripe_shared::IssuingTokenStatus>,
43 wallet_provider: Option<Option<IssuingTokenWalletProvider>>,
44}
45
46#[allow(
47 unused_variables,
48 irrefutable_let_patterns,
49 clippy::let_unit_value,
50 clippy::match_single_binding,
51 clippy::single_match
52)]
53const _: () = {
54 use miniserde::de::{Map, Visitor};
55 use miniserde::json::Value;
56 use miniserde::{make_place, Deserialize, Result};
57 use stripe_types::miniserde_helpers::FromValueOpt;
58 use stripe_types::{MapBuilder, ObjectDeser};
59
60 make_place!(Place);
61
62 impl Deserialize for IssuingToken {
63 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
64 Place::new(out)
65 }
66 }
67
68 struct Builder<'a> {
69 out: &'a mut Option<IssuingToken>,
70 builder: IssuingTokenBuilder,
71 }
72
73 impl Visitor for Place<IssuingToken> {
74 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
75 Ok(Box::new(Builder {
76 out: &mut self.out,
77 builder: IssuingTokenBuilder::deser_default(),
78 }))
79 }
80 }
81
82 impl MapBuilder for IssuingTokenBuilder {
83 type Out = IssuingToken;
84 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
85 Ok(match k {
86 "card" => Deserialize::begin(&mut self.card),
87 "created" => Deserialize::begin(&mut self.created),
88 "device_fingerprint" => Deserialize::begin(&mut self.device_fingerprint),
89 "id" => Deserialize::begin(&mut self.id),
90 "last4" => Deserialize::begin(&mut self.last4),
91 "livemode" => Deserialize::begin(&mut self.livemode),
92 "network" => Deserialize::begin(&mut self.network),
93 "network_data" => Deserialize::begin(&mut self.network_data),
94 "network_updated_at" => Deserialize::begin(&mut self.network_updated_at),
95 "status" => Deserialize::begin(&mut self.status),
96 "wallet_provider" => Deserialize::begin(&mut self.wallet_provider),
97
98 _ => <dyn Visitor>::ignore(),
99 })
100 }
101
102 fn deser_default() -> Self {
103 Self {
104 card: Deserialize::default(),
105 created: Deserialize::default(),
106 device_fingerprint: Deserialize::default(),
107 id: Deserialize::default(),
108 last4: Deserialize::default(),
109 livemode: Deserialize::default(),
110 network: Deserialize::default(),
111 network_data: Deserialize::default(),
112 network_updated_at: Deserialize::default(),
113 status: Deserialize::default(),
114 wallet_provider: Deserialize::default(),
115 }
116 }
117
118 fn take_out(&mut self) -> Option<Self::Out> {
119 let (
120 Some(card),
121 Some(created),
122 Some(device_fingerprint),
123 Some(id),
124 Some(last4),
125 Some(livemode),
126 Some(network),
127 Some(network_data),
128 Some(network_updated_at),
129 Some(status),
130 Some(wallet_provider),
131 ) = (
132 self.card.take(),
133 self.created,
134 self.device_fingerprint.take(),
135 self.id.take(),
136 self.last4.take(),
137 self.livemode,
138 self.network,
139 self.network_data.take(),
140 self.network_updated_at,
141 self.status,
142 self.wallet_provider,
143 )
144 else {
145 return None;
146 };
147 Some(Self::Out {
148 card,
149 created,
150 device_fingerprint,
151 id,
152 last4,
153 livemode,
154 network,
155 network_data,
156 network_updated_at,
157 status,
158 wallet_provider,
159 })
160 }
161 }
162
163 impl<'a> Map for Builder<'a> {
164 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
165 self.builder.key(k)
166 }
167
168 fn finish(&mut self) -> Result<()> {
169 *self.out = self.builder.take_out();
170 Ok(())
171 }
172 }
173
174 impl ObjectDeser for IssuingToken {
175 type Builder = IssuingTokenBuilder;
176 }
177
178 impl FromValueOpt for IssuingToken {
179 fn from_value(v: Value) -> Option<Self> {
180 let Value::Object(obj) = v else {
181 return None;
182 };
183 let mut b = IssuingTokenBuilder::deser_default();
184 for (k, v) in obj {
185 match k.as_str() {
186 "card" => b.card = FromValueOpt::from_value(v),
187 "created" => b.created = FromValueOpt::from_value(v),
188 "device_fingerprint" => b.device_fingerprint = FromValueOpt::from_value(v),
189 "id" => b.id = FromValueOpt::from_value(v),
190 "last4" => b.last4 = FromValueOpt::from_value(v),
191 "livemode" => b.livemode = FromValueOpt::from_value(v),
192 "network" => b.network = FromValueOpt::from_value(v),
193 "network_data" => b.network_data = FromValueOpt::from_value(v),
194 "network_updated_at" => b.network_updated_at = FromValueOpt::from_value(v),
195 "status" => b.status = FromValueOpt::from_value(v),
196 "wallet_provider" => b.wallet_provider = FromValueOpt::from_value(v),
197
198 _ => {}
199 }
200 }
201 b.take_out()
202 }
203 }
204};
205#[cfg(feature = "serialize")]
206impl serde::Serialize for IssuingToken {
207 fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
208 use serde::ser::SerializeStruct;
209 let mut s = s.serialize_struct("IssuingToken", 12)?;
210 s.serialize_field("card", &self.card)?;
211 s.serialize_field("created", &self.created)?;
212 s.serialize_field("device_fingerprint", &self.device_fingerprint)?;
213 s.serialize_field("id", &self.id)?;
214 s.serialize_field("last4", &self.last4)?;
215 s.serialize_field("livemode", &self.livemode)?;
216 s.serialize_field("network", &self.network)?;
217 s.serialize_field("network_data", &self.network_data)?;
218 s.serialize_field("network_updated_at", &self.network_updated_at)?;
219 s.serialize_field("status", &self.status)?;
220 s.serialize_field("wallet_provider", &self.wallet_provider)?;
221
222 s.serialize_field("object", "issuing.token")?;
223 s.end()
224 }
225}
226#[derive(Copy, Clone, Eq, PartialEq)]
228pub enum IssuingTokenNetwork {
229 Mastercard,
230 Visa,
231}
232impl IssuingTokenNetwork {
233 pub fn as_str(self) -> &'static str {
234 use IssuingTokenNetwork::*;
235 match self {
236 Mastercard => "mastercard",
237 Visa => "visa",
238 }
239 }
240}
241
242impl std::str::FromStr for IssuingTokenNetwork {
243 type Err = stripe_types::StripeParseError;
244 fn from_str(s: &str) -> Result<Self, Self::Err> {
245 use IssuingTokenNetwork::*;
246 match s {
247 "mastercard" => Ok(Mastercard),
248 "visa" => Ok(Visa),
249 _ => Err(stripe_types::StripeParseError),
250 }
251 }
252}
253impl std::fmt::Display for IssuingTokenNetwork {
254 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
255 f.write_str(self.as_str())
256 }
257}
258
259impl std::fmt::Debug for IssuingTokenNetwork {
260 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
261 f.write_str(self.as_str())
262 }
263}
264#[cfg(feature = "serialize")]
265impl serde::Serialize for IssuingTokenNetwork {
266 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
267 where
268 S: serde::Serializer,
269 {
270 serializer.serialize_str(self.as_str())
271 }
272}
273impl miniserde::Deserialize for IssuingTokenNetwork {
274 fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
275 crate::Place::new(out)
276 }
277}
278
279impl miniserde::de::Visitor for crate::Place<IssuingTokenNetwork> {
280 fn string(&mut self, s: &str) -> miniserde::Result<()> {
281 use std::str::FromStr;
282 self.out = Some(IssuingTokenNetwork::from_str(s).map_err(|_| miniserde::Error)?);
283 Ok(())
284 }
285}
286
287stripe_types::impl_from_val_with_from_str!(IssuingTokenNetwork);
288#[cfg(feature = "deserialize")]
289impl<'de> serde::Deserialize<'de> for IssuingTokenNetwork {
290 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
291 use std::str::FromStr;
292 let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
293 Self::from_str(&s)
294 .map_err(|_| serde::de::Error::custom("Unknown value for IssuingTokenNetwork"))
295 }
296}
297#[derive(Copy, Clone, Eq, PartialEq)]
299pub enum IssuingTokenWalletProvider {
300 ApplePay,
301 GooglePay,
302 SamsungPay,
303}
304impl IssuingTokenWalletProvider {
305 pub fn as_str(self) -> &'static str {
306 use IssuingTokenWalletProvider::*;
307 match self {
308 ApplePay => "apple_pay",
309 GooglePay => "google_pay",
310 SamsungPay => "samsung_pay",
311 }
312 }
313}
314
315impl std::str::FromStr for IssuingTokenWalletProvider {
316 type Err = stripe_types::StripeParseError;
317 fn from_str(s: &str) -> Result<Self, Self::Err> {
318 use IssuingTokenWalletProvider::*;
319 match s {
320 "apple_pay" => Ok(ApplePay),
321 "google_pay" => Ok(GooglePay),
322 "samsung_pay" => Ok(SamsungPay),
323 _ => Err(stripe_types::StripeParseError),
324 }
325 }
326}
327impl std::fmt::Display for IssuingTokenWalletProvider {
328 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
329 f.write_str(self.as_str())
330 }
331}
332
333impl std::fmt::Debug for IssuingTokenWalletProvider {
334 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
335 f.write_str(self.as_str())
336 }
337}
338#[cfg(feature = "serialize")]
339impl serde::Serialize for IssuingTokenWalletProvider {
340 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
341 where
342 S: serde::Serializer,
343 {
344 serializer.serialize_str(self.as_str())
345 }
346}
347impl miniserde::Deserialize for IssuingTokenWalletProvider {
348 fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
349 crate::Place::new(out)
350 }
351}
352
353impl miniserde::de::Visitor for crate::Place<IssuingTokenWalletProvider> {
354 fn string(&mut self, s: &str) -> miniserde::Result<()> {
355 use std::str::FromStr;
356 self.out = Some(IssuingTokenWalletProvider::from_str(s).map_err(|_| miniserde::Error)?);
357 Ok(())
358 }
359}
360
361stripe_types::impl_from_val_with_from_str!(IssuingTokenWalletProvider);
362#[cfg(feature = "deserialize")]
363impl<'de> serde::Deserialize<'de> for IssuingTokenWalletProvider {
364 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
365 use std::str::FromStr;
366 let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
367 Self::from_str(&s)
368 .map_err(|_| serde::de::Error::custom("Unknown value for IssuingTokenWalletProvider"))
369 }
370}
371impl stripe_types::Object for IssuingToken {
372 type Id = stripe_shared::IssuingTokenId;
373 fn id(&self) -> &Self::Id {
374 &self.id
375 }
376
377 fn into_id(self) -> Self::Id {
378 self.id
379 }
380}
381stripe_types::def_id!(IssuingTokenId);
382#[derive(Copy, Clone, Eq, PartialEq)]
383pub enum IssuingTokenStatus {
384 Active,
385 Deleted,
386 Requested,
387 Suspended,
388}
389impl IssuingTokenStatus {
390 pub fn as_str(self) -> &'static str {
391 use IssuingTokenStatus::*;
392 match self {
393 Active => "active",
394 Deleted => "deleted",
395 Requested => "requested",
396 Suspended => "suspended",
397 }
398 }
399}
400
401impl std::str::FromStr for IssuingTokenStatus {
402 type Err = stripe_types::StripeParseError;
403 fn from_str(s: &str) -> Result<Self, Self::Err> {
404 use IssuingTokenStatus::*;
405 match s {
406 "active" => Ok(Active),
407 "deleted" => Ok(Deleted),
408 "requested" => Ok(Requested),
409 "suspended" => Ok(Suspended),
410 _ => Err(stripe_types::StripeParseError),
411 }
412 }
413}
414impl std::fmt::Display for IssuingTokenStatus {
415 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
416 f.write_str(self.as_str())
417 }
418}
419
420impl std::fmt::Debug for IssuingTokenStatus {
421 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
422 f.write_str(self.as_str())
423 }
424}
425impl serde::Serialize for IssuingTokenStatus {
426 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
427 where
428 S: serde::Serializer,
429 {
430 serializer.serialize_str(self.as_str())
431 }
432}
433impl miniserde::Deserialize for IssuingTokenStatus {
434 fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
435 crate::Place::new(out)
436 }
437}
438
439impl miniserde::de::Visitor for crate::Place<IssuingTokenStatus> {
440 fn string(&mut self, s: &str) -> miniserde::Result<()> {
441 use std::str::FromStr;
442 self.out = Some(IssuingTokenStatus::from_str(s).map_err(|_| miniserde::Error)?);
443 Ok(())
444 }
445}
446
447stripe_types::impl_from_val_with_from_str!(IssuingTokenStatus);
448#[cfg(feature = "deserialize")]
449impl<'de> serde::Deserialize<'de> for IssuingTokenStatus {
450 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
451 use std::str::FromStr;
452 let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
453 Self::from_str(&s)
454 .map_err(|_| serde::de::Error::custom("Unknown value for IssuingTokenStatus"))
455 }
456}