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