1#[derive(Clone, Debug)]
7#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
8pub struct SubscriptionSchedule {
9 pub application: Option<stripe_types::Expandable<stripe_shared::Application>>,
11 pub canceled_at: Option<stripe_types::Timestamp>,
13 pub completed_at: Option<stripe_types::Timestamp>,
15 pub created: stripe_types::Timestamp,
17 pub current_phase: Option<stripe_shared::SubscriptionScheduleCurrentPhase>,
19 pub customer: stripe_types::Expandable<stripe_shared::Customer>,
21 pub default_settings: stripe_shared::SubscriptionSchedulesResourceDefaultSettings,
22 pub end_behavior: stripe_shared::SubscriptionScheduleEndBehavior,
27 pub id: stripe_shared::SubscriptionScheduleId,
29 pub livemode: bool,
31 pub metadata: Option<std::collections::HashMap<String, String>>,
34 pub phases: Vec<stripe_shared::SubscriptionSchedulePhaseConfiguration>,
36 pub released_at: Option<stripe_types::Timestamp>,
38 pub released_subscription: Option<String>,
40 pub status: SubscriptionScheduleStatus,
44 pub subscription: Option<stripe_types::Expandable<stripe_shared::Subscription>>,
46 pub test_clock: Option<stripe_types::Expandable<stripe_shared::TestHelpersTestClock>>,
48}
49#[doc(hidden)]
50pub struct SubscriptionScheduleBuilder {
51 application: Option<Option<stripe_types::Expandable<stripe_shared::Application>>>,
52 canceled_at: Option<Option<stripe_types::Timestamp>>,
53 completed_at: Option<Option<stripe_types::Timestamp>>,
54 created: Option<stripe_types::Timestamp>,
55 current_phase: Option<Option<stripe_shared::SubscriptionScheduleCurrentPhase>>,
56 customer: Option<stripe_types::Expandable<stripe_shared::Customer>>,
57 default_settings: Option<stripe_shared::SubscriptionSchedulesResourceDefaultSettings>,
58 end_behavior: Option<stripe_shared::SubscriptionScheduleEndBehavior>,
59 id: Option<stripe_shared::SubscriptionScheduleId>,
60 livemode: Option<bool>,
61 metadata: Option<Option<std::collections::HashMap<String, String>>>,
62 phases: Option<Vec<stripe_shared::SubscriptionSchedulePhaseConfiguration>>,
63 released_at: Option<Option<stripe_types::Timestamp>>,
64 released_subscription: Option<Option<String>>,
65 status: Option<SubscriptionScheduleStatus>,
66 subscription: Option<Option<stripe_types::Expandable<stripe_shared::Subscription>>>,
67 test_clock: Option<Option<stripe_types::Expandable<stripe_shared::TestHelpersTestClock>>>,
68}
69
70#[allow(
71 unused_variables,
72 irrefutable_let_patterns,
73 clippy::let_unit_value,
74 clippy::match_single_binding,
75 clippy::single_match
76)]
77const _: () = {
78 use miniserde::de::{Map, Visitor};
79 use miniserde::json::Value;
80 use miniserde::{make_place, Deserialize, Result};
81 use stripe_types::miniserde_helpers::FromValueOpt;
82 use stripe_types::{MapBuilder, ObjectDeser};
83
84 make_place!(Place);
85
86 impl Deserialize for SubscriptionSchedule {
87 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
88 Place::new(out)
89 }
90 }
91
92 struct Builder<'a> {
93 out: &'a mut Option<SubscriptionSchedule>,
94 builder: SubscriptionScheduleBuilder,
95 }
96
97 impl Visitor for Place<SubscriptionSchedule> {
98 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
99 Ok(Box::new(Builder {
100 out: &mut self.out,
101 builder: SubscriptionScheduleBuilder::deser_default(),
102 }))
103 }
104 }
105
106 impl MapBuilder for SubscriptionScheduleBuilder {
107 type Out = SubscriptionSchedule;
108 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
109 Ok(match k {
110 "application" => Deserialize::begin(&mut self.application),
111 "canceled_at" => Deserialize::begin(&mut self.canceled_at),
112 "completed_at" => Deserialize::begin(&mut self.completed_at),
113 "created" => Deserialize::begin(&mut self.created),
114 "current_phase" => Deserialize::begin(&mut self.current_phase),
115 "customer" => Deserialize::begin(&mut self.customer),
116 "default_settings" => Deserialize::begin(&mut self.default_settings),
117 "end_behavior" => Deserialize::begin(&mut self.end_behavior),
118 "id" => Deserialize::begin(&mut self.id),
119 "livemode" => Deserialize::begin(&mut self.livemode),
120 "metadata" => Deserialize::begin(&mut self.metadata),
121 "phases" => Deserialize::begin(&mut self.phases),
122 "released_at" => Deserialize::begin(&mut self.released_at),
123 "released_subscription" => Deserialize::begin(&mut self.released_subscription),
124 "status" => Deserialize::begin(&mut self.status),
125 "subscription" => Deserialize::begin(&mut self.subscription),
126 "test_clock" => Deserialize::begin(&mut self.test_clock),
127
128 _ => <dyn Visitor>::ignore(),
129 })
130 }
131
132 fn deser_default() -> Self {
133 Self {
134 application: Deserialize::default(),
135 canceled_at: Deserialize::default(),
136 completed_at: Deserialize::default(),
137 created: Deserialize::default(),
138 current_phase: Deserialize::default(),
139 customer: Deserialize::default(),
140 default_settings: Deserialize::default(),
141 end_behavior: Deserialize::default(),
142 id: Deserialize::default(),
143 livemode: Deserialize::default(),
144 metadata: Deserialize::default(),
145 phases: Deserialize::default(),
146 released_at: Deserialize::default(),
147 released_subscription: Deserialize::default(),
148 status: Deserialize::default(),
149 subscription: Deserialize::default(),
150 test_clock: Deserialize::default(),
151 }
152 }
153
154 fn take_out(&mut self) -> Option<Self::Out> {
155 let (
156 Some(application),
157 Some(canceled_at),
158 Some(completed_at),
159 Some(created),
160 Some(current_phase),
161 Some(customer),
162 Some(default_settings),
163 Some(end_behavior),
164 Some(id),
165 Some(livemode),
166 Some(metadata),
167 Some(phases),
168 Some(released_at),
169 Some(released_subscription),
170 Some(status),
171 Some(subscription),
172 Some(test_clock),
173 ) = (
174 self.application.take(),
175 self.canceled_at,
176 self.completed_at,
177 self.created,
178 self.current_phase,
179 self.customer.take(),
180 self.default_settings.take(),
181 self.end_behavior,
182 self.id.take(),
183 self.livemode,
184 self.metadata.take(),
185 self.phases.take(),
186 self.released_at,
187 self.released_subscription.take(),
188 self.status,
189 self.subscription.take(),
190 self.test_clock.take(),
191 )
192 else {
193 return None;
194 };
195 Some(Self::Out {
196 application,
197 canceled_at,
198 completed_at,
199 created,
200 current_phase,
201 customer,
202 default_settings,
203 end_behavior,
204 id,
205 livemode,
206 metadata,
207 phases,
208 released_at,
209 released_subscription,
210 status,
211 subscription,
212 test_clock,
213 })
214 }
215 }
216
217 impl<'a> Map for Builder<'a> {
218 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
219 self.builder.key(k)
220 }
221
222 fn finish(&mut self) -> Result<()> {
223 *self.out = self.builder.take_out();
224 Ok(())
225 }
226 }
227
228 impl ObjectDeser for SubscriptionSchedule {
229 type Builder = SubscriptionScheduleBuilder;
230 }
231
232 impl FromValueOpt for SubscriptionSchedule {
233 fn from_value(v: Value) -> Option<Self> {
234 let Value::Object(obj) = v else {
235 return None;
236 };
237 let mut b = SubscriptionScheduleBuilder::deser_default();
238 for (k, v) in obj {
239 match k.as_str() {
240 "application" => b.application = FromValueOpt::from_value(v),
241 "canceled_at" => b.canceled_at = FromValueOpt::from_value(v),
242 "completed_at" => b.completed_at = FromValueOpt::from_value(v),
243 "created" => b.created = FromValueOpt::from_value(v),
244 "current_phase" => b.current_phase = FromValueOpt::from_value(v),
245 "customer" => b.customer = FromValueOpt::from_value(v),
246 "default_settings" => b.default_settings = FromValueOpt::from_value(v),
247 "end_behavior" => b.end_behavior = FromValueOpt::from_value(v),
248 "id" => b.id = FromValueOpt::from_value(v),
249 "livemode" => b.livemode = FromValueOpt::from_value(v),
250 "metadata" => b.metadata = FromValueOpt::from_value(v),
251 "phases" => b.phases = FromValueOpt::from_value(v),
252 "released_at" => b.released_at = FromValueOpt::from_value(v),
253 "released_subscription" => {
254 b.released_subscription = FromValueOpt::from_value(v)
255 }
256 "status" => b.status = FromValueOpt::from_value(v),
257 "subscription" => b.subscription = FromValueOpt::from_value(v),
258 "test_clock" => b.test_clock = FromValueOpt::from_value(v),
259
260 _ => {}
261 }
262 }
263 b.take_out()
264 }
265 }
266};
267#[cfg(feature = "serialize")]
268impl serde::Serialize for SubscriptionSchedule {
269 fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
270 use serde::ser::SerializeStruct;
271 let mut s = s.serialize_struct("SubscriptionSchedule", 18)?;
272 s.serialize_field("application", &self.application)?;
273 s.serialize_field("canceled_at", &self.canceled_at)?;
274 s.serialize_field("completed_at", &self.completed_at)?;
275 s.serialize_field("created", &self.created)?;
276 s.serialize_field("current_phase", &self.current_phase)?;
277 s.serialize_field("customer", &self.customer)?;
278 s.serialize_field("default_settings", &self.default_settings)?;
279 s.serialize_field("end_behavior", &self.end_behavior)?;
280 s.serialize_field("id", &self.id)?;
281 s.serialize_field("livemode", &self.livemode)?;
282 s.serialize_field("metadata", &self.metadata)?;
283 s.serialize_field("phases", &self.phases)?;
284 s.serialize_field("released_at", &self.released_at)?;
285 s.serialize_field("released_subscription", &self.released_subscription)?;
286 s.serialize_field("status", &self.status)?;
287 s.serialize_field("subscription", &self.subscription)?;
288 s.serialize_field("test_clock", &self.test_clock)?;
289
290 s.serialize_field("object", "subscription_schedule")?;
291 s.end()
292 }
293}
294#[derive(Copy, Clone, Eq, PartialEq)]
298pub enum SubscriptionScheduleStatus {
299 Active,
300 Canceled,
301 Completed,
302 NotStarted,
303 Released,
304}
305impl SubscriptionScheduleStatus {
306 pub fn as_str(self) -> &'static str {
307 use SubscriptionScheduleStatus::*;
308 match self {
309 Active => "active",
310 Canceled => "canceled",
311 Completed => "completed",
312 NotStarted => "not_started",
313 Released => "released",
314 }
315 }
316}
317
318impl std::str::FromStr for SubscriptionScheduleStatus {
319 type Err = stripe_types::StripeParseError;
320 fn from_str(s: &str) -> Result<Self, Self::Err> {
321 use SubscriptionScheduleStatus::*;
322 match s {
323 "active" => Ok(Active),
324 "canceled" => Ok(Canceled),
325 "completed" => Ok(Completed),
326 "not_started" => Ok(NotStarted),
327 "released" => Ok(Released),
328 _ => Err(stripe_types::StripeParseError),
329 }
330 }
331}
332impl std::fmt::Display for SubscriptionScheduleStatus {
333 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
334 f.write_str(self.as_str())
335 }
336}
337
338impl std::fmt::Debug for SubscriptionScheduleStatus {
339 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
340 f.write_str(self.as_str())
341 }
342}
343#[cfg(feature = "serialize")]
344impl serde::Serialize for SubscriptionScheduleStatus {
345 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
346 where
347 S: serde::Serializer,
348 {
349 serializer.serialize_str(self.as_str())
350 }
351}
352impl miniserde::Deserialize for SubscriptionScheduleStatus {
353 fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
354 crate::Place::new(out)
355 }
356}
357
358impl miniserde::de::Visitor for crate::Place<SubscriptionScheduleStatus> {
359 fn string(&mut self, s: &str) -> miniserde::Result<()> {
360 use std::str::FromStr;
361 self.out = Some(SubscriptionScheduleStatus::from_str(s).map_err(|_| miniserde::Error)?);
362 Ok(())
363 }
364}
365
366stripe_types::impl_from_val_with_from_str!(SubscriptionScheduleStatus);
367#[cfg(feature = "deserialize")]
368impl<'de> serde::Deserialize<'de> for SubscriptionScheduleStatus {
369 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
370 use std::str::FromStr;
371 let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
372 Self::from_str(&s)
373 .map_err(|_| serde::de::Error::custom("Unknown value for SubscriptionScheduleStatus"))
374 }
375}
376impl stripe_types::Object for SubscriptionSchedule {
377 type Id = stripe_shared::SubscriptionScheduleId;
378 fn id(&self) -> &Self::Id {
379 &self.id
380 }
381
382 fn into_id(self) -> Self::Id {
383 self.id
384 }
385}
386stripe_types::def_id!(SubscriptionScheduleId);
387#[derive(Copy, Clone, Eq, PartialEq)]
388pub enum SubscriptionScheduleEndBehavior {
389 Cancel,
390 None,
391 Release,
392 Renew,
393}
394impl SubscriptionScheduleEndBehavior {
395 pub fn as_str(self) -> &'static str {
396 use SubscriptionScheduleEndBehavior::*;
397 match self {
398 Cancel => "cancel",
399 None => "none",
400 Release => "release",
401 Renew => "renew",
402 }
403 }
404}
405
406impl std::str::FromStr for SubscriptionScheduleEndBehavior {
407 type Err = stripe_types::StripeParseError;
408 fn from_str(s: &str) -> Result<Self, Self::Err> {
409 use SubscriptionScheduleEndBehavior::*;
410 match s {
411 "cancel" => Ok(Cancel),
412 "none" => Ok(None),
413 "release" => Ok(Release),
414 "renew" => Ok(Renew),
415 _ => Err(stripe_types::StripeParseError),
416 }
417 }
418}
419impl std::fmt::Display for SubscriptionScheduleEndBehavior {
420 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
421 f.write_str(self.as_str())
422 }
423}
424
425impl std::fmt::Debug for SubscriptionScheduleEndBehavior {
426 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
427 f.write_str(self.as_str())
428 }
429}
430impl serde::Serialize for SubscriptionScheduleEndBehavior {
431 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
432 where
433 S: serde::Serializer,
434 {
435 serializer.serialize_str(self.as_str())
436 }
437}
438impl miniserde::Deserialize for SubscriptionScheduleEndBehavior {
439 fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
440 crate::Place::new(out)
441 }
442}
443
444impl miniserde::de::Visitor for crate::Place<SubscriptionScheduleEndBehavior> {
445 fn string(&mut self, s: &str) -> miniserde::Result<()> {
446 use std::str::FromStr;
447 self.out =
448 Some(SubscriptionScheduleEndBehavior::from_str(s).map_err(|_| miniserde::Error)?);
449 Ok(())
450 }
451}
452
453stripe_types::impl_from_val_with_from_str!(SubscriptionScheduleEndBehavior);
454#[cfg(feature = "deserialize")]
455impl<'de> serde::Deserialize<'de> for SubscriptionScheduleEndBehavior {
456 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
457 use std::str::FromStr;
458 let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
459 Self::from_str(&s).map_err(|_| {
460 serde::de::Error::custom("Unknown value for SubscriptionScheduleEndBehavior")
461 })
462 }
463}