1#[derive(Debug, Default)]
5pub struct Application {
6 properties: ApplicationProperties
7}
8
9#[derive(Debug, Default)]
11pub struct ApplicationProperties {
12 pub description: Option<::Value<String>>,
17 pub name: ::Value<String>,
22 pub tags: Option<::ValueList<self::application::Tags>>,
27}
28
29impl ::serde::Serialize for ApplicationProperties {
30 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
31 let mut map = ::serde::Serializer::serialize_map(s, None)?;
32 if let Some(ref description) = self.description {
33 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Description", description)?;
34 }
35 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Name", &self.name)?;
36 if let Some(ref tags) = self.tags {
37 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Tags", tags)?;
38 }
39 ::serde::ser::SerializeMap::end(map)
40 }
41}
42
43impl<'de> ::serde::Deserialize<'de> for ApplicationProperties {
44 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<ApplicationProperties, D::Error> {
45 struct Visitor;
46
47 impl<'de> ::serde::de::Visitor<'de> for Visitor {
48 type Value = ApplicationProperties;
49
50 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
51 write!(f, "a struct of type ApplicationProperties")
52 }
53
54 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
55 let mut description: Option<::Value<String>> = None;
56 let mut name: Option<::Value<String>> = None;
57 let mut tags: Option<::ValueList<self::application::Tags>> = None;
58
59 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
60 match __cfn_key.as_ref() {
61 "Description" => {
62 description = ::serde::de::MapAccess::next_value(&mut map)?;
63 }
64 "Name" => {
65 name = ::serde::de::MapAccess::next_value(&mut map)?;
66 }
67 "Tags" => {
68 tags = ::serde::de::MapAccess::next_value(&mut map)?;
69 }
70 _ => {}
71 }
72 }
73
74 Ok(ApplicationProperties {
75 description: description,
76 name: name.ok_or(::serde::de::Error::missing_field("Name"))?,
77 tags: tags,
78 })
79 }
80 }
81
82 d.deserialize_map(Visitor)
83 }
84}
85
86impl ::Resource for Application {
87 type Properties = ApplicationProperties;
88 const TYPE: &'static str = "AWS::AppConfig::Application";
89 fn properties(&self) -> &ApplicationProperties {
90 &self.properties
91 }
92 fn properties_mut(&mut self) -> &mut ApplicationProperties {
93 &mut self.properties
94 }
95}
96
97impl ::private::Sealed for Application {}
98
99impl From<ApplicationProperties> for Application {
100 fn from(properties: ApplicationProperties) -> Application {
101 Application { properties }
102 }
103}
104
105#[derive(Debug, Default)]
107pub struct ConfigurationProfile {
108 properties: ConfigurationProfileProperties
109}
110
111#[derive(Debug, Default)]
113pub struct ConfigurationProfileProperties {
114 pub application_id: ::Value<String>,
119 pub description: Option<::Value<String>>,
124 pub location_uri: ::Value<String>,
129 pub name: ::Value<String>,
134 pub retrieval_role_arn: Option<::Value<String>>,
139 pub tags: Option<::ValueList<self::configuration_profile::Tags>>,
144 pub validators: Option<::ValueList<self::configuration_profile::Validators>>,
149}
150
151impl ::serde::Serialize for ConfigurationProfileProperties {
152 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
153 let mut map = ::serde::Serializer::serialize_map(s, None)?;
154 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ApplicationId", &self.application_id)?;
155 if let Some(ref description) = self.description {
156 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Description", description)?;
157 }
158 ::serde::ser::SerializeMap::serialize_entry(&mut map, "LocationUri", &self.location_uri)?;
159 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Name", &self.name)?;
160 if let Some(ref retrieval_role_arn) = self.retrieval_role_arn {
161 ::serde::ser::SerializeMap::serialize_entry(&mut map, "RetrievalRoleArn", retrieval_role_arn)?;
162 }
163 if let Some(ref tags) = self.tags {
164 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Tags", tags)?;
165 }
166 if let Some(ref validators) = self.validators {
167 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Validators", validators)?;
168 }
169 ::serde::ser::SerializeMap::end(map)
170 }
171}
172
173impl<'de> ::serde::Deserialize<'de> for ConfigurationProfileProperties {
174 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<ConfigurationProfileProperties, D::Error> {
175 struct Visitor;
176
177 impl<'de> ::serde::de::Visitor<'de> for Visitor {
178 type Value = ConfigurationProfileProperties;
179
180 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
181 write!(f, "a struct of type ConfigurationProfileProperties")
182 }
183
184 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
185 let mut application_id: Option<::Value<String>> = None;
186 let mut description: Option<::Value<String>> = None;
187 let mut location_uri: Option<::Value<String>> = None;
188 let mut name: Option<::Value<String>> = None;
189 let mut retrieval_role_arn: Option<::Value<String>> = None;
190 let mut tags: Option<::ValueList<self::configuration_profile::Tags>> = None;
191 let mut validators: Option<::ValueList<self::configuration_profile::Validators>> = None;
192
193 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
194 match __cfn_key.as_ref() {
195 "ApplicationId" => {
196 application_id = ::serde::de::MapAccess::next_value(&mut map)?;
197 }
198 "Description" => {
199 description = ::serde::de::MapAccess::next_value(&mut map)?;
200 }
201 "LocationUri" => {
202 location_uri = ::serde::de::MapAccess::next_value(&mut map)?;
203 }
204 "Name" => {
205 name = ::serde::de::MapAccess::next_value(&mut map)?;
206 }
207 "RetrievalRoleArn" => {
208 retrieval_role_arn = ::serde::de::MapAccess::next_value(&mut map)?;
209 }
210 "Tags" => {
211 tags = ::serde::de::MapAccess::next_value(&mut map)?;
212 }
213 "Validators" => {
214 validators = ::serde::de::MapAccess::next_value(&mut map)?;
215 }
216 _ => {}
217 }
218 }
219
220 Ok(ConfigurationProfileProperties {
221 application_id: application_id.ok_or(::serde::de::Error::missing_field("ApplicationId"))?,
222 description: description,
223 location_uri: location_uri.ok_or(::serde::de::Error::missing_field("LocationUri"))?,
224 name: name.ok_or(::serde::de::Error::missing_field("Name"))?,
225 retrieval_role_arn: retrieval_role_arn,
226 tags: tags,
227 validators: validators,
228 })
229 }
230 }
231
232 d.deserialize_map(Visitor)
233 }
234}
235
236impl ::Resource for ConfigurationProfile {
237 type Properties = ConfigurationProfileProperties;
238 const TYPE: &'static str = "AWS::AppConfig::ConfigurationProfile";
239 fn properties(&self) -> &ConfigurationProfileProperties {
240 &self.properties
241 }
242 fn properties_mut(&mut self) -> &mut ConfigurationProfileProperties {
243 &mut self.properties
244 }
245}
246
247impl ::private::Sealed for ConfigurationProfile {}
248
249impl From<ConfigurationProfileProperties> for ConfigurationProfile {
250 fn from(properties: ConfigurationProfileProperties) -> ConfigurationProfile {
251 ConfigurationProfile { properties }
252 }
253}
254
255#[derive(Debug, Default)]
257pub struct Deployment {
258 properties: DeploymentProperties
259}
260
261#[derive(Debug, Default)]
263pub struct DeploymentProperties {
264 pub application_id: ::Value<String>,
269 pub configuration_profile_id: ::Value<String>,
274 pub configuration_version: ::Value<String>,
279 pub deployment_strategy_id: ::Value<String>,
284 pub description: Option<::Value<String>>,
289 pub environment_id: ::Value<String>,
294 pub tags: Option<::ValueList<self::deployment::Tags>>,
299}
300
301impl ::serde::Serialize for DeploymentProperties {
302 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
303 let mut map = ::serde::Serializer::serialize_map(s, None)?;
304 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ApplicationId", &self.application_id)?;
305 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ConfigurationProfileId", &self.configuration_profile_id)?;
306 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ConfigurationVersion", &self.configuration_version)?;
307 ::serde::ser::SerializeMap::serialize_entry(&mut map, "DeploymentStrategyId", &self.deployment_strategy_id)?;
308 if let Some(ref description) = self.description {
309 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Description", description)?;
310 }
311 ::serde::ser::SerializeMap::serialize_entry(&mut map, "EnvironmentId", &self.environment_id)?;
312 if let Some(ref tags) = self.tags {
313 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Tags", tags)?;
314 }
315 ::serde::ser::SerializeMap::end(map)
316 }
317}
318
319impl<'de> ::serde::Deserialize<'de> for DeploymentProperties {
320 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<DeploymentProperties, D::Error> {
321 struct Visitor;
322
323 impl<'de> ::serde::de::Visitor<'de> for Visitor {
324 type Value = DeploymentProperties;
325
326 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
327 write!(f, "a struct of type DeploymentProperties")
328 }
329
330 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
331 let mut application_id: Option<::Value<String>> = None;
332 let mut configuration_profile_id: Option<::Value<String>> = None;
333 let mut configuration_version: Option<::Value<String>> = None;
334 let mut deployment_strategy_id: Option<::Value<String>> = None;
335 let mut description: Option<::Value<String>> = None;
336 let mut environment_id: Option<::Value<String>> = None;
337 let mut tags: Option<::ValueList<self::deployment::Tags>> = None;
338
339 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
340 match __cfn_key.as_ref() {
341 "ApplicationId" => {
342 application_id = ::serde::de::MapAccess::next_value(&mut map)?;
343 }
344 "ConfigurationProfileId" => {
345 configuration_profile_id = ::serde::de::MapAccess::next_value(&mut map)?;
346 }
347 "ConfigurationVersion" => {
348 configuration_version = ::serde::de::MapAccess::next_value(&mut map)?;
349 }
350 "DeploymentStrategyId" => {
351 deployment_strategy_id = ::serde::de::MapAccess::next_value(&mut map)?;
352 }
353 "Description" => {
354 description = ::serde::de::MapAccess::next_value(&mut map)?;
355 }
356 "EnvironmentId" => {
357 environment_id = ::serde::de::MapAccess::next_value(&mut map)?;
358 }
359 "Tags" => {
360 tags = ::serde::de::MapAccess::next_value(&mut map)?;
361 }
362 _ => {}
363 }
364 }
365
366 Ok(DeploymentProperties {
367 application_id: application_id.ok_or(::serde::de::Error::missing_field("ApplicationId"))?,
368 configuration_profile_id: configuration_profile_id.ok_or(::serde::de::Error::missing_field("ConfigurationProfileId"))?,
369 configuration_version: configuration_version.ok_or(::serde::de::Error::missing_field("ConfigurationVersion"))?,
370 deployment_strategy_id: deployment_strategy_id.ok_or(::serde::de::Error::missing_field("DeploymentStrategyId"))?,
371 description: description,
372 environment_id: environment_id.ok_or(::serde::de::Error::missing_field("EnvironmentId"))?,
373 tags: tags,
374 })
375 }
376 }
377
378 d.deserialize_map(Visitor)
379 }
380}
381
382impl ::Resource for Deployment {
383 type Properties = DeploymentProperties;
384 const TYPE: &'static str = "AWS::AppConfig::Deployment";
385 fn properties(&self) -> &DeploymentProperties {
386 &self.properties
387 }
388 fn properties_mut(&mut self) -> &mut DeploymentProperties {
389 &mut self.properties
390 }
391}
392
393impl ::private::Sealed for Deployment {}
394
395impl From<DeploymentProperties> for Deployment {
396 fn from(properties: DeploymentProperties) -> Deployment {
397 Deployment { properties }
398 }
399}
400
401#[derive(Debug, Default)]
403pub struct DeploymentStrategy {
404 properties: DeploymentStrategyProperties
405}
406
407#[derive(Debug, Default)]
409pub struct DeploymentStrategyProperties {
410 pub deployment_duration_in_minutes: ::Value<f64>,
415 pub description: Option<::Value<String>>,
420 pub final_bake_time_in_minutes: Option<::Value<f64>>,
425 pub growth_factor: ::Value<f64>,
430 pub growth_type: Option<::Value<String>>,
435 pub name: ::Value<String>,
440 pub replicate_to: ::Value<String>,
445 pub tags: Option<::ValueList<self::deployment_strategy::Tags>>,
450}
451
452impl ::serde::Serialize for DeploymentStrategyProperties {
453 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
454 let mut map = ::serde::Serializer::serialize_map(s, None)?;
455 ::serde::ser::SerializeMap::serialize_entry(&mut map, "DeploymentDurationInMinutes", &self.deployment_duration_in_minutes)?;
456 if let Some(ref description) = self.description {
457 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Description", description)?;
458 }
459 if let Some(ref final_bake_time_in_minutes) = self.final_bake_time_in_minutes {
460 ::serde::ser::SerializeMap::serialize_entry(&mut map, "FinalBakeTimeInMinutes", final_bake_time_in_minutes)?;
461 }
462 ::serde::ser::SerializeMap::serialize_entry(&mut map, "GrowthFactor", &self.growth_factor)?;
463 if let Some(ref growth_type) = self.growth_type {
464 ::serde::ser::SerializeMap::serialize_entry(&mut map, "GrowthType", growth_type)?;
465 }
466 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Name", &self.name)?;
467 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ReplicateTo", &self.replicate_to)?;
468 if let Some(ref tags) = self.tags {
469 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Tags", tags)?;
470 }
471 ::serde::ser::SerializeMap::end(map)
472 }
473}
474
475impl<'de> ::serde::Deserialize<'de> for DeploymentStrategyProperties {
476 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<DeploymentStrategyProperties, D::Error> {
477 struct Visitor;
478
479 impl<'de> ::serde::de::Visitor<'de> for Visitor {
480 type Value = DeploymentStrategyProperties;
481
482 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
483 write!(f, "a struct of type DeploymentStrategyProperties")
484 }
485
486 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
487 let mut deployment_duration_in_minutes: Option<::Value<f64>> = None;
488 let mut description: Option<::Value<String>> = None;
489 let mut final_bake_time_in_minutes: Option<::Value<f64>> = None;
490 let mut growth_factor: Option<::Value<f64>> = None;
491 let mut growth_type: Option<::Value<String>> = None;
492 let mut name: Option<::Value<String>> = None;
493 let mut replicate_to: Option<::Value<String>> = None;
494 let mut tags: Option<::ValueList<self::deployment_strategy::Tags>> = None;
495
496 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
497 match __cfn_key.as_ref() {
498 "DeploymentDurationInMinutes" => {
499 deployment_duration_in_minutes = ::serde::de::MapAccess::next_value(&mut map)?;
500 }
501 "Description" => {
502 description = ::serde::de::MapAccess::next_value(&mut map)?;
503 }
504 "FinalBakeTimeInMinutes" => {
505 final_bake_time_in_minutes = ::serde::de::MapAccess::next_value(&mut map)?;
506 }
507 "GrowthFactor" => {
508 growth_factor = ::serde::de::MapAccess::next_value(&mut map)?;
509 }
510 "GrowthType" => {
511 growth_type = ::serde::de::MapAccess::next_value(&mut map)?;
512 }
513 "Name" => {
514 name = ::serde::de::MapAccess::next_value(&mut map)?;
515 }
516 "ReplicateTo" => {
517 replicate_to = ::serde::de::MapAccess::next_value(&mut map)?;
518 }
519 "Tags" => {
520 tags = ::serde::de::MapAccess::next_value(&mut map)?;
521 }
522 _ => {}
523 }
524 }
525
526 Ok(DeploymentStrategyProperties {
527 deployment_duration_in_minutes: deployment_duration_in_minutes.ok_or(::serde::de::Error::missing_field("DeploymentDurationInMinutes"))?,
528 description: description,
529 final_bake_time_in_minutes: final_bake_time_in_minutes,
530 growth_factor: growth_factor.ok_or(::serde::de::Error::missing_field("GrowthFactor"))?,
531 growth_type: growth_type,
532 name: name.ok_or(::serde::de::Error::missing_field("Name"))?,
533 replicate_to: replicate_to.ok_or(::serde::de::Error::missing_field("ReplicateTo"))?,
534 tags: tags,
535 })
536 }
537 }
538
539 d.deserialize_map(Visitor)
540 }
541}
542
543impl ::Resource for DeploymentStrategy {
544 type Properties = DeploymentStrategyProperties;
545 const TYPE: &'static str = "AWS::AppConfig::DeploymentStrategy";
546 fn properties(&self) -> &DeploymentStrategyProperties {
547 &self.properties
548 }
549 fn properties_mut(&mut self) -> &mut DeploymentStrategyProperties {
550 &mut self.properties
551 }
552}
553
554impl ::private::Sealed for DeploymentStrategy {}
555
556impl From<DeploymentStrategyProperties> for DeploymentStrategy {
557 fn from(properties: DeploymentStrategyProperties) -> DeploymentStrategy {
558 DeploymentStrategy { properties }
559 }
560}
561
562#[derive(Debug, Default)]
564pub struct Environment {
565 properties: EnvironmentProperties
566}
567
568#[derive(Debug, Default)]
570pub struct EnvironmentProperties {
571 pub application_id: ::Value<String>,
576 pub description: Option<::Value<String>>,
581 pub monitors: Option<::ValueList<self::environment::Monitors>>,
586 pub name: ::Value<String>,
591 pub tags: Option<::ValueList<self::environment::Tags>>,
596}
597
598impl ::serde::Serialize for EnvironmentProperties {
599 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
600 let mut map = ::serde::Serializer::serialize_map(s, None)?;
601 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ApplicationId", &self.application_id)?;
602 if let Some(ref description) = self.description {
603 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Description", description)?;
604 }
605 if let Some(ref monitors) = self.monitors {
606 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Monitors", monitors)?;
607 }
608 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Name", &self.name)?;
609 if let Some(ref tags) = self.tags {
610 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Tags", tags)?;
611 }
612 ::serde::ser::SerializeMap::end(map)
613 }
614}
615
616impl<'de> ::serde::Deserialize<'de> for EnvironmentProperties {
617 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<EnvironmentProperties, D::Error> {
618 struct Visitor;
619
620 impl<'de> ::serde::de::Visitor<'de> for Visitor {
621 type Value = EnvironmentProperties;
622
623 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
624 write!(f, "a struct of type EnvironmentProperties")
625 }
626
627 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
628 let mut application_id: Option<::Value<String>> = None;
629 let mut description: Option<::Value<String>> = None;
630 let mut monitors: Option<::ValueList<self::environment::Monitors>> = None;
631 let mut name: Option<::Value<String>> = None;
632 let mut tags: Option<::ValueList<self::environment::Tags>> = None;
633
634 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
635 match __cfn_key.as_ref() {
636 "ApplicationId" => {
637 application_id = ::serde::de::MapAccess::next_value(&mut map)?;
638 }
639 "Description" => {
640 description = ::serde::de::MapAccess::next_value(&mut map)?;
641 }
642 "Monitors" => {
643 monitors = ::serde::de::MapAccess::next_value(&mut map)?;
644 }
645 "Name" => {
646 name = ::serde::de::MapAccess::next_value(&mut map)?;
647 }
648 "Tags" => {
649 tags = ::serde::de::MapAccess::next_value(&mut map)?;
650 }
651 _ => {}
652 }
653 }
654
655 Ok(EnvironmentProperties {
656 application_id: application_id.ok_or(::serde::de::Error::missing_field("ApplicationId"))?,
657 description: description,
658 monitors: monitors,
659 name: name.ok_or(::serde::de::Error::missing_field("Name"))?,
660 tags: tags,
661 })
662 }
663 }
664
665 d.deserialize_map(Visitor)
666 }
667}
668
669impl ::Resource for Environment {
670 type Properties = EnvironmentProperties;
671 const TYPE: &'static str = "AWS::AppConfig::Environment";
672 fn properties(&self) -> &EnvironmentProperties {
673 &self.properties
674 }
675 fn properties_mut(&mut self) -> &mut EnvironmentProperties {
676 &mut self.properties
677 }
678}
679
680impl ::private::Sealed for Environment {}
681
682impl From<EnvironmentProperties> for Environment {
683 fn from(properties: EnvironmentProperties) -> Environment {
684 Environment { properties }
685 }
686}
687
688#[derive(Debug, Default)]
690pub struct HostedConfigurationVersion {
691 properties: HostedConfigurationVersionProperties
692}
693
694#[derive(Debug, Default)]
696pub struct HostedConfigurationVersionProperties {
697 pub application_id: ::Value<String>,
702 pub configuration_profile_id: ::Value<String>,
707 pub content: ::Value<String>,
712 pub content_type: ::Value<String>,
717 pub description: Option<::Value<String>>,
722 pub latest_version_number: Option<::Value<f64>>,
727}
728
729impl ::serde::Serialize for HostedConfigurationVersionProperties {
730 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
731 let mut map = ::serde::Serializer::serialize_map(s, None)?;
732 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ApplicationId", &self.application_id)?;
733 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ConfigurationProfileId", &self.configuration_profile_id)?;
734 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Content", &self.content)?;
735 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ContentType", &self.content_type)?;
736 if let Some(ref description) = self.description {
737 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Description", description)?;
738 }
739 if let Some(ref latest_version_number) = self.latest_version_number {
740 ::serde::ser::SerializeMap::serialize_entry(&mut map, "LatestVersionNumber", latest_version_number)?;
741 }
742 ::serde::ser::SerializeMap::end(map)
743 }
744}
745
746impl<'de> ::serde::Deserialize<'de> for HostedConfigurationVersionProperties {
747 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<HostedConfigurationVersionProperties, D::Error> {
748 struct Visitor;
749
750 impl<'de> ::serde::de::Visitor<'de> for Visitor {
751 type Value = HostedConfigurationVersionProperties;
752
753 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
754 write!(f, "a struct of type HostedConfigurationVersionProperties")
755 }
756
757 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
758 let mut application_id: Option<::Value<String>> = None;
759 let mut configuration_profile_id: Option<::Value<String>> = None;
760 let mut content: Option<::Value<String>> = None;
761 let mut content_type: Option<::Value<String>> = None;
762 let mut description: Option<::Value<String>> = None;
763 let mut latest_version_number: Option<::Value<f64>> = None;
764
765 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
766 match __cfn_key.as_ref() {
767 "ApplicationId" => {
768 application_id = ::serde::de::MapAccess::next_value(&mut map)?;
769 }
770 "ConfigurationProfileId" => {
771 configuration_profile_id = ::serde::de::MapAccess::next_value(&mut map)?;
772 }
773 "Content" => {
774 content = ::serde::de::MapAccess::next_value(&mut map)?;
775 }
776 "ContentType" => {
777 content_type = ::serde::de::MapAccess::next_value(&mut map)?;
778 }
779 "Description" => {
780 description = ::serde::de::MapAccess::next_value(&mut map)?;
781 }
782 "LatestVersionNumber" => {
783 latest_version_number = ::serde::de::MapAccess::next_value(&mut map)?;
784 }
785 _ => {}
786 }
787 }
788
789 Ok(HostedConfigurationVersionProperties {
790 application_id: application_id.ok_or(::serde::de::Error::missing_field("ApplicationId"))?,
791 configuration_profile_id: configuration_profile_id.ok_or(::serde::de::Error::missing_field("ConfigurationProfileId"))?,
792 content: content.ok_or(::serde::de::Error::missing_field("Content"))?,
793 content_type: content_type.ok_or(::serde::de::Error::missing_field("ContentType"))?,
794 description: description,
795 latest_version_number: latest_version_number,
796 })
797 }
798 }
799
800 d.deserialize_map(Visitor)
801 }
802}
803
804impl ::Resource for HostedConfigurationVersion {
805 type Properties = HostedConfigurationVersionProperties;
806 const TYPE: &'static str = "AWS::AppConfig::HostedConfigurationVersion";
807 fn properties(&self) -> &HostedConfigurationVersionProperties {
808 &self.properties
809 }
810 fn properties_mut(&mut self) -> &mut HostedConfigurationVersionProperties {
811 &mut self.properties
812 }
813}
814
815impl ::private::Sealed for HostedConfigurationVersion {}
816
817impl From<HostedConfigurationVersionProperties> for HostedConfigurationVersion {
818 fn from(properties: HostedConfigurationVersionProperties) -> HostedConfigurationVersion {
819 HostedConfigurationVersion { properties }
820 }
821}
822
823pub mod application {
824 #[derive(Debug, Default)]
828 pub struct Tags {
829 pub key: Option<::Value<String>>,
834 pub value: Option<::Value<String>>,
839 }
840
841 impl ::codec::SerializeValue for Tags {
842 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
843 let mut map = ::serde::Serializer::serialize_map(s, None)?;
844 if let Some(ref key) = self.key {
845 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Key", key)?;
846 }
847 if let Some(ref value) = self.value {
848 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Value", value)?;
849 }
850 ::serde::ser::SerializeMap::end(map)
851 }
852 }
853
854 impl ::codec::DeserializeValue for Tags {
855 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<Tags, D::Error> {
856 struct Visitor;
857
858 impl<'de> ::serde::de::Visitor<'de> for Visitor {
859 type Value = Tags;
860
861 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
862 write!(f, "a struct of type Tags")
863 }
864
865 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
866 let mut key: Option<::Value<String>> = None;
867 let mut value: Option<::Value<String>> = None;
868
869 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
870 match __cfn_key.as_ref() {
871 "Key" => {
872 key = ::serde::de::MapAccess::next_value(&mut map)?;
873 }
874 "Value" => {
875 value = ::serde::de::MapAccess::next_value(&mut map)?;
876 }
877 _ => {}
878 }
879 }
880
881 Ok(Tags {
882 key: key,
883 value: value,
884 })
885 }
886 }
887
888 d.deserialize_map(Visitor)
889 }
890 }
891}
892
893pub mod configuration_profile {
894 #[derive(Debug, Default)]
898 pub struct Tags {
899 pub key: Option<::Value<String>>,
904 pub value: Option<::Value<String>>,
909 }
910
911 impl ::codec::SerializeValue for Tags {
912 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
913 let mut map = ::serde::Serializer::serialize_map(s, None)?;
914 if let Some(ref key) = self.key {
915 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Key", key)?;
916 }
917 if let Some(ref value) = self.value {
918 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Value", value)?;
919 }
920 ::serde::ser::SerializeMap::end(map)
921 }
922 }
923
924 impl ::codec::DeserializeValue for Tags {
925 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<Tags, D::Error> {
926 struct Visitor;
927
928 impl<'de> ::serde::de::Visitor<'de> for Visitor {
929 type Value = Tags;
930
931 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
932 write!(f, "a struct of type Tags")
933 }
934
935 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
936 let mut key: Option<::Value<String>> = None;
937 let mut value: Option<::Value<String>> = None;
938
939 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
940 match __cfn_key.as_ref() {
941 "Key" => {
942 key = ::serde::de::MapAccess::next_value(&mut map)?;
943 }
944 "Value" => {
945 value = ::serde::de::MapAccess::next_value(&mut map)?;
946 }
947 _ => {}
948 }
949 }
950
951 Ok(Tags {
952 key: key,
953 value: value,
954 })
955 }
956 }
957
958 d.deserialize_map(Visitor)
959 }
960 }
961
962 #[derive(Debug, Default)]
964 pub struct Validators {
965 pub content: Option<::Value<String>>,
970 pub r#type: Option<::Value<String>>,
975 }
976
977 impl ::codec::SerializeValue for Validators {
978 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
979 let mut map = ::serde::Serializer::serialize_map(s, None)?;
980 if let Some(ref content) = self.content {
981 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Content", content)?;
982 }
983 if let Some(ref r#type) = self.r#type {
984 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Type", r#type)?;
985 }
986 ::serde::ser::SerializeMap::end(map)
987 }
988 }
989
990 impl ::codec::DeserializeValue for Validators {
991 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<Validators, D::Error> {
992 struct Visitor;
993
994 impl<'de> ::serde::de::Visitor<'de> for Visitor {
995 type Value = Validators;
996
997 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
998 write!(f, "a struct of type Validators")
999 }
1000
1001 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
1002 let mut content: Option<::Value<String>> = None;
1003 let mut r#type: Option<::Value<String>> = None;
1004
1005 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
1006 match __cfn_key.as_ref() {
1007 "Content" => {
1008 content = ::serde::de::MapAccess::next_value(&mut map)?;
1009 }
1010 "Type" => {
1011 r#type = ::serde::de::MapAccess::next_value(&mut map)?;
1012 }
1013 _ => {}
1014 }
1015 }
1016
1017 Ok(Validators {
1018 content: content,
1019 r#type: r#type,
1020 })
1021 }
1022 }
1023
1024 d.deserialize_map(Visitor)
1025 }
1026 }
1027}
1028
1029pub mod deployment {
1030 #[derive(Debug, Default)]
1034 pub struct Tags {
1035 pub key: Option<::Value<String>>,
1040 pub value: Option<::Value<String>>,
1045 }
1046
1047 impl ::codec::SerializeValue for Tags {
1048 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
1049 let mut map = ::serde::Serializer::serialize_map(s, None)?;
1050 if let Some(ref key) = self.key {
1051 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Key", key)?;
1052 }
1053 if let Some(ref value) = self.value {
1054 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Value", value)?;
1055 }
1056 ::serde::ser::SerializeMap::end(map)
1057 }
1058 }
1059
1060 impl ::codec::DeserializeValue for Tags {
1061 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<Tags, D::Error> {
1062 struct Visitor;
1063
1064 impl<'de> ::serde::de::Visitor<'de> for Visitor {
1065 type Value = Tags;
1066
1067 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1068 write!(f, "a struct of type Tags")
1069 }
1070
1071 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
1072 let mut key: Option<::Value<String>> = None;
1073 let mut value: Option<::Value<String>> = None;
1074
1075 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
1076 match __cfn_key.as_ref() {
1077 "Key" => {
1078 key = ::serde::de::MapAccess::next_value(&mut map)?;
1079 }
1080 "Value" => {
1081 value = ::serde::de::MapAccess::next_value(&mut map)?;
1082 }
1083 _ => {}
1084 }
1085 }
1086
1087 Ok(Tags {
1088 key: key,
1089 value: value,
1090 })
1091 }
1092 }
1093
1094 d.deserialize_map(Visitor)
1095 }
1096 }
1097}
1098
1099pub mod deployment_strategy {
1100 #[derive(Debug, Default)]
1104 pub struct Tags {
1105 pub key: Option<::Value<String>>,
1110 pub value: Option<::Value<String>>,
1115 }
1116
1117 impl ::codec::SerializeValue for Tags {
1118 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
1119 let mut map = ::serde::Serializer::serialize_map(s, None)?;
1120 if let Some(ref key) = self.key {
1121 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Key", key)?;
1122 }
1123 if let Some(ref value) = self.value {
1124 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Value", value)?;
1125 }
1126 ::serde::ser::SerializeMap::end(map)
1127 }
1128 }
1129
1130 impl ::codec::DeserializeValue for Tags {
1131 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<Tags, D::Error> {
1132 struct Visitor;
1133
1134 impl<'de> ::serde::de::Visitor<'de> for Visitor {
1135 type Value = Tags;
1136
1137 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1138 write!(f, "a struct of type Tags")
1139 }
1140
1141 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
1142 let mut key: Option<::Value<String>> = None;
1143 let mut value: Option<::Value<String>> = None;
1144
1145 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
1146 match __cfn_key.as_ref() {
1147 "Key" => {
1148 key = ::serde::de::MapAccess::next_value(&mut map)?;
1149 }
1150 "Value" => {
1151 value = ::serde::de::MapAccess::next_value(&mut map)?;
1152 }
1153 _ => {}
1154 }
1155 }
1156
1157 Ok(Tags {
1158 key: key,
1159 value: value,
1160 })
1161 }
1162 }
1163
1164 d.deserialize_map(Visitor)
1165 }
1166 }
1167}
1168
1169pub mod environment {
1170 #[derive(Debug, Default)]
1174 pub struct Monitors {
1175 pub alarm_arn: Option<::Value<String>>,
1180 pub alarm_role_arn: Option<::Value<String>>,
1185 }
1186
1187 impl ::codec::SerializeValue for Monitors {
1188 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
1189 let mut map = ::serde::Serializer::serialize_map(s, None)?;
1190 if let Some(ref alarm_arn) = self.alarm_arn {
1191 ::serde::ser::SerializeMap::serialize_entry(&mut map, "AlarmArn", alarm_arn)?;
1192 }
1193 if let Some(ref alarm_role_arn) = self.alarm_role_arn {
1194 ::serde::ser::SerializeMap::serialize_entry(&mut map, "AlarmRoleArn", alarm_role_arn)?;
1195 }
1196 ::serde::ser::SerializeMap::end(map)
1197 }
1198 }
1199
1200 impl ::codec::DeserializeValue for Monitors {
1201 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<Monitors, D::Error> {
1202 struct Visitor;
1203
1204 impl<'de> ::serde::de::Visitor<'de> for Visitor {
1205 type Value = Monitors;
1206
1207 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1208 write!(f, "a struct of type Monitors")
1209 }
1210
1211 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
1212 let mut alarm_arn: Option<::Value<String>> = None;
1213 let mut alarm_role_arn: Option<::Value<String>> = None;
1214
1215 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
1216 match __cfn_key.as_ref() {
1217 "AlarmArn" => {
1218 alarm_arn = ::serde::de::MapAccess::next_value(&mut map)?;
1219 }
1220 "AlarmRoleArn" => {
1221 alarm_role_arn = ::serde::de::MapAccess::next_value(&mut map)?;
1222 }
1223 _ => {}
1224 }
1225 }
1226
1227 Ok(Monitors {
1228 alarm_arn: alarm_arn,
1229 alarm_role_arn: alarm_role_arn,
1230 })
1231 }
1232 }
1233
1234 d.deserialize_map(Visitor)
1235 }
1236 }
1237
1238 #[derive(Debug, Default)]
1240 pub struct Tags {
1241 pub key: Option<::Value<String>>,
1246 pub value: Option<::Value<String>>,
1251 }
1252
1253 impl ::codec::SerializeValue for Tags {
1254 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
1255 let mut map = ::serde::Serializer::serialize_map(s, None)?;
1256 if let Some(ref key) = self.key {
1257 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Key", key)?;
1258 }
1259 if let Some(ref value) = self.value {
1260 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Value", value)?;
1261 }
1262 ::serde::ser::SerializeMap::end(map)
1263 }
1264 }
1265
1266 impl ::codec::DeserializeValue for Tags {
1267 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<Tags, D::Error> {
1268 struct Visitor;
1269
1270 impl<'de> ::serde::de::Visitor<'de> for Visitor {
1271 type Value = Tags;
1272
1273 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1274 write!(f, "a struct of type Tags")
1275 }
1276
1277 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
1278 let mut key: Option<::Value<String>> = None;
1279 let mut value: Option<::Value<String>> = None;
1280
1281 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
1282 match __cfn_key.as_ref() {
1283 "Key" => {
1284 key = ::serde::de::MapAccess::next_value(&mut map)?;
1285 }
1286 "Value" => {
1287 value = ::serde::de::MapAccess::next_value(&mut map)?;
1288 }
1289 _ => {}
1290 }
1291 }
1292
1293 Ok(Tags {
1294 key: key,
1295 value: value,
1296 })
1297 }
1298 }
1299
1300 d.deserialize_map(Visitor)
1301 }
1302 }
1303}