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