1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct PaymentMethodDetailsEps {
5 pub bank: Option<PaymentMethodDetailsEpsBank>,
8 pub verified_name: Option<String>,
12}
13#[doc(hidden)]
14pub struct PaymentMethodDetailsEpsBuilder {
15 bank: Option<Option<PaymentMethodDetailsEpsBank>>,
16 verified_name: Option<Option<String>>,
17}
18
19#[allow(
20 unused_variables,
21 irrefutable_let_patterns,
22 clippy::let_unit_value,
23 clippy::match_single_binding,
24 clippy::single_match
25)]
26const _: () = {
27 use miniserde::de::{Map, Visitor};
28 use miniserde::json::Value;
29 use miniserde::{make_place, Deserialize, Result};
30 use stripe_types::miniserde_helpers::FromValueOpt;
31 use stripe_types::{MapBuilder, ObjectDeser};
32
33 make_place!(Place);
34
35 impl Deserialize for PaymentMethodDetailsEps {
36 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
37 Place::new(out)
38 }
39 }
40
41 struct Builder<'a> {
42 out: &'a mut Option<PaymentMethodDetailsEps>,
43 builder: PaymentMethodDetailsEpsBuilder,
44 }
45
46 impl Visitor for Place<PaymentMethodDetailsEps> {
47 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
48 Ok(Box::new(Builder {
49 out: &mut self.out,
50 builder: PaymentMethodDetailsEpsBuilder::deser_default(),
51 }))
52 }
53 }
54
55 impl MapBuilder for PaymentMethodDetailsEpsBuilder {
56 type Out = PaymentMethodDetailsEps;
57 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
58 Ok(match k {
59 "bank" => Deserialize::begin(&mut self.bank),
60 "verified_name" => Deserialize::begin(&mut self.verified_name),
61
62 _ => <dyn Visitor>::ignore(),
63 })
64 }
65
66 fn deser_default() -> Self {
67 Self { bank: Deserialize::default(), verified_name: Deserialize::default() }
68 }
69
70 fn take_out(&mut self) -> Option<Self::Out> {
71 let (Some(bank), Some(verified_name)) = (self.bank.take(), self.verified_name.take())
72 else {
73 return None;
74 };
75 Some(Self::Out { bank, verified_name })
76 }
77 }
78
79 impl<'a> Map for Builder<'a> {
80 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
81 self.builder.key(k)
82 }
83
84 fn finish(&mut self) -> Result<()> {
85 *self.out = self.builder.take_out();
86 Ok(())
87 }
88 }
89
90 impl ObjectDeser for PaymentMethodDetailsEps {
91 type Builder = PaymentMethodDetailsEpsBuilder;
92 }
93
94 impl FromValueOpt for PaymentMethodDetailsEps {
95 fn from_value(v: Value) -> Option<Self> {
96 let Value::Object(obj) = v else {
97 return None;
98 };
99 let mut b = PaymentMethodDetailsEpsBuilder::deser_default();
100 for (k, v) in obj {
101 match k.as_str() {
102 "bank" => b.bank = FromValueOpt::from_value(v),
103 "verified_name" => b.verified_name = FromValueOpt::from_value(v),
104
105 _ => {}
106 }
107 }
108 b.take_out()
109 }
110 }
111};
112#[derive(Clone, Eq, PartialEq)]
115#[non_exhaustive]
116pub enum PaymentMethodDetailsEpsBank {
117 ArzteUndApothekerBank,
118 AustrianAnadiBankAg,
119 BankAustria,
120 BankhausCarlSpangler,
121 BankhausSchelhammerUndSchatteraAg,
122 BawagPskAg,
123 BksBankAg,
124 BrullKallmusBankAg,
125 BtvVierLanderBank,
126 CapitalBankGraweGruppeAg,
127 DeutscheBankAg,
128 Dolomitenbank,
129 EasybankAg,
130 ErsteBankUndSparkassen,
131 HypoAlpeadriabankInternationalAg,
132 HypoBankBurgenlandAktiengesellschaft,
133 HypoNoeLbFurNiederosterreichUWien,
134 HypoOberosterreichSalzburgSteiermark,
135 HypoTirolBankAg,
136 HypoVorarlbergBankAg,
137 MarchfelderBank,
138 OberbankAg,
139 RaiffeisenBankengruppeOsterreich,
140 SchoellerbankAg,
141 SpardaBankWien,
142 VolksbankGruppe,
143 VolkskreditbankAg,
144 VrBankBraunau,
145 Unknown(String),
147}
148impl PaymentMethodDetailsEpsBank {
149 pub fn as_str(&self) -> &str {
150 use PaymentMethodDetailsEpsBank::*;
151 match self {
152 ArzteUndApothekerBank => "arzte_und_apotheker_bank",
153 AustrianAnadiBankAg => "austrian_anadi_bank_ag",
154 BankAustria => "bank_austria",
155 BankhausCarlSpangler => "bankhaus_carl_spangler",
156 BankhausSchelhammerUndSchatteraAg => "bankhaus_schelhammer_und_schattera_ag",
157 BawagPskAg => "bawag_psk_ag",
158 BksBankAg => "bks_bank_ag",
159 BrullKallmusBankAg => "brull_kallmus_bank_ag",
160 BtvVierLanderBank => "btv_vier_lander_bank",
161 CapitalBankGraweGruppeAg => "capital_bank_grawe_gruppe_ag",
162 DeutscheBankAg => "deutsche_bank_ag",
163 Dolomitenbank => "dolomitenbank",
164 EasybankAg => "easybank_ag",
165 ErsteBankUndSparkassen => "erste_bank_und_sparkassen",
166 HypoAlpeadriabankInternationalAg => "hypo_alpeadriabank_international_ag",
167 HypoBankBurgenlandAktiengesellschaft => "hypo_bank_burgenland_aktiengesellschaft",
168 HypoNoeLbFurNiederosterreichUWien => "hypo_noe_lb_fur_niederosterreich_u_wien",
169 HypoOberosterreichSalzburgSteiermark => "hypo_oberosterreich_salzburg_steiermark",
170 HypoTirolBankAg => "hypo_tirol_bank_ag",
171 HypoVorarlbergBankAg => "hypo_vorarlberg_bank_ag",
172 MarchfelderBank => "marchfelder_bank",
173 OberbankAg => "oberbank_ag",
174 RaiffeisenBankengruppeOsterreich => "raiffeisen_bankengruppe_osterreich",
175 SchoellerbankAg => "schoellerbank_ag",
176 SpardaBankWien => "sparda_bank_wien",
177 VolksbankGruppe => "volksbank_gruppe",
178 VolkskreditbankAg => "volkskreditbank_ag",
179 VrBankBraunau => "vr_bank_braunau",
180 Unknown(v) => v,
181 }
182 }
183}
184
185impl std::str::FromStr for PaymentMethodDetailsEpsBank {
186 type Err = std::convert::Infallible;
187 fn from_str(s: &str) -> Result<Self, Self::Err> {
188 use PaymentMethodDetailsEpsBank::*;
189 match s {
190 "arzte_und_apotheker_bank" => Ok(ArzteUndApothekerBank),
191 "austrian_anadi_bank_ag" => Ok(AustrianAnadiBankAg),
192 "bank_austria" => Ok(BankAustria),
193 "bankhaus_carl_spangler" => Ok(BankhausCarlSpangler),
194 "bankhaus_schelhammer_und_schattera_ag" => Ok(BankhausSchelhammerUndSchatteraAg),
195 "bawag_psk_ag" => Ok(BawagPskAg),
196 "bks_bank_ag" => Ok(BksBankAg),
197 "brull_kallmus_bank_ag" => Ok(BrullKallmusBankAg),
198 "btv_vier_lander_bank" => Ok(BtvVierLanderBank),
199 "capital_bank_grawe_gruppe_ag" => Ok(CapitalBankGraweGruppeAg),
200 "deutsche_bank_ag" => Ok(DeutscheBankAg),
201 "dolomitenbank" => Ok(Dolomitenbank),
202 "easybank_ag" => Ok(EasybankAg),
203 "erste_bank_und_sparkassen" => Ok(ErsteBankUndSparkassen),
204 "hypo_alpeadriabank_international_ag" => Ok(HypoAlpeadriabankInternationalAg),
205 "hypo_bank_burgenland_aktiengesellschaft" => Ok(HypoBankBurgenlandAktiengesellschaft),
206 "hypo_noe_lb_fur_niederosterreich_u_wien" => Ok(HypoNoeLbFurNiederosterreichUWien),
207 "hypo_oberosterreich_salzburg_steiermark" => Ok(HypoOberosterreichSalzburgSteiermark),
208 "hypo_tirol_bank_ag" => Ok(HypoTirolBankAg),
209 "hypo_vorarlberg_bank_ag" => Ok(HypoVorarlbergBankAg),
210 "marchfelder_bank" => Ok(MarchfelderBank),
211 "oberbank_ag" => Ok(OberbankAg),
212 "raiffeisen_bankengruppe_osterreich" => Ok(RaiffeisenBankengruppeOsterreich),
213 "schoellerbank_ag" => Ok(SchoellerbankAg),
214 "sparda_bank_wien" => Ok(SpardaBankWien),
215 "volksbank_gruppe" => Ok(VolksbankGruppe),
216 "volkskreditbank_ag" => Ok(VolkskreditbankAg),
217 "vr_bank_braunau" => Ok(VrBankBraunau),
218 v => Ok(Unknown(v.to_owned())),
219 }
220 }
221}
222impl std::fmt::Display for PaymentMethodDetailsEpsBank {
223 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
224 f.write_str(self.as_str())
225 }
226}
227
228impl std::fmt::Debug for PaymentMethodDetailsEpsBank {
229 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
230 f.write_str(self.as_str())
231 }
232}
233#[cfg(feature = "serialize")]
234impl serde::Serialize for PaymentMethodDetailsEpsBank {
235 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
236 where
237 S: serde::Serializer,
238 {
239 serializer.serialize_str(self.as_str())
240 }
241}
242impl miniserde::Deserialize for PaymentMethodDetailsEpsBank {
243 fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
244 crate::Place::new(out)
245 }
246}
247
248impl miniserde::de::Visitor for crate::Place<PaymentMethodDetailsEpsBank> {
249 fn string(&mut self, s: &str) -> miniserde::Result<()> {
250 use std::str::FromStr;
251 self.out = Some(PaymentMethodDetailsEpsBank::from_str(s).unwrap());
252 Ok(())
253 }
254}
255
256stripe_types::impl_from_val_with_from_str!(PaymentMethodDetailsEpsBank);
257#[cfg(feature = "deserialize")]
258impl<'de> serde::Deserialize<'de> for PaymentMethodDetailsEpsBank {
259 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
260 use std::str::FromStr;
261 let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
262 Ok(Self::from_str(&s).unwrap())
263 }
264}