1#[derive(Debug, Default)]
5pub struct JobTemplate {
6 properties: JobTemplateProperties
7}
8
9#[derive(Debug, Default)]
11pub struct JobTemplateProperties {
12 pub acceleration_settings: Option<::Value<self::job_template::AccelerationSettings>>,
17 pub category: Option<::Value<String>>,
22 pub description: Option<::Value<String>>,
27 pub hop_destinations: Option<::ValueList<self::job_template::HopDestination>>,
32 pub name: Option<::Value<String>>,
37 pub priority: Option<::Value<u32>>,
42 pub queue: Option<::Value<String>>,
47 pub settings_json: ::Value<::json::Value>,
52 pub status_update_interval: Option<::Value<String>>,
57 pub tags: Option<::Value<::json::Value>>,
62}
63
64impl ::serde::Serialize for JobTemplateProperties {
65 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
66 let mut map = ::serde::Serializer::serialize_map(s, None)?;
67 if let Some(ref acceleration_settings) = self.acceleration_settings {
68 ::serde::ser::SerializeMap::serialize_entry(&mut map, "AccelerationSettings", acceleration_settings)?;
69 }
70 if let Some(ref category) = self.category {
71 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Category", category)?;
72 }
73 if let Some(ref description) = self.description {
74 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Description", description)?;
75 }
76 if let Some(ref hop_destinations) = self.hop_destinations {
77 ::serde::ser::SerializeMap::serialize_entry(&mut map, "HopDestinations", hop_destinations)?;
78 }
79 if let Some(ref name) = self.name {
80 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Name", name)?;
81 }
82 if let Some(ref priority) = self.priority {
83 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Priority", priority)?;
84 }
85 if let Some(ref queue) = self.queue {
86 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Queue", queue)?;
87 }
88 ::serde::ser::SerializeMap::serialize_entry(&mut map, "SettingsJson", &self.settings_json)?;
89 if let Some(ref status_update_interval) = self.status_update_interval {
90 ::serde::ser::SerializeMap::serialize_entry(&mut map, "StatusUpdateInterval", status_update_interval)?;
91 }
92 if let Some(ref tags) = self.tags {
93 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Tags", tags)?;
94 }
95 ::serde::ser::SerializeMap::end(map)
96 }
97}
98
99impl<'de> ::serde::Deserialize<'de> for JobTemplateProperties {
100 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<JobTemplateProperties, D::Error> {
101 struct Visitor;
102
103 impl<'de> ::serde::de::Visitor<'de> for Visitor {
104 type Value = JobTemplateProperties;
105
106 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
107 write!(f, "a struct of type JobTemplateProperties")
108 }
109
110 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
111 let mut acceleration_settings: Option<::Value<self::job_template::AccelerationSettings>> = None;
112 let mut category: Option<::Value<String>> = None;
113 let mut description: Option<::Value<String>> = None;
114 let mut hop_destinations: Option<::ValueList<self::job_template::HopDestination>> = None;
115 let mut name: Option<::Value<String>> = None;
116 let mut priority: Option<::Value<u32>> = None;
117 let mut queue: Option<::Value<String>> = None;
118 let mut settings_json: Option<::Value<::json::Value>> = None;
119 let mut status_update_interval: Option<::Value<String>> = None;
120 let mut tags: Option<::Value<::json::Value>> = None;
121
122 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
123 match __cfn_key.as_ref() {
124 "AccelerationSettings" => {
125 acceleration_settings = ::serde::de::MapAccess::next_value(&mut map)?;
126 }
127 "Category" => {
128 category = ::serde::de::MapAccess::next_value(&mut map)?;
129 }
130 "Description" => {
131 description = ::serde::de::MapAccess::next_value(&mut map)?;
132 }
133 "HopDestinations" => {
134 hop_destinations = ::serde::de::MapAccess::next_value(&mut map)?;
135 }
136 "Name" => {
137 name = ::serde::de::MapAccess::next_value(&mut map)?;
138 }
139 "Priority" => {
140 priority = ::serde::de::MapAccess::next_value(&mut map)?;
141 }
142 "Queue" => {
143 queue = ::serde::de::MapAccess::next_value(&mut map)?;
144 }
145 "SettingsJson" => {
146 settings_json = ::serde::de::MapAccess::next_value(&mut map)?;
147 }
148 "StatusUpdateInterval" => {
149 status_update_interval = ::serde::de::MapAccess::next_value(&mut map)?;
150 }
151 "Tags" => {
152 tags = ::serde::de::MapAccess::next_value(&mut map)?;
153 }
154 _ => {}
155 }
156 }
157
158 Ok(JobTemplateProperties {
159 acceleration_settings: acceleration_settings,
160 category: category,
161 description: description,
162 hop_destinations: hop_destinations,
163 name: name,
164 priority: priority,
165 queue: queue,
166 settings_json: settings_json.ok_or(::serde::de::Error::missing_field("SettingsJson"))?,
167 status_update_interval: status_update_interval,
168 tags: tags,
169 })
170 }
171 }
172
173 d.deserialize_map(Visitor)
174 }
175}
176
177impl ::Resource for JobTemplate {
178 type Properties = JobTemplateProperties;
179 const TYPE: &'static str = "AWS::MediaConvert::JobTemplate";
180 fn properties(&self) -> &JobTemplateProperties {
181 &self.properties
182 }
183 fn properties_mut(&mut self) -> &mut JobTemplateProperties {
184 &mut self.properties
185 }
186}
187
188impl ::private::Sealed for JobTemplate {}
189
190impl From<JobTemplateProperties> for JobTemplate {
191 fn from(properties: JobTemplateProperties) -> JobTemplate {
192 JobTemplate { properties }
193 }
194}
195
196#[derive(Debug, Default)]
198pub struct Preset {
199 properties: PresetProperties
200}
201
202#[derive(Debug, Default)]
204pub struct PresetProperties {
205 pub category: Option<::Value<String>>,
210 pub description: Option<::Value<String>>,
215 pub name: Option<::Value<String>>,
220 pub settings_json: ::Value<::json::Value>,
225 pub tags: Option<::Value<::json::Value>>,
230}
231
232impl ::serde::Serialize for PresetProperties {
233 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
234 let mut map = ::serde::Serializer::serialize_map(s, None)?;
235 if let Some(ref category) = self.category {
236 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Category", category)?;
237 }
238 if let Some(ref description) = self.description {
239 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Description", description)?;
240 }
241 if let Some(ref name) = self.name {
242 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Name", name)?;
243 }
244 ::serde::ser::SerializeMap::serialize_entry(&mut map, "SettingsJson", &self.settings_json)?;
245 if let Some(ref tags) = self.tags {
246 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Tags", tags)?;
247 }
248 ::serde::ser::SerializeMap::end(map)
249 }
250}
251
252impl<'de> ::serde::Deserialize<'de> for PresetProperties {
253 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<PresetProperties, D::Error> {
254 struct Visitor;
255
256 impl<'de> ::serde::de::Visitor<'de> for Visitor {
257 type Value = PresetProperties;
258
259 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
260 write!(f, "a struct of type PresetProperties")
261 }
262
263 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
264 let mut category: Option<::Value<String>> = None;
265 let mut description: Option<::Value<String>> = None;
266 let mut name: Option<::Value<String>> = None;
267 let mut settings_json: Option<::Value<::json::Value>> = None;
268 let mut tags: Option<::Value<::json::Value>> = None;
269
270 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
271 match __cfn_key.as_ref() {
272 "Category" => {
273 category = ::serde::de::MapAccess::next_value(&mut map)?;
274 }
275 "Description" => {
276 description = ::serde::de::MapAccess::next_value(&mut map)?;
277 }
278 "Name" => {
279 name = ::serde::de::MapAccess::next_value(&mut map)?;
280 }
281 "SettingsJson" => {
282 settings_json = ::serde::de::MapAccess::next_value(&mut map)?;
283 }
284 "Tags" => {
285 tags = ::serde::de::MapAccess::next_value(&mut map)?;
286 }
287 _ => {}
288 }
289 }
290
291 Ok(PresetProperties {
292 category: category,
293 description: description,
294 name: name,
295 settings_json: settings_json.ok_or(::serde::de::Error::missing_field("SettingsJson"))?,
296 tags: tags,
297 })
298 }
299 }
300
301 d.deserialize_map(Visitor)
302 }
303}
304
305impl ::Resource for Preset {
306 type Properties = PresetProperties;
307 const TYPE: &'static str = "AWS::MediaConvert::Preset";
308 fn properties(&self) -> &PresetProperties {
309 &self.properties
310 }
311 fn properties_mut(&mut self) -> &mut PresetProperties {
312 &mut self.properties
313 }
314}
315
316impl ::private::Sealed for Preset {}
317
318impl From<PresetProperties> for Preset {
319 fn from(properties: PresetProperties) -> Preset {
320 Preset { properties }
321 }
322}
323
324#[derive(Debug, Default)]
326pub struct Queue {
327 properties: QueueProperties
328}
329
330#[derive(Debug, Default)]
332pub struct QueueProperties {
333 pub description: Option<::Value<String>>,
338 pub name: Option<::Value<String>>,
343 pub pricing_plan: Option<::Value<String>>,
348 pub status: Option<::Value<String>>,
353 pub tags: Option<::Value<::json::Value>>,
358}
359
360impl ::serde::Serialize for QueueProperties {
361 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
362 let mut map = ::serde::Serializer::serialize_map(s, None)?;
363 if let Some(ref description) = self.description {
364 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Description", description)?;
365 }
366 if let Some(ref name) = self.name {
367 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Name", name)?;
368 }
369 if let Some(ref pricing_plan) = self.pricing_plan {
370 ::serde::ser::SerializeMap::serialize_entry(&mut map, "PricingPlan", pricing_plan)?;
371 }
372 if let Some(ref status) = self.status {
373 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Status", status)?;
374 }
375 if let Some(ref tags) = self.tags {
376 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Tags", tags)?;
377 }
378 ::serde::ser::SerializeMap::end(map)
379 }
380}
381
382impl<'de> ::serde::Deserialize<'de> for QueueProperties {
383 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<QueueProperties, D::Error> {
384 struct Visitor;
385
386 impl<'de> ::serde::de::Visitor<'de> for Visitor {
387 type Value = QueueProperties;
388
389 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
390 write!(f, "a struct of type QueueProperties")
391 }
392
393 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
394 let mut description: Option<::Value<String>> = None;
395 let mut name: Option<::Value<String>> = None;
396 let mut pricing_plan: Option<::Value<String>> = None;
397 let mut status: Option<::Value<String>> = None;
398 let mut tags: Option<::Value<::json::Value>> = None;
399
400 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
401 match __cfn_key.as_ref() {
402 "Description" => {
403 description = ::serde::de::MapAccess::next_value(&mut map)?;
404 }
405 "Name" => {
406 name = ::serde::de::MapAccess::next_value(&mut map)?;
407 }
408 "PricingPlan" => {
409 pricing_plan = ::serde::de::MapAccess::next_value(&mut map)?;
410 }
411 "Status" => {
412 status = ::serde::de::MapAccess::next_value(&mut map)?;
413 }
414 "Tags" => {
415 tags = ::serde::de::MapAccess::next_value(&mut map)?;
416 }
417 _ => {}
418 }
419 }
420
421 Ok(QueueProperties {
422 description: description,
423 name: name,
424 pricing_plan: pricing_plan,
425 status: status,
426 tags: tags,
427 })
428 }
429 }
430
431 d.deserialize_map(Visitor)
432 }
433}
434
435impl ::Resource for Queue {
436 type Properties = QueueProperties;
437 const TYPE: &'static str = "AWS::MediaConvert::Queue";
438 fn properties(&self) -> &QueueProperties {
439 &self.properties
440 }
441 fn properties_mut(&mut self) -> &mut QueueProperties {
442 &mut self.properties
443 }
444}
445
446impl ::private::Sealed for Queue {}
447
448impl From<QueueProperties> for Queue {
449 fn from(properties: QueueProperties) -> Queue {
450 Queue { properties }
451 }
452}
453
454pub mod job_template {
455 #[derive(Debug, Default)]
459 pub struct AccelerationSettings {
460 pub mode: ::Value<String>,
465 }
466
467 impl ::codec::SerializeValue for AccelerationSettings {
468 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
469 let mut map = ::serde::Serializer::serialize_map(s, None)?;
470 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Mode", &self.mode)?;
471 ::serde::ser::SerializeMap::end(map)
472 }
473 }
474
475 impl ::codec::DeserializeValue for AccelerationSettings {
476 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<AccelerationSettings, D::Error> {
477 struct Visitor;
478
479 impl<'de> ::serde::de::Visitor<'de> for Visitor {
480 type Value = AccelerationSettings;
481
482 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
483 write!(f, "a struct of type AccelerationSettings")
484 }
485
486 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
487 let mut mode: Option<::Value<String>> = None;
488
489 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
490 match __cfn_key.as_ref() {
491 "Mode" => {
492 mode = ::serde::de::MapAccess::next_value(&mut map)?;
493 }
494 _ => {}
495 }
496 }
497
498 Ok(AccelerationSettings {
499 mode: mode.ok_or(::serde::de::Error::missing_field("Mode"))?,
500 })
501 }
502 }
503
504 d.deserialize_map(Visitor)
505 }
506 }
507
508 #[derive(Debug, Default)]
510 pub struct HopDestination {
511 pub priority: Option<::Value<u32>>,
516 pub queue: Option<::Value<String>>,
521 pub wait_minutes: Option<::Value<u32>>,
526 }
527
528 impl ::codec::SerializeValue for HopDestination {
529 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
530 let mut map = ::serde::Serializer::serialize_map(s, None)?;
531 if let Some(ref priority) = self.priority {
532 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Priority", priority)?;
533 }
534 if let Some(ref queue) = self.queue {
535 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Queue", queue)?;
536 }
537 if let Some(ref wait_minutes) = self.wait_minutes {
538 ::serde::ser::SerializeMap::serialize_entry(&mut map, "WaitMinutes", wait_minutes)?;
539 }
540 ::serde::ser::SerializeMap::end(map)
541 }
542 }
543
544 impl ::codec::DeserializeValue for HopDestination {
545 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<HopDestination, D::Error> {
546 struct Visitor;
547
548 impl<'de> ::serde::de::Visitor<'de> for Visitor {
549 type Value = HopDestination;
550
551 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
552 write!(f, "a struct of type HopDestination")
553 }
554
555 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
556 let mut priority: Option<::Value<u32>> = None;
557 let mut queue: Option<::Value<String>> = None;
558 let mut wait_minutes: Option<::Value<u32>> = None;
559
560 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
561 match __cfn_key.as_ref() {
562 "Priority" => {
563 priority = ::serde::de::MapAccess::next_value(&mut map)?;
564 }
565 "Queue" => {
566 queue = ::serde::de::MapAccess::next_value(&mut map)?;
567 }
568 "WaitMinutes" => {
569 wait_minutes = ::serde::de::MapAccess::next_value(&mut map)?;
570 }
571 _ => {}
572 }
573 }
574
575 Ok(HopDestination {
576 priority: priority,
577 queue: queue,
578 wait_minutes: wait_minutes,
579 })
580 }
581 }
582
583 d.deserialize_map(Visitor)
584 }
585 }
586}