1#[derive(Debug, Default)]
5pub struct Contact {
6 properties: ContactProperties
7}
8
9#[derive(Debug, Default)]
11pub struct ContactProperties {
12 pub alias: ::Value<String>,
17 pub display_name: ::Value<String>,
22 pub plan: ::ValueList<self::contact::Stage>,
27 pub r#type: ::Value<String>,
32}
33
34impl ::serde::Serialize for ContactProperties {
35 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
36 let mut map = ::serde::Serializer::serialize_map(s, None)?;
37 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Alias", &self.alias)?;
38 ::serde::ser::SerializeMap::serialize_entry(&mut map, "DisplayName", &self.display_name)?;
39 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Plan", &self.plan)?;
40 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Type", &self.r#type)?;
41 ::serde::ser::SerializeMap::end(map)
42 }
43}
44
45impl<'de> ::serde::Deserialize<'de> for ContactProperties {
46 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<ContactProperties, D::Error> {
47 struct Visitor;
48
49 impl<'de> ::serde::de::Visitor<'de> for Visitor {
50 type Value = ContactProperties;
51
52 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
53 write!(f, "a struct of type ContactProperties")
54 }
55
56 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
57 let mut alias: Option<::Value<String>> = None;
58 let mut display_name: Option<::Value<String>> = None;
59 let mut plan: Option<::ValueList<self::contact::Stage>> = None;
60 let mut r#type: Option<::Value<String>> = None;
61
62 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
63 match __cfn_key.as_ref() {
64 "Alias" => {
65 alias = ::serde::de::MapAccess::next_value(&mut map)?;
66 }
67 "DisplayName" => {
68 display_name = ::serde::de::MapAccess::next_value(&mut map)?;
69 }
70 "Plan" => {
71 plan = ::serde::de::MapAccess::next_value(&mut map)?;
72 }
73 "Type" => {
74 r#type = ::serde::de::MapAccess::next_value(&mut map)?;
75 }
76 _ => {}
77 }
78 }
79
80 Ok(ContactProperties {
81 alias: alias.ok_or(::serde::de::Error::missing_field("Alias"))?,
82 display_name: display_name.ok_or(::serde::de::Error::missing_field("DisplayName"))?,
83 plan: plan.ok_or(::serde::de::Error::missing_field("Plan"))?,
84 r#type: r#type.ok_or(::serde::de::Error::missing_field("Type"))?,
85 })
86 }
87 }
88
89 d.deserialize_map(Visitor)
90 }
91}
92
93impl ::Resource for Contact {
94 type Properties = ContactProperties;
95 const TYPE: &'static str = "AWS::SSMContacts::Contact";
96 fn properties(&self) -> &ContactProperties {
97 &self.properties
98 }
99 fn properties_mut(&mut self) -> &mut ContactProperties {
100 &mut self.properties
101 }
102}
103
104impl ::private::Sealed for Contact {}
105
106impl From<ContactProperties> for Contact {
107 fn from(properties: ContactProperties) -> Contact {
108 Contact { properties }
109 }
110}
111
112#[derive(Debug, Default)]
114pub struct ContactChannel {
115 properties: ContactChannelProperties
116}
117
118#[derive(Debug, Default)]
120pub struct ContactChannelProperties {
121 pub channel_address: ::Value<String>,
126 pub channel_name: ::Value<String>,
131 pub channel_type: ::Value<String>,
136 pub contact_id: ::Value<String>,
141 pub defer_activation: Option<::Value<bool>>,
146}
147
148impl ::serde::Serialize for ContactChannelProperties {
149 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
150 let mut map = ::serde::Serializer::serialize_map(s, None)?;
151 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ChannelAddress", &self.channel_address)?;
152 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ChannelName", &self.channel_name)?;
153 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ChannelType", &self.channel_type)?;
154 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ContactId", &self.contact_id)?;
155 if let Some(ref defer_activation) = self.defer_activation {
156 ::serde::ser::SerializeMap::serialize_entry(&mut map, "DeferActivation", defer_activation)?;
157 }
158 ::serde::ser::SerializeMap::end(map)
159 }
160}
161
162impl<'de> ::serde::Deserialize<'de> for ContactChannelProperties {
163 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<ContactChannelProperties, D::Error> {
164 struct Visitor;
165
166 impl<'de> ::serde::de::Visitor<'de> for Visitor {
167 type Value = ContactChannelProperties;
168
169 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
170 write!(f, "a struct of type ContactChannelProperties")
171 }
172
173 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
174 let mut channel_address: Option<::Value<String>> = None;
175 let mut channel_name: Option<::Value<String>> = None;
176 let mut channel_type: Option<::Value<String>> = None;
177 let mut contact_id: Option<::Value<String>> = None;
178 let mut defer_activation: Option<::Value<bool>> = None;
179
180 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
181 match __cfn_key.as_ref() {
182 "ChannelAddress" => {
183 channel_address = ::serde::de::MapAccess::next_value(&mut map)?;
184 }
185 "ChannelName" => {
186 channel_name = ::serde::de::MapAccess::next_value(&mut map)?;
187 }
188 "ChannelType" => {
189 channel_type = ::serde::de::MapAccess::next_value(&mut map)?;
190 }
191 "ContactId" => {
192 contact_id = ::serde::de::MapAccess::next_value(&mut map)?;
193 }
194 "DeferActivation" => {
195 defer_activation = ::serde::de::MapAccess::next_value(&mut map)?;
196 }
197 _ => {}
198 }
199 }
200
201 Ok(ContactChannelProperties {
202 channel_address: channel_address.ok_or(::serde::de::Error::missing_field("ChannelAddress"))?,
203 channel_name: channel_name.ok_or(::serde::de::Error::missing_field("ChannelName"))?,
204 channel_type: channel_type.ok_or(::serde::de::Error::missing_field("ChannelType"))?,
205 contact_id: contact_id.ok_or(::serde::de::Error::missing_field("ContactId"))?,
206 defer_activation: defer_activation,
207 })
208 }
209 }
210
211 d.deserialize_map(Visitor)
212 }
213}
214
215impl ::Resource for ContactChannel {
216 type Properties = ContactChannelProperties;
217 const TYPE: &'static str = "AWS::SSMContacts::ContactChannel";
218 fn properties(&self) -> &ContactChannelProperties {
219 &self.properties
220 }
221 fn properties_mut(&mut self) -> &mut ContactChannelProperties {
222 &mut self.properties
223 }
224}
225
226impl ::private::Sealed for ContactChannel {}
227
228impl From<ContactChannelProperties> for ContactChannel {
229 fn from(properties: ContactChannelProperties) -> ContactChannel {
230 ContactChannel { properties }
231 }
232}
233
234pub mod contact {
235 #[derive(Debug, Default)]
239 pub struct ChannelTargetInfo {
240 pub channel_id: ::Value<String>,
245 pub retry_interval_in_minutes: ::Value<u32>,
250 }
251
252 impl ::codec::SerializeValue for ChannelTargetInfo {
253 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
254 let mut map = ::serde::Serializer::serialize_map(s, None)?;
255 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ChannelId", &self.channel_id)?;
256 ::serde::ser::SerializeMap::serialize_entry(&mut map, "RetryIntervalInMinutes", &self.retry_interval_in_minutes)?;
257 ::serde::ser::SerializeMap::end(map)
258 }
259 }
260
261 impl ::codec::DeserializeValue for ChannelTargetInfo {
262 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<ChannelTargetInfo, D::Error> {
263 struct Visitor;
264
265 impl<'de> ::serde::de::Visitor<'de> for Visitor {
266 type Value = ChannelTargetInfo;
267
268 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
269 write!(f, "a struct of type ChannelTargetInfo")
270 }
271
272 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
273 let mut channel_id: Option<::Value<String>> = None;
274 let mut retry_interval_in_minutes: Option<::Value<u32>> = None;
275
276 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
277 match __cfn_key.as_ref() {
278 "ChannelId" => {
279 channel_id = ::serde::de::MapAccess::next_value(&mut map)?;
280 }
281 "RetryIntervalInMinutes" => {
282 retry_interval_in_minutes = ::serde::de::MapAccess::next_value(&mut map)?;
283 }
284 _ => {}
285 }
286 }
287
288 Ok(ChannelTargetInfo {
289 channel_id: channel_id.ok_or(::serde::de::Error::missing_field("ChannelId"))?,
290 retry_interval_in_minutes: retry_interval_in_minutes.ok_or(::serde::de::Error::missing_field("RetryIntervalInMinutes"))?,
291 })
292 }
293 }
294
295 d.deserialize_map(Visitor)
296 }
297 }
298
299 #[derive(Debug, Default)]
301 pub struct ContactTargetInfo {
302 pub contact_id: ::Value<String>,
307 pub is_essential: ::Value<bool>,
312 }
313
314 impl ::codec::SerializeValue for ContactTargetInfo {
315 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
316 let mut map = ::serde::Serializer::serialize_map(s, None)?;
317 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ContactId", &self.contact_id)?;
318 ::serde::ser::SerializeMap::serialize_entry(&mut map, "IsEssential", &self.is_essential)?;
319 ::serde::ser::SerializeMap::end(map)
320 }
321 }
322
323 impl ::codec::DeserializeValue for ContactTargetInfo {
324 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<ContactTargetInfo, D::Error> {
325 struct Visitor;
326
327 impl<'de> ::serde::de::Visitor<'de> for Visitor {
328 type Value = ContactTargetInfo;
329
330 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
331 write!(f, "a struct of type ContactTargetInfo")
332 }
333
334 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
335 let mut contact_id: Option<::Value<String>> = None;
336 let mut is_essential: Option<::Value<bool>> = None;
337
338 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
339 match __cfn_key.as_ref() {
340 "ContactId" => {
341 contact_id = ::serde::de::MapAccess::next_value(&mut map)?;
342 }
343 "IsEssential" => {
344 is_essential = ::serde::de::MapAccess::next_value(&mut map)?;
345 }
346 _ => {}
347 }
348 }
349
350 Ok(ContactTargetInfo {
351 contact_id: contact_id.ok_or(::serde::de::Error::missing_field("ContactId"))?,
352 is_essential: is_essential.ok_or(::serde::de::Error::missing_field("IsEssential"))?,
353 })
354 }
355 }
356
357 d.deserialize_map(Visitor)
358 }
359 }
360
361 #[derive(Debug, Default)]
363 pub struct Stage {
364 pub duration_in_minutes: ::Value<u32>,
369 pub targets: Option<::ValueList<Targets>>,
374 }
375
376 impl ::codec::SerializeValue for Stage {
377 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
378 let mut map = ::serde::Serializer::serialize_map(s, None)?;
379 ::serde::ser::SerializeMap::serialize_entry(&mut map, "DurationInMinutes", &self.duration_in_minutes)?;
380 if let Some(ref targets) = self.targets {
381 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Targets", targets)?;
382 }
383 ::serde::ser::SerializeMap::end(map)
384 }
385 }
386
387 impl ::codec::DeserializeValue for Stage {
388 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<Stage, D::Error> {
389 struct Visitor;
390
391 impl<'de> ::serde::de::Visitor<'de> for Visitor {
392 type Value = Stage;
393
394 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
395 write!(f, "a struct of type Stage")
396 }
397
398 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
399 let mut duration_in_minutes: Option<::Value<u32>> = None;
400 let mut targets: Option<::ValueList<Targets>> = None;
401
402 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
403 match __cfn_key.as_ref() {
404 "DurationInMinutes" => {
405 duration_in_minutes = ::serde::de::MapAccess::next_value(&mut map)?;
406 }
407 "Targets" => {
408 targets = ::serde::de::MapAccess::next_value(&mut map)?;
409 }
410 _ => {}
411 }
412 }
413
414 Ok(Stage {
415 duration_in_minutes: duration_in_minutes.ok_or(::serde::de::Error::missing_field("DurationInMinutes"))?,
416 targets: targets,
417 })
418 }
419 }
420
421 d.deserialize_map(Visitor)
422 }
423 }
424
425 #[derive(Debug, Default)]
427 pub struct Targets {
428 pub channel_target_info: Option<::Value<ChannelTargetInfo>>,
433 pub contact_target_info: Option<::Value<ContactTargetInfo>>,
438 }
439
440 impl ::codec::SerializeValue for Targets {
441 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
442 let mut map = ::serde::Serializer::serialize_map(s, None)?;
443 if let Some(ref channel_target_info) = self.channel_target_info {
444 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ChannelTargetInfo", channel_target_info)?;
445 }
446 if let Some(ref contact_target_info) = self.contact_target_info {
447 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ContactTargetInfo", contact_target_info)?;
448 }
449 ::serde::ser::SerializeMap::end(map)
450 }
451 }
452
453 impl ::codec::DeserializeValue for Targets {
454 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<Targets, D::Error> {
455 struct Visitor;
456
457 impl<'de> ::serde::de::Visitor<'de> for Visitor {
458 type Value = Targets;
459
460 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
461 write!(f, "a struct of type Targets")
462 }
463
464 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
465 let mut channel_target_info: Option<::Value<ChannelTargetInfo>> = None;
466 let mut contact_target_info: Option<::Value<ContactTargetInfo>> = None;
467
468 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
469 match __cfn_key.as_ref() {
470 "ChannelTargetInfo" => {
471 channel_target_info = ::serde::de::MapAccess::next_value(&mut map)?;
472 }
473 "ContactTargetInfo" => {
474 contact_target_info = ::serde::de::MapAccess::next_value(&mut map)?;
475 }
476 _ => {}
477 }
478 }
479
480 Ok(Targets {
481 channel_target_info: channel_target_info,
482 contact_target_info: contact_target_info,
483 })
484 }
485 }
486
487 d.deserialize_map(Visitor)
488 }
489 }
490}