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