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::{Deserialize, Result, make_place};
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                _ => <dyn Visitor>::ignore(),
81            })
82        }
83
84        fn deser_default() -> Self {
85            Self {
86                account: Deserialize::default(),
87                future_requirements: Deserialize::default(),
88                id: Deserialize::default(),
89                requested: Deserialize::default(),
90                requested_at: Deserialize::default(),
91                requirements: Deserialize::default(),
92                status: Deserialize::default(),
93            }
94        }
95
96        fn take_out(&mut self) -> Option<Self::Out> {
97            let (
98                Some(account),
99                Some(future_requirements),
100                Some(id),
101                Some(requested),
102                Some(requested_at),
103                Some(requirements),
104                Some(status),
105            ) = (
106                self.account.take(),
107                self.future_requirements.take(),
108                self.id.take(),
109                self.requested,
110                self.requested_at,
111                self.requirements.take(),
112                self.status.take(),
113            )
114            else {
115                return None;
116            };
117            Some(Self::Out {
118                account,
119                future_requirements,
120                id,
121                requested,
122                requested_at,
123                requirements,
124                status,
125            })
126        }
127    }
128
129    impl Map for Builder<'_> {
130        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
131            self.builder.key(k)
132        }
133
134        fn finish(&mut self) -> Result<()> {
135            *self.out = self.builder.take_out();
136            Ok(())
137        }
138    }
139
140    impl ObjectDeser for Capability {
141        type Builder = CapabilityBuilder;
142    }
143
144    impl FromValueOpt for Capability {
145        fn from_value(v: Value) -> Option<Self> {
146            let Value::Object(obj) = v else {
147                return None;
148            };
149            let mut b = CapabilityBuilder::deser_default();
150            for (k, v) in obj {
151                match k.as_str() {
152                    "account" => b.account = FromValueOpt::from_value(v),
153                    "future_requirements" => b.future_requirements = FromValueOpt::from_value(v),
154                    "id" => b.id = FromValueOpt::from_value(v),
155                    "requested" => b.requested = FromValueOpt::from_value(v),
156                    "requested_at" => b.requested_at = FromValueOpt::from_value(v),
157                    "requirements" => b.requirements = FromValueOpt::from_value(v),
158                    "status" => b.status = FromValueOpt::from_value(v),
159                    _ => {}
160                }
161            }
162            b.take_out()
163        }
164    }
165};
166#[cfg(feature = "serialize")]
167impl serde::Serialize for Capability {
168    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
169        use serde::ser::SerializeStruct;
170        let mut s = s.serialize_struct("Capability", 8)?;
171        s.serialize_field("account", &self.account)?;
172        s.serialize_field("future_requirements", &self.future_requirements)?;
173        s.serialize_field("id", &self.id)?;
174        s.serialize_field("requested", &self.requested)?;
175        s.serialize_field("requested_at", &self.requested_at)?;
176        s.serialize_field("requirements", &self.requirements)?;
177        s.serialize_field("status", &self.status)?;
178
179        s.serialize_field("object", "capability")?;
180        s.end()
181    }
182}
183/// The status of the capability.
184#[derive(Clone, Eq, PartialEq)]
185#[non_exhaustive]
186pub enum CapabilityStatus {
187    Active,
188    Inactive,
189    Pending,
190    Unrequested,
191    /// An unrecognized value from Stripe. Should not be used as a request parameter.
192    Unknown(String),
193}
194impl CapabilityStatus {
195    pub fn as_str(&self) -> &str {
196        use CapabilityStatus::*;
197        match self {
198            Active => "active",
199            Inactive => "inactive",
200            Pending => "pending",
201            Unrequested => "unrequested",
202            Unknown(v) => v,
203        }
204    }
205}
206
207impl std::str::FromStr for CapabilityStatus {
208    type Err = std::convert::Infallible;
209    fn from_str(s: &str) -> Result<Self, Self::Err> {
210        use CapabilityStatus::*;
211        match s {
212            "active" => Ok(Active),
213            "inactive" => Ok(Inactive),
214            "pending" => Ok(Pending),
215            "unrequested" => Ok(Unrequested),
216            v => {
217                tracing::warn!("Unknown value '{}' for enum '{}'", v, "CapabilityStatus");
218                Ok(Unknown(v.to_owned()))
219            }
220        }
221    }
222}
223impl std::fmt::Display for CapabilityStatus {
224    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
225        f.write_str(self.as_str())
226    }
227}
228
229impl std::fmt::Debug for CapabilityStatus {
230    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
231        f.write_str(self.as_str())
232    }
233}
234#[cfg(feature = "serialize")]
235impl serde::Serialize for CapabilityStatus {
236    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
237    where
238        S: serde::Serializer,
239    {
240        serializer.serialize_str(self.as_str())
241    }
242}
243impl miniserde::Deserialize for CapabilityStatus {
244    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
245        crate::Place::new(out)
246    }
247}
248
249impl miniserde::de::Visitor for crate::Place<CapabilityStatus> {
250    fn string(&mut self, s: &str) -> miniserde::Result<()> {
251        use std::str::FromStr;
252        self.out = Some(CapabilityStatus::from_str(s).expect("infallible"));
253        Ok(())
254    }
255}
256
257stripe_types::impl_from_val_with_from_str!(CapabilityStatus);
258#[cfg(feature = "deserialize")]
259impl<'de> serde::Deserialize<'de> for CapabilityStatus {
260    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
261        use std::str::FromStr;
262        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
263        Ok(Self::from_str(&s).expect("infallible"))
264    }
265}
266impl stripe_types::Object for Capability {
267    type Id = stripe_shared::CapabilityId;
268    fn id(&self) -> &Self::Id {
269        &self.id
270    }
271
272    fn into_id(self) -> Self::Id {
273        self.id
274    }
275}
276stripe_types::def_id!(CapabilityId);
stripe_shared/capability.rs

stripe_shared/
capability.rs
