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 Map for Builder<'_> {
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    Inactive,
190    Pending,
191    Unrequested,
192}
193impl CapabilityStatus {
194    pub fn as_str(self) -> &'static str {
195        use CapabilityStatus::*;
196        match self {
197            Active => "active",
198            Inactive => "inactive",
199            Pending => "pending",
200            Unrequested => "unrequested",
201        }
202    }
203}
204
205impl std::str::FromStr for CapabilityStatus {
206    type Err = stripe_types::StripeParseError;
207    fn from_str(s: &str) -> Result<Self, Self::Err> {
208        use CapabilityStatus::*;
209        match s {
210            "active" => Ok(Active),
211            "inactive" => Ok(Inactive),
212            "pending" => Ok(Pending),
213            "unrequested" => Ok(Unrequested),
214            _ => Err(stripe_types::StripeParseError),
215        }
216    }
217}
218impl std::fmt::Display for CapabilityStatus {
219    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
220        f.write_str(self.as_str())
221    }
222}
223
224impl std::fmt::Debug for CapabilityStatus {
225    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
226        f.write_str(self.as_str())
227    }
228}
229#[cfg(feature = "serialize")]
230impl serde::Serialize for CapabilityStatus {
231    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
232    where
233        S: serde::Serializer,
234    {
235        serializer.serialize_str(self.as_str())
236    }
237}
238impl miniserde::Deserialize for CapabilityStatus {
239    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
240        crate::Place::new(out)
241    }
242}
243
244impl miniserde::de::Visitor for crate::Place<CapabilityStatus> {
245    fn string(&mut self, s: &str) -> miniserde::Result<()> {
246        use std::str::FromStr;
247        self.out = Some(CapabilityStatus::from_str(s).map_err(|_| miniserde::Error)?);
248        Ok(())
249    }
250}
251
252stripe_types::impl_from_val_with_from_str!(CapabilityStatus);
253#[cfg(feature = "deserialize")]
254impl<'de> serde::Deserialize<'de> for CapabilityStatus {
255    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
256        use std::str::FromStr;
257        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
258        Self::from_str(&s)
259            .map_err(|_| serde::de::Error::custom("Unknown value for CapabilityStatus"))
260    }
261}
262impl stripe_types::Object for Capability {
263    type Id = stripe_shared::CapabilityId;
264    fn id(&self) -> &Self::Id {
265        &self.id
266    }
267
268    fn into_id(self) -> Self::Id {
269        self.id
270    }
271}
272stripe_types::def_id!(CapabilityId);
stripe_shared/capability.rs

stripe_shared/
capability.rs
