1#[derive(Clone, Debug)]
9#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
10pub struct PromotionCode {
11 pub active: bool,
14 pub code: String,
18 pub coupon: stripe_shared::Coupon,
19 pub created: stripe_types::Timestamp,
21 pub customer: Option<stripe_types::Expandable<stripe_shared::Customer>>,
23 pub expires_at: Option<stripe_types::Timestamp>,
25 pub id: stripe_shared::PromotionCodeId,
27 pub livemode: bool,
29 pub max_redemptions: Option<i64>,
31 pub metadata: Option<std::collections::HashMap<String, String>>,
34 pub restrictions: stripe_shared::PromotionCodesResourceRestrictions,
35 pub times_redeemed: i64,
37}
38#[doc(hidden)]
39pub struct PromotionCodeBuilder {
40 active: Option<bool>,
41 code: Option<String>,
42 coupon: Option<stripe_shared::Coupon>,
43 created: Option<stripe_types::Timestamp>,
44 customer: Option<Option<stripe_types::Expandable<stripe_shared::Customer>>>,
45 expires_at: Option<Option<stripe_types::Timestamp>>,
46 id: Option<stripe_shared::PromotionCodeId>,
47 livemode: Option<bool>,
48 max_redemptions: Option<Option<i64>>,
49 metadata: Option<Option<std::collections::HashMap<String, String>>>,
50 restrictions: Option<stripe_shared::PromotionCodesResourceRestrictions>,
51 times_redeemed: Option<i64>,
52}
53
54#[allow(
55 unused_variables,
56 irrefutable_let_patterns,
57 clippy::let_unit_value,
58 clippy::match_single_binding,
59 clippy::single_match
60)]
61const _: () = {
62 use miniserde::de::{Map, Visitor};
63 use miniserde::json::Value;
64 use miniserde::{make_place, Deserialize, Result};
65 use stripe_types::miniserde_helpers::FromValueOpt;
66 use stripe_types::{MapBuilder, ObjectDeser};
67
68 make_place!(Place);
69
70 impl Deserialize for PromotionCode {
71 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
72 Place::new(out)
73 }
74 }
75
76 struct Builder<'a> {
77 out: &'a mut Option<PromotionCode>,
78 builder: PromotionCodeBuilder,
79 }
80
81 impl Visitor for Place<PromotionCode> {
82 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
83 Ok(Box::new(Builder {
84 out: &mut self.out,
85 builder: PromotionCodeBuilder::deser_default(),
86 }))
87 }
88 }
89
90 impl MapBuilder for PromotionCodeBuilder {
91 type Out = PromotionCode;
92 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
93 Ok(match k {
94 "active" => Deserialize::begin(&mut self.active),
95 "code" => Deserialize::begin(&mut self.code),
96 "coupon" => Deserialize::begin(&mut self.coupon),
97 "created" => Deserialize::begin(&mut self.created),
98 "customer" => Deserialize::begin(&mut self.customer),
99 "expires_at" => Deserialize::begin(&mut self.expires_at),
100 "id" => Deserialize::begin(&mut self.id),
101 "livemode" => Deserialize::begin(&mut self.livemode),
102 "max_redemptions" => Deserialize::begin(&mut self.max_redemptions),
103 "metadata" => Deserialize::begin(&mut self.metadata),
104 "restrictions" => Deserialize::begin(&mut self.restrictions),
105 "times_redeemed" => Deserialize::begin(&mut self.times_redeemed),
106
107 _ => <dyn Visitor>::ignore(),
108 })
109 }
110
111 fn deser_default() -> Self {
112 Self {
113 active: Deserialize::default(),
114 code: Deserialize::default(),
115 coupon: Deserialize::default(),
116 created: Deserialize::default(),
117 customer: Deserialize::default(),
118 expires_at: Deserialize::default(),
119 id: Deserialize::default(),
120 livemode: Deserialize::default(),
121 max_redemptions: Deserialize::default(),
122 metadata: Deserialize::default(),
123 restrictions: Deserialize::default(),
124 times_redeemed: Deserialize::default(),
125 }
126 }
127
128 fn take_out(&mut self) -> Option<Self::Out> {
129 let (
130 Some(active),
131 Some(code),
132 Some(coupon),
133 Some(created),
134 Some(customer),
135 Some(expires_at),
136 Some(id),
137 Some(livemode),
138 Some(max_redemptions),
139 Some(metadata),
140 Some(restrictions),
141 Some(times_redeemed),
142 ) = (
143 self.active,
144 self.code.take(),
145 self.coupon.take(),
146 self.created,
147 self.customer.take(),
148 self.expires_at,
149 self.id.take(),
150 self.livemode,
151 self.max_redemptions,
152 self.metadata.take(),
153 self.restrictions.take(),
154 self.times_redeemed,
155 )
156 else {
157 return None;
158 };
159 Some(Self::Out {
160 active,
161 code,
162 coupon,
163 created,
164 customer,
165 expires_at,
166 id,
167 livemode,
168 max_redemptions,
169 metadata,
170 restrictions,
171 times_redeemed,
172 })
173 }
174 }
175
176 impl Map for Builder<'_> {
177 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
178 self.builder.key(k)
179 }
180
181 fn finish(&mut self) -> Result<()> {
182 *self.out = self.builder.take_out();
183 Ok(())
184 }
185 }
186
187 impl ObjectDeser for PromotionCode {
188 type Builder = PromotionCodeBuilder;
189 }
190
191 impl FromValueOpt for PromotionCode {
192 fn from_value(v: Value) -> Option<Self> {
193 let Value::Object(obj) = v else {
194 return None;
195 };
196 let mut b = PromotionCodeBuilder::deser_default();
197 for (k, v) in obj {
198 match k.as_str() {
199 "active" => b.active = FromValueOpt::from_value(v),
200 "code" => b.code = FromValueOpt::from_value(v),
201 "coupon" => b.coupon = FromValueOpt::from_value(v),
202 "created" => b.created = FromValueOpt::from_value(v),
203 "customer" => b.customer = FromValueOpt::from_value(v),
204 "expires_at" => b.expires_at = FromValueOpt::from_value(v),
205 "id" => b.id = FromValueOpt::from_value(v),
206 "livemode" => b.livemode = FromValueOpt::from_value(v),
207 "max_redemptions" => b.max_redemptions = FromValueOpt::from_value(v),
208 "metadata" => b.metadata = FromValueOpt::from_value(v),
209 "restrictions" => b.restrictions = FromValueOpt::from_value(v),
210 "times_redeemed" => b.times_redeemed = FromValueOpt::from_value(v),
211
212 _ => {}
213 }
214 }
215 b.take_out()
216 }
217 }
218};
219#[cfg(feature = "serialize")]
220impl serde::Serialize for PromotionCode {
221 fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
222 use serde::ser::SerializeStruct;
223 let mut s = s.serialize_struct("PromotionCode", 13)?;
224 s.serialize_field("active", &self.active)?;
225 s.serialize_field("code", &self.code)?;
226 s.serialize_field("coupon", &self.coupon)?;
227 s.serialize_field("created", &self.created)?;
228 s.serialize_field("customer", &self.customer)?;
229 s.serialize_field("expires_at", &self.expires_at)?;
230 s.serialize_field("id", &self.id)?;
231 s.serialize_field("livemode", &self.livemode)?;
232 s.serialize_field("max_redemptions", &self.max_redemptions)?;
233 s.serialize_field("metadata", &self.metadata)?;
234 s.serialize_field("restrictions", &self.restrictions)?;
235 s.serialize_field("times_redeemed", &self.times_redeemed)?;
236
237 s.serialize_field("object", "promotion_code")?;
238 s.end()
239 }
240}
241impl stripe_types::Object for PromotionCode {
242 type Id = stripe_shared::PromotionCodeId;
243 fn id(&self) -> &Self::Id {
244 &self.id
245 }
246
247 fn into_id(self) -> Self::Id {
248 self.id
249 }
250}
251stripe_types::def_id!(PromotionCodeId);