stripe_shared/
capability.rs

1/// This is an object representing a capability for a Stripe account.
2///
3/// Related guide: [Account capabilities](https://stripe.com/docs/connect/account-capabilities)
4///
5/// For more details see <<https://stripe.com/docs/api/capabilities/object>>.
6#[derive(Clone, Debug)]
7#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
8pub struct Capability {
9    /// The account for which the capability enables functionality.
10    pub account: stripe_types::Expandable<stripe_shared::Account>,
11    pub future_requirements: Option<stripe_shared::AccountCapabilityFutureRequirements>,
12    /// The identifier for the capability.
13    pub id: stripe_shared::CapabilityId,
14    /// Whether the capability has been requested.
15    pub requested: bool,
16    /// Time at which the capability was requested. Measured in seconds since the Unix epoch.
17    pub requested_at: Option<stripe_types::Timestamp>,
18    pub requirements: Option<stripe_shared::AccountCapabilityRequirements>,
19    /// The status of the capability.
20    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/// The status of the capability.
186#[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);
stripe_shared/capability.rs

stripe_shared/
capability.rs
