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

stripe_shared/
capability.rs
