stripe_shared/
entitlements_feature.rs

1/// A feature represents a monetizable ability or functionality in your system.
2/// Features can be assigned to products, and when those products are purchased, Stripe will create an entitlement to the feature for the purchasing customer.
3#[derive(Clone)]
4#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
5#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
6pub struct EntitlementsFeature {
7    /// Inactive features cannot be attached to new products and will not be returned from the features list endpoint.
8    pub active: bool,
9    /// Unique identifier for the object.
10    pub id: stripe_shared::EntitlementsFeatureId,
11    /// If the object exists in live mode, the value is `true`.
12    /// If the object exists in test mode, the value is `false`.
13    pub livemode: bool,
14    /// A unique key you provide as your own system identifier. This may be up to 80 characters.
15    pub lookup_key: String,
16    /// Set of key-value pairs that you can attach to an object.
17    /// This can be useful for storing additional information about the object in a structured format.
18    pub metadata: std::collections::HashMap<String, String>,
19    /// The feature's name, for your own purpose, not meant to be displayable to the customer.
20    pub name: String,
21}
22#[cfg(feature = "redact-generated-debug")]
23impl std::fmt::Debug for EntitlementsFeature {
24    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
25        f.debug_struct("EntitlementsFeature").finish_non_exhaustive()
26    }
27}
28#[doc(hidden)]
29pub struct EntitlementsFeatureBuilder {
30    active: Option<bool>,
31    id: Option<stripe_shared::EntitlementsFeatureId>,
32    livemode: Option<bool>,
33    lookup_key: Option<String>,
34    metadata: Option<std::collections::HashMap<String, String>>,
35    name: Option<String>,
36}
37
38#[allow(
39    unused_variables,
40    irrefutable_let_patterns,
41    clippy::let_unit_value,
42    clippy::match_single_binding,
43    clippy::single_match
44)]
45const _: () = {
46    use miniserde::de::{Map, Visitor};
47    use miniserde::json::Value;
48    use miniserde::{Deserialize, Result, make_place};
49    use stripe_types::miniserde_helpers::FromValueOpt;
50    use stripe_types::{MapBuilder, ObjectDeser};
51
52    make_place!(Place);
53
54    impl Deserialize for EntitlementsFeature {
55        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
56            Place::new(out)
57        }
58    }
59
60    struct Builder<'a> {
61        out: &'a mut Option<EntitlementsFeature>,
62        builder: EntitlementsFeatureBuilder,
63    }
64
65    impl Visitor for Place<EntitlementsFeature> {
66        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
67            Ok(Box::new(Builder {
68                out: &mut self.out,
69                builder: EntitlementsFeatureBuilder::deser_default(),
70            }))
71        }
72    }
73
74    impl MapBuilder for EntitlementsFeatureBuilder {
75        type Out = EntitlementsFeature;
76        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
77            Ok(match k {
78                "active" => Deserialize::begin(&mut self.active),
79                "id" => Deserialize::begin(&mut self.id),
80                "livemode" => Deserialize::begin(&mut self.livemode),
81                "lookup_key" => Deserialize::begin(&mut self.lookup_key),
82                "metadata" => Deserialize::begin(&mut self.metadata),
83                "name" => Deserialize::begin(&mut self.name),
84                _ => <dyn Visitor>::ignore(),
85            })
86        }
87
88        fn deser_default() -> Self {
89            Self {
90                active: None,
91                id: None,
92                livemode: None,
93                lookup_key: None,
94                metadata: None,
95                name: None,
96            }
97        }
98
99        fn take_out(&mut self) -> Option<Self::Out> {
100            let (
101                Some(active),
102                Some(id),
103                Some(livemode),
104                Some(lookup_key),
105                Some(metadata),
106                Some(name),
107            ) = (
108                self.active,
109                self.id.take(),
110                self.livemode,
111                self.lookup_key.take(),
112                self.metadata.take(),
113                self.name.take(),
114            )
115            else {
116                return None;
117            };
118            Some(Self::Out { active, id, livemode, lookup_key, metadata, name })
119        }
120    }
121
122    impl Map for Builder<'_> {
123        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
124            self.builder.key(k)
125        }
126
127        fn finish(&mut self) -> Result<()> {
128            *self.out = self.builder.take_out();
129            Ok(())
130        }
131    }
132
133    impl ObjectDeser for EntitlementsFeature {
134        type Builder = EntitlementsFeatureBuilder;
135    }
136
137    impl FromValueOpt for EntitlementsFeature {
138        fn from_value(v: Value) -> Option<Self> {
139            let Value::Object(obj) = v else {
140                return None;
141            };
142            let mut b = EntitlementsFeatureBuilder::deser_default();
143            for (k, v) in obj {
144                match k.as_str() {
145                    "active" => b.active = FromValueOpt::from_value(v),
146                    "id" => b.id = FromValueOpt::from_value(v),
147                    "livemode" => b.livemode = FromValueOpt::from_value(v),
148                    "lookup_key" => b.lookup_key = FromValueOpt::from_value(v),
149                    "metadata" => b.metadata = FromValueOpt::from_value(v),
150                    "name" => b.name = FromValueOpt::from_value(v),
151                    _ => {}
152                }
153            }
154            b.take_out()
155        }
156    }
157};
158#[cfg(feature = "serialize")]
159impl serde::Serialize for EntitlementsFeature {
160    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
161        use serde::ser::SerializeStruct;
162        let mut s = s.serialize_struct("EntitlementsFeature", 7)?;
163        s.serialize_field("active", &self.active)?;
164        s.serialize_field("id", &self.id)?;
165        s.serialize_field("livemode", &self.livemode)?;
166        s.serialize_field("lookup_key", &self.lookup_key)?;
167        s.serialize_field("metadata", &self.metadata)?;
168        s.serialize_field("name", &self.name)?;
169
170        s.serialize_field("object", "entitlements.feature")?;
171        s.end()
172    }
173}
174impl stripe_types::Object for EntitlementsFeature {
175    type Id = stripe_shared::EntitlementsFeatureId;
176    fn id(&self) -> &Self::Id {
177        &self.id
178    }
179
180    fn into_id(self) -> Self::Id {
181        self.id
182    }
183}
184stripe_types::def_id!(EntitlementsFeatureId);
stripe_shared/entitlements_feature.rs

stripe_shared/
entitlements_feature.rs
