1#[derive(Debug, Default)]
5pub struct Assignment {
6 properties: AssignmentProperties
7}
8
9#[derive(Debug, Default)]
11pub struct AssignmentProperties {
12 pub instance_arn: ::Value<String>,
17 pub permission_set_arn: ::Value<String>,
22 pub principal_id: ::Value<String>,
27 pub principal_type: ::Value<String>,
32 pub target_id: ::Value<String>,
37 pub target_type: ::Value<String>,
42}
43
44impl ::serde::Serialize for AssignmentProperties {
45 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
46 let mut map = ::serde::Serializer::serialize_map(s, None)?;
47 ::serde::ser::SerializeMap::serialize_entry(&mut map, "InstanceArn", &self.instance_arn)?;
48 ::serde::ser::SerializeMap::serialize_entry(&mut map, "PermissionSetArn", &self.permission_set_arn)?;
49 ::serde::ser::SerializeMap::serialize_entry(&mut map, "PrincipalId", &self.principal_id)?;
50 ::serde::ser::SerializeMap::serialize_entry(&mut map, "PrincipalType", &self.principal_type)?;
51 ::serde::ser::SerializeMap::serialize_entry(&mut map, "TargetId", &self.target_id)?;
52 ::serde::ser::SerializeMap::serialize_entry(&mut map, "TargetType", &self.target_type)?;
53 ::serde::ser::SerializeMap::end(map)
54 }
55}
56
57impl<'de> ::serde::Deserialize<'de> for AssignmentProperties {
58 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<AssignmentProperties, D::Error> {
59 struct Visitor;
60
61 impl<'de> ::serde::de::Visitor<'de> for Visitor {
62 type Value = AssignmentProperties;
63
64 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
65 write!(f, "a struct of type AssignmentProperties")
66 }
67
68 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
69 let mut instance_arn: Option<::Value<String>> = None;
70 let mut permission_set_arn: Option<::Value<String>> = None;
71 let mut principal_id: Option<::Value<String>> = None;
72 let mut principal_type: Option<::Value<String>> = None;
73 let mut target_id: Option<::Value<String>> = None;
74 let mut target_type: Option<::Value<String>> = None;
75
76 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
77 match __cfn_key.as_ref() {
78 "InstanceArn" => {
79 instance_arn = ::serde::de::MapAccess::next_value(&mut map)?;
80 }
81 "PermissionSetArn" => {
82 permission_set_arn = ::serde::de::MapAccess::next_value(&mut map)?;
83 }
84 "PrincipalId" => {
85 principal_id = ::serde::de::MapAccess::next_value(&mut map)?;
86 }
87 "PrincipalType" => {
88 principal_type = ::serde::de::MapAccess::next_value(&mut map)?;
89 }
90 "TargetId" => {
91 target_id = ::serde::de::MapAccess::next_value(&mut map)?;
92 }
93 "TargetType" => {
94 target_type = ::serde::de::MapAccess::next_value(&mut map)?;
95 }
96 _ => {}
97 }
98 }
99
100 Ok(AssignmentProperties {
101 instance_arn: instance_arn.ok_or(::serde::de::Error::missing_field("InstanceArn"))?,
102 permission_set_arn: permission_set_arn.ok_or(::serde::de::Error::missing_field("PermissionSetArn"))?,
103 principal_id: principal_id.ok_or(::serde::de::Error::missing_field("PrincipalId"))?,
104 principal_type: principal_type.ok_or(::serde::de::Error::missing_field("PrincipalType"))?,
105 target_id: target_id.ok_or(::serde::de::Error::missing_field("TargetId"))?,
106 target_type: target_type.ok_or(::serde::de::Error::missing_field("TargetType"))?,
107 })
108 }
109 }
110
111 d.deserialize_map(Visitor)
112 }
113}
114
115impl ::Resource for Assignment {
116 type Properties = AssignmentProperties;
117 const TYPE: &'static str = "AWS::SSO::Assignment";
118 fn properties(&self) -> &AssignmentProperties {
119 &self.properties
120 }
121 fn properties_mut(&mut self) -> &mut AssignmentProperties {
122 &mut self.properties
123 }
124}
125
126impl ::private::Sealed for Assignment {}
127
128impl From<AssignmentProperties> for Assignment {
129 fn from(properties: AssignmentProperties) -> Assignment {
130 Assignment { properties }
131 }
132}
133
134#[derive(Debug, Default)]
136pub struct InstanceAccessControlAttributeConfiguration {
137 properties: InstanceAccessControlAttributeConfigurationProperties
138}
139
140#[derive(Debug, Default)]
142pub struct InstanceAccessControlAttributeConfigurationProperties {
143 pub access_control_attributes: Option<::ValueList<self::instance_access_control_attribute_configuration::AccessControlAttribute>>,
148 pub instance_arn: ::Value<String>,
153}
154
155impl ::serde::Serialize for InstanceAccessControlAttributeConfigurationProperties {
156 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
157 let mut map = ::serde::Serializer::serialize_map(s, None)?;
158 if let Some(ref access_control_attributes) = self.access_control_attributes {
159 ::serde::ser::SerializeMap::serialize_entry(&mut map, "AccessControlAttributes", access_control_attributes)?;
160 }
161 ::serde::ser::SerializeMap::serialize_entry(&mut map, "InstanceArn", &self.instance_arn)?;
162 ::serde::ser::SerializeMap::end(map)
163 }
164}
165
166impl<'de> ::serde::Deserialize<'de> for InstanceAccessControlAttributeConfigurationProperties {
167 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<InstanceAccessControlAttributeConfigurationProperties, D::Error> {
168 struct Visitor;
169
170 impl<'de> ::serde::de::Visitor<'de> for Visitor {
171 type Value = InstanceAccessControlAttributeConfigurationProperties;
172
173 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
174 write!(f, "a struct of type InstanceAccessControlAttributeConfigurationProperties")
175 }
176
177 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
178 let mut access_control_attributes: Option<::ValueList<self::instance_access_control_attribute_configuration::AccessControlAttribute>> = None;
179 let mut instance_arn: Option<::Value<String>> = None;
180
181 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
182 match __cfn_key.as_ref() {
183 "AccessControlAttributes" => {
184 access_control_attributes = ::serde::de::MapAccess::next_value(&mut map)?;
185 }
186 "InstanceArn" => {
187 instance_arn = ::serde::de::MapAccess::next_value(&mut map)?;
188 }
189 _ => {}
190 }
191 }
192
193 Ok(InstanceAccessControlAttributeConfigurationProperties {
194 access_control_attributes: access_control_attributes,
195 instance_arn: instance_arn.ok_or(::serde::de::Error::missing_field("InstanceArn"))?,
196 })
197 }
198 }
199
200 d.deserialize_map(Visitor)
201 }
202}
203
204impl ::Resource for InstanceAccessControlAttributeConfiguration {
205 type Properties = InstanceAccessControlAttributeConfigurationProperties;
206 const TYPE: &'static str = "AWS::SSO::InstanceAccessControlAttributeConfiguration";
207 fn properties(&self) -> &InstanceAccessControlAttributeConfigurationProperties {
208 &self.properties
209 }
210 fn properties_mut(&mut self) -> &mut InstanceAccessControlAttributeConfigurationProperties {
211 &mut self.properties
212 }
213}
214
215impl ::private::Sealed for InstanceAccessControlAttributeConfiguration {}
216
217impl From<InstanceAccessControlAttributeConfigurationProperties> for InstanceAccessControlAttributeConfiguration {
218 fn from(properties: InstanceAccessControlAttributeConfigurationProperties) -> InstanceAccessControlAttributeConfiguration {
219 InstanceAccessControlAttributeConfiguration { properties }
220 }
221}
222
223#[derive(Debug, Default)]
225pub struct PermissionSet {
226 properties: PermissionSetProperties
227}
228
229#[derive(Debug, Default)]
231pub struct PermissionSetProperties {
232 pub description: Option<::Value<String>>,
237 pub inline_policy: Option<::Value<::json::Value>>,
242 pub instance_arn: ::Value<String>,
247 pub managed_policies: Option<::ValueList<String>>,
252 pub name: ::Value<String>,
257 pub relay_state_type: Option<::Value<String>>,
262 pub session_duration: Option<::Value<String>>,
267 pub tags: Option<::ValueList<::Tag>>,
272}
273
274impl ::serde::Serialize for PermissionSetProperties {
275 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
276 let mut map = ::serde::Serializer::serialize_map(s, None)?;
277 if let Some(ref description) = self.description {
278 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Description", description)?;
279 }
280 if let Some(ref inline_policy) = self.inline_policy {
281 ::serde::ser::SerializeMap::serialize_entry(&mut map, "InlinePolicy", inline_policy)?;
282 }
283 ::serde::ser::SerializeMap::serialize_entry(&mut map, "InstanceArn", &self.instance_arn)?;
284 if let Some(ref managed_policies) = self.managed_policies {
285 ::serde::ser::SerializeMap::serialize_entry(&mut map, "ManagedPolicies", managed_policies)?;
286 }
287 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Name", &self.name)?;
288 if let Some(ref relay_state_type) = self.relay_state_type {
289 ::serde::ser::SerializeMap::serialize_entry(&mut map, "RelayStateType", relay_state_type)?;
290 }
291 if let Some(ref session_duration) = self.session_duration {
292 ::serde::ser::SerializeMap::serialize_entry(&mut map, "SessionDuration", session_duration)?;
293 }
294 if let Some(ref tags) = self.tags {
295 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Tags", tags)?;
296 }
297 ::serde::ser::SerializeMap::end(map)
298 }
299}
300
301impl<'de> ::serde::Deserialize<'de> for PermissionSetProperties {
302 fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<PermissionSetProperties, D::Error> {
303 struct Visitor;
304
305 impl<'de> ::serde::de::Visitor<'de> for Visitor {
306 type Value = PermissionSetProperties;
307
308 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
309 write!(f, "a struct of type PermissionSetProperties")
310 }
311
312 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
313 let mut description: Option<::Value<String>> = None;
314 let mut inline_policy: Option<::Value<::json::Value>> = None;
315 let mut instance_arn: Option<::Value<String>> = None;
316 let mut managed_policies: Option<::ValueList<String>> = None;
317 let mut name: Option<::Value<String>> = None;
318 let mut relay_state_type: Option<::Value<String>> = None;
319 let mut session_duration: Option<::Value<String>> = None;
320 let mut tags: Option<::ValueList<::Tag>> = None;
321
322 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
323 match __cfn_key.as_ref() {
324 "Description" => {
325 description = ::serde::de::MapAccess::next_value(&mut map)?;
326 }
327 "InlinePolicy" => {
328 inline_policy = ::serde::de::MapAccess::next_value(&mut map)?;
329 }
330 "InstanceArn" => {
331 instance_arn = ::serde::de::MapAccess::next_value(&mut map)?;
332 }
333 "ManagedPolicies" => {
334 managed_policies = ::serde::de::MapAccess::next_value(&mut map)?;
335 }
336 "Name" => {
337 name = ::serde::de::MapAccess::next_value(&mut map)?;
338 }
339 "RelayStateType" => {
340 relay_state_type = ::serde::de::MapAccess::next_value(&mut map)?;
341 }
342 "SessionDuration" => {
343 session_duration = ::serde::de::MapAccess::next_value(&mut map)?;
344 }
345 "Tags" => {
346 tags = ::serde::de::MapAccess::next_value(&mut map)?;
347 }
348 _ => {}
349 }
350 }
351
352 Ok(PermissionSetProperties {
353 description: description,
354 inline_policy: inline_policy,
355 instance_arn: instance_arn.ok_or(::serde::de::Error::missing_field("InstanceArn"))?,
356 managed_policies: managed_policies,
357 name: name.ok_or(::serde::de::Error::missing_field("Name"))?,
358 relay_state_type: relay_state_type,
359 session_duration: session_duration,
360 tags: tags,
361 })
362 }
363 }
364
365 d.deserialize_map(Visitor)
366 }
367}
368
369impl ::Resource for PermissionSet {
370 type Properties = PermissionSetProperties;
371 const TYPE: &'static str = "AWS::SSO::PermissionSet";
372 fn properties(&self) -> &PermissionSetProperties {
373 &self.properties
374 }
375 fn properties_mut(&mut self) -> &mut PermissionSetProperties {
376 &mut self.properties
377 }
378}
379
380impl ::private::Sealed for PermissionSet {}
381
382impl From<PermissionSetProperties> for PermissionSet {
383 fn from(properties: PermissionSetProperties) -> PermissionSet {
384 PermissionSet { properties }
385 }
386}
387
388pub mod instance_access_control_attribute_configuration {
389 #[derive(Debug, Default)]
393 pub struct AccessControlAttribute {
394 pub key: ::Value<String>,
399 pub value: ::Value<AccessControlAttributeValue>,
404 }
405
406 impl ::codec::SerializeValue for AccessControlAttribute {
407 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
408 let mut map = ::serde::Serializer::serialize_map(s, None)?;
409 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Key", &self.key)?;
410 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Value", &self.value)?;
411 ::serde::ser::SerializeMap::end(map)
412 }
413 }
414
415 impl ::codec::DeserializeValue for AccessControlAttribute {
416 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<AccessControlAttribute, D::Error> {
417 struct Visitor;
418
419 impl<'de> ::serde::de::Visitor<'de> for Visitor {
420 type Value = AccessControlAttribute;
421
422 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
423 write!(f, "a struct of type AccessControlAttribute")
424 }
425
426 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
427 let mut key: Option<::Value<String>> = None;
428 let mut value: Option<::Value<AccessControlAttributeValue>> = None;
429
430 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
431 match __cfn_key.as_ref() {
432 "Key" => {
433 key = ::serde::de::MapAccess::next_value(&mut map)?;
434 }
435 "Value" => {
436 value = ::serde::de::MapAccess::next_value(&mut map)?;
437 }
438 _ => {}
439 }
440 }
441
442 Ok(AccessControlAttribute {
443 key: key.ok_or(::serde::de::Error::missing_field("Key"))?,
444 value: value.ok_or(::serde::de::Error::missing_field("Value"))?,
445 })
446 }
447 }
448
449 d.deserialize_map(Visitor)
450 }
451 }
452
453 #[derive(Debug, Default)]
455 pub struct AccessControlAttributeValue {
456 pub source: ::ValueList<String>,
461 }
462
463 impl ::codec::SerializeValue for AccessControlAttributeValue {
464 fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
465 let mut map = ::serde::Serializer::serialize_map(s, None)?;
466 ::serde::ser::SerializeMap::serialize_entry(&mut map, "Source", &self.source)?;
467 ::serde::ser::SerializeMap::end(map)
468 }
469 }
470
471 impl ::codec::DeserializeValue for AccessControlAttributeValue {
472 fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<AccessControlAttributeValue, D::Error> {
473 struct Visitor;
474
475 impl<'de> ::serde::de::Visitor<'de> for Visitor {
476 type Value = AccessControlAttributeValue;
477
478 fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
479 write!(f, "a struct of type AccessControlAttributeValue")
480 }
481
482 fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
483 let mut source: Option<::ValueList<String>> = None;
484
485 while let Some(__cfn_key) = ::serde::de::MapAccess::next_key::<String>(&mut map)? {
486 match __cfn_key.as_ref() {
487 "Source" => {
488 source = ::serde::de::MapAccess::next_value(&mut map)?;
489 }
490 _ => {}
491 }
492 }
493
494 Ok(AccessControlAttributeValue {
495 source: source.ok_or(::serde::de::Error::missing_field("Source"))?,
496 })
497 }
498 }
499
500 d.deserialize_map(Visitor)
501 }
502 }
503}