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