1#[derive(Debug, Default)]
5pub struct ConnectionAlias {
6 properties: ConnectionAliasProperties
7}
8
9#[derive(Debug, Default)]
11pub struct ConnectionAliasProperties {
12 pub connection_string: ::Value<String>,
17 pub tags: Option<::ValueList<::Tag>>,
22}
23
24impl ::serde::Serialize for ConnectionAliasProperties {
25 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
26 let mut map = ::serde::Serializer::serialize_map(s, None)?;
27 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ConnectionString", &self.connection_string)?;
28 if let Some(ref tags) = self.tags {
29 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Tags", tags)?;
30 }
31 ::serde::ser::SerializeMap::end(map)
32 }
33}
34
35impl<'de> ::serde::Deserialize<'de> for ConnectionAliasProperties {
36 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<ConnectionAliasProperties, D::Error> {
37 struct Visitor;
38
39 impl<'de> ::serde::de::Visitor<'de> for Visitor {
40 type Value = ConnectionAliasProperties;
41
42 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
43 write!(f, "a struct of type ConnectionAliasProperties")
44 }
45
46 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
47 let mut connection_string: Option<::Value<String>> = None;
48 let mut tags: Option<::ValueList<::Tag>> = None;
49
50 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
51 match __cfn_key.as_ref() {
52 "ConnectionString" => {
53 connection_string = ::serde::de::MapAccess::next_value(&mut map)?;
54 }
55 "Tags" => {
56 tags = ::serde::de::MapAccess::next_value(&mut map)?;
57 }
58 _ => {}
59 }
60 }
61
62 Ok(ConnectionAliasProperties {
63 connection_string: connection_string.ok_or(::serde::de::Error::missing_field("ConnectionString"))?,
64 tags: tags,
65 })
66 }
67 }
68
69 d.deserialize_map(Visitor)
70 }
71}
72
73impl ::Resource for ConnectionAlias {
74 type Properties = ConnectionAliasProperties;
75 const TYPE: &'static str = "AWS::WorkSpaces::ConnectionAlias";
76 fn properties(&self) -> &ConnectionAliasProperties {
77 &self.properties
78 }
79 fn properties_mut(&mut self) -> &mut ConnectionAliasProperties {
80 &mut self.properties
81 }
82}
83
84impl ::private::Sealed for ConnectionAlias {}
85
86impl From<ConnectionAliasProperties> for ConnectionAlias {
87 fn from(properties: ConnectionAliasProperties) -> ConnectionAlias {
88 ConnectionAlias { properties }
89 }
90}
91
92#[derive(Debug, Default)]
94pub struct Workspace {
95 properties: WorkspaceProperties
96}
97
98#[derive(Debug, Default)]
100pub struct WorkspaceProperties {
101 pub bundle_id: ::Value<String>,
107 pub directory_id: ::Value<String>,
113 pub root_volume_encryption_enabled: Option<::Value<bool>>,
119 pub tags: Option<::ValueList<::Tag>>,
124 pub user_name: ::Value<String>,
129 pub user_volume_encryption_enabled: Option<::Value<bool>>,
135 pub volume_encryption_key: Option<::Value<String>>,
141 pub workspace_properties: Option<::Value<self::workspace::WorkspaceProperties>>,
146}
147
148impl ::serde::Serialize for WorkspaceProperties {
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, "BundleId", &self.bundle_id)?;
152 ::serde::ser::SerializeMap::serialize_entry(&mut map, "DirectoryId", &self.directory_id)?;
153 if let Some(ref root_volume_encryption_enabled) = self.root_volume_encryption_enabled {
154 ::serde::ser::SerializeMap::serialize_entry(&mut map, "RootVolumeEncryptionEnabled", root_volume_encryption_enabled)?;
155 }
156 if let Some(ref tags) = self.tags {
157 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Tags", tags)?;
158 }
159 ::serde::ser::SerializeMap::serialize_entry(&mut map, "UserName", &self.user_name)?;
160 if let Some(ref user_volume_encryption_enabled) = self.user_volume_encryption_enabled {
161 ::serde::ser::SerializeMap::serialize_entry(&mut map, "UserVolumeEncryptionEnabled", user_volume_encryption_enabled)?;
162 }
163 if let Some(ref volume_encryption_key) = self.volume_encryption_key {
164 ::serde::ser::SerializeMap::serialize_entry(&mut map, "VolumeEncryptionKey", volume_encryption_key)?;
165 }
166 if let Some(ref workspace_properties) = self.workspace_properties {
167 ::serde::ser::SerializeMap::serialize_entry(&mut map, "WorkspaceProperties", workspace_properties)?;
168 }
169 ::serde::ser::SerializeMap::end(map)
170 }
171}
172
173impl<'de> ::serde::Deserialize<'de> for WorkspaceProperties {
174 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<WorkspaceProperties, D::Error> {
175 struct Visitor;
176
177 impl<'de> ::serde::de::Visitor<'de> for Visitor {
178 type Value = WorkspaceProperties;
179
180 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
181 write!(f, "a struct of type WorkspaceProperties")
182 }
183
184 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
185 let mut bundle_id: Option<::Value<String>> = None;
186 let mut directory_id: Option<::Value<String>> = None;
187 let mut root_volume_encryption_enabled: Option<::Value<bool>> = None;
188 let mut tags: Option<::ValueList<::Tag>> = None;
189 let mut user_name: Option<::Value<String>> = None;
190 let mut user_volume_encryption_enabled: Option<::Value<bool>> = None;
191 let mut volume_encryption_key: Option<::Value<String>> = None;
192 let mut workspace_properties: Option<::Value<self::workspace::WorkspaceProperties>> = None;
193
194 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
195 match __cfn_key.as_ref() {
196 "BundleId" => {
197 bundle_id = ::serde::de::MapAccess::next_value(&mut map)?;
198 }
199 "DirectoryId" => {
200 directory_id = ::serde::de::MapAccess::next_value(&mut map)?;
201 }
202 "RootVolumeEncryptionEnabled" => {
203 root_volume_encryption_enabled = ::serde::de::MapAccess::next_value(&mut map)?;
204 }
205 "Tags" => {
206 tags = ::serde::de::MapAccess::next_value(&mut map)?;
207 }
208 "UserName" => {
209 user_name = ::serde::de::MapAccess::next_value(&mut map)?;
210 }
211 "UserVolumeEncryptionEnabled" => {
212 user_volume_encryption_enabled = ::serde::de::MapAccess::next_value(&mut map)?;
213 }
214 "VolumeEncryptionKey" => {
215 volume_encryption_key = ::serde::de::MapAccess::next_value(&mut map)?;
216 }
217 "WorkspaceProperties" => {
218 workspace_properties = ::serde::de::MapAccess::next_value(&mut map)?;
219 }
220 _ => {}
221 }
222 }
223
224 Ok(WorkspaceProperties {
225 bundle_id: bundle_id.ok_or(::serde::de::Error::missing_field("BundleId"))?,
226 directory_id: directory_id.ok_or(::serde::de::Error::missing_field("DirectoryId"))?,
227 root_volume_encryption_enabled: root_volume_encryption_enabled,
228 tags: tags,
229 user_name: user_name.ok_or(::serde::de::Error::missing_field("UserName"))?,
230 user_volume_encryption_enabled: user_volume_encryption_enabled,
231 volume_encryption_key: volume_encryption_key,
232 workspace_properties: workspace_properties,
233 })
234 }
235 }
236
237 d.deserialize_map(Visitor)
238 }
239}
240
241impl ::Resource for Workspace {
242 type Properties = WorkspaceProperties;
243 const TYPE: &'static str = "AWS::WorkSpaces::Workspace";
244 fn properties(&self) -> &WorkspaceProperties {
245 &self.properties
246 }
247 fn properties_mut(&mut self) -> &mut WorkspaceProperties {
248 &mut self.properties
249 }
250}
251
252impl ::private::Sealed for Workspace {}
253
254impl From<WorkspaceProperties> for Workspace {
255 fn from(properties: WorkspaceProperties) -> Workspace {
256 Workspace { properties }
257 }
258}
259
260pub mod connection_alias {
261 #[derive(Debug, Default)]
265 pub struct ConnectionAliasAssociation {
266 pub associated_account_id: Option<::Value<String>>,
271 pub association_status: Option<::Value<String>>,
276 pub connection_identifier: Option<::Value<String>>,
281 pub resource_id: Option<::Value<String>>,
286 }
287
288 impl ::codec::SerializeValue for ConnectionAliasAssociation {
289 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
290 let mut map = ::serde::Serializer::serialize_map(s, None)?;
291 if let Some(ref associated_account_id) = self.associated_account_id {
292 ::serde::ser::SerializeMap::serialize_entry(&mut map, "AssociatedAccountId", associated_account_id)?;
293 }
294 if let Some(ref association_status) = self.association_status {
295 ::serde::ser::SerializeMap::serialize_entry(&mut map, "AssociationStatus", association_status)?;
296 }
297 if let Some(ref connection_identifier) = self.connection_identifier {
298 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ConnectionIdentifier", connection_identifier)?;
299 }
300 if let Some(ref resource_id) = self.resource_id {
301 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ResourceId", resource_id)?;
302 }
303 ::serde::ser::SerializeMap::end(map)
304 }
305 }
306
307 impl ::codec::DeserializeValue for ConnectionAliasAssociation {
308 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<ConnectionAliasAssociation, D::Error> {
309 struct Visitor;
310
311 impl<'de> ::serde::de::Visitor<'de> for Visitor {
312 type Value = ConnectionAliasAssociation;
313
314 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
315 write!(f, "a struct of type ConnectionAliasAssociation")
316 }
317
318 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
319 let mut associated_account_id: Option<::Value<String>> = None;
320 let mut association_status: Option<::Value<String>> = None;
321 let mut connection_identifier: Option<::Value<String>> = None;
322 let mut resource_id: Option<::Value<String>> = None;
323
324 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
325 match __cfn_key.as_ref() {
326 "AssociatedAccountId" => {
327 associated_account_id = ::serde::de::MapAccess::next_value(&mut map)?;
328 }
329 "AssociationStatus" => {
330 association_status = ::serde::de::MapAccess::next_value(&mut map)?;
331 }
332 "ConnectionIdentifier" => {
333 connection_identifier = ::serde::de::MapAccess::next_value(&mut map)?;
334 }
335 "ResourceId" => {
336 resource_id = ::serde::de::MapAccess::next_value(&mut map)?;
337 }
338 _ => {}
339 }
340 }
341
342 Ok(ConnectionAliasAssociation {
343 associated_account_id: associated_account_id,
344 association_status: association_status,
345 connection_identifier: connection_identifier,
346 resource_id: resource_id,
347 })
348 }
349 }
350
351 d.deserialize_map(Visitor)
352 }
353 }
354}
355
356pub mod workspace {
357 #[derive(Debug, Default)]
361 pub struct WorkspaceProperties {
362 pub compute_type_name: Option<::Value<String>>,
367 pub root_volume_size_gib: Option<::Value<u32>>,
372 pub running_mode: Option<::Value<String>>,
377 pub running_mode_auto_stop_timeout_in_minutes: Option<::Value<u32>>,
382 pub user_volume_size_gib: Option<::Value<u32>>,
387 }
388
389 impl ::codec::SerializeValue for WorkspaceProperties {
390 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
391 let mut map = ::serde::Serializer::serialize_map(s, None)?;
392 if let Some(ref compute_type_name) = self.compute_type_name {
393 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ComputeTypeName", compute_type_name)?;
394 }
395 if let Some(ref root_volume_size_gib) = self.root_volume_size_gib {
396 ::serde::ser::SerializeMap::serialize_entry(&mut map, "RootVolumeSizeGib", root_volume_size_gib)?;
397 }
398 if let Some(ref running_mode) = self.running_mode {
399 ::serde::ser::SerializeMap::serialize_entry(&mut map, "RunningMode", running_mode)?;
400 }
401 if let Some(ref running_mode_auto_stop_timeout_in_minutes) = self.running_mode_auto_stop_timeout_in_minutes {
402 ::serde::ser::SerializeMap::serialize_entry(&mut map, "RunningModeAutoStopTimeoutInMinutes", running_mode_auto_stop_timeout_in_minutes)?;
403 }
404 if let Some(ref user_volume_size_gib) = self.user_volume_size_gib {
405 ::serde::ser::SerializeMap::serialize_entry(&mut map, "UserVolumeSizeGib", user_volume_size_gib)?;
406 }
407 ::serde::ser::SerializeMap::end(map)
408 }
409 }
410
411 impl ::codec::DeserializeValue for WorkspaceProperties {
412 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<WorkspaceProperties, D::Error> {
413 struct Visitor;
414
415 impl<'de> ::serde::de::Visitor<'de> for Visitor {
416 type Value = WorkspaceProperties;
417
418 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
419 write!(f, "a struct of type WorkspaceProperties")
420 }
421
422 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
423 let mut compute_type_name: Option<::Value<String>> = None;
424 let mut root_volume_size_gib: Option<::Value<u32>> = None;
425 let mut running_mode: Option<::Value<String>> = None;
426 let mut running_mode_auto_stop_timeout_in_minutes: Option<::Value<u32>> = None;
427 let mut user_volume_size_gib: Option<::Value<u32>> = None;
428
429 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
430 match __cfn_key.as_ref() {
431 "ComputeTypeName" => {
432 compute_type_name = ::serde::de::MapAccess::next_value(&mut map)?;
433 }
434 "RootVolumeSizeGib" => {
435 root_volume_size_gib = ::serde::de::MapAccess::next_value(&mut map)?;
436 }
437 "RunningMode" => {
438 running_mode = ::serde::de::MapAccess::next_value(&mut map)?;
439 }
440 "RunningModeAutoStopTimeoutInMinutes" => {
441 running_mode_auto_stop_timeout_in_minutes = ::serde::de::MapAccess::next_value(&mut map)?;
442 }
443 "UserVolumeSizeGib" => {
444 user_volume_size_gib = ::serde::de::MapAccess::next_value(&mut map)?;
445 }
446 _ => {}
447 }
448 }
449
450 Ok(WorkspaceProperties {
451 compute_type_name: compute_type_name,
452 root_volume_size_gib: root_volume_size_gib,
453 running_mode: running_mode,
454 running_mode_auto_stop_timeout_in_minutes: running_mode_auto_stop_timeout_in_minutes,
455 user_volume_size_gib: user_volume_size_gib,
456 })
457 }
458 }
459
460 d.deserialize_map(Visitor)
461 }
462 }
463}