1use serde::{Deserialize, Serialize};
4
5use crate::types::{ContextEntry, EntityType, PolicyUsageType, Tag, policyScopeType, statusType};
6
7#[derive(Debug, Clone, Default, Serialize, Deserialize)]
9#[serde(rename_all = "PascalCase")]
10pub struct AddRoleToInstanceProfileInput {
11 pub instance_profile_name: String,
12 pub role_name: String,
13}
14
15#[derive(Debug, Clone, Default, Serialize, Deserialize)]
17#[serde(rename_all = "PascalCase")]
18pub struct AddUserToGroupInput {
19 pub group_name: String,
20 pub user_name: String,
21}
22
23#[derive(Debug, Clone, Default, Serialize, Deserialize)]
25#[serde(rename_all = "PascalCase")]
26pub struct AttachGroupPolicyInput {
27 pub group_name: String,
28 pub policy_arn: String,
29}
30
31#[derive(Debug, Clone, Default, Serialize, Deserialize)]
33#[serde(rename_all = "PascalCase")]
34pub struct AttachRolePolicyInput {
35 pub policy_arn: String,
36 pub role_name: String,
37}
38
39#[derive(Debug, Clone, Default, Serialize, Deserialize)]
41#[serde(rename_all = "PascalCase")]
42pub struct AttachUserPolicyInput {
43 pub policy_arn: String,
44 pub user_name: String,
45}
46
47#[derive(Debug, Clone, Default, Serialize, Deserialize)]
49#[serde(rename_all = "PascalCase")]
50pub struct CreateAccessKeyInput {
51 #[serde(skip_serializing_if = "Option::is_none")]
52 pub user_name: Option<String>,
53}
54
55#[derive(Debug, Clone, Default, Serialize, Deserialize)]
57#[serde(rename_all = "PascalCase")]
58pub struct CreateGroupInput {
59 pub group_name: String,
60 #[serde(skip_serializing_if = "Option::is_none")]
61 pub path: Option<String>,
62}
63
64#[derive(Debug, Clone, Default, Serialize, Deserialize)]
66#[serde(rename_all = "PascalCase")]
67pub struct CreateInstanceProfileInput {
68 pub instance_profile_name: String,
69 #[serde(skip_serializing_if = "Option::is_none")]
70 pub path: Option<String>,
71 #[serde(default, skip_serializing_if = "Vec::is_empty")]
72 pub tags: Vec<Tag>,
73}
74
75#[derive(Debug, Clone, Default, Serialize, Deserialize)]
77#[serde(rename_all = "PascalCase")]
78pub struct CreatePolicyInput {
79 #[serde(skip_serializing_if = "Option::is_none")]
80 pub description: Option<String>,
81 #[serde(skip_serializing_if = "Option::is_none")]
82 pub path: Option<String>,
83 pub policy_document: String,
84 pub policy_name: String,
85 #[serde(default, skip_serializing_if = "Vec::is_empty")]
86 pub tags: Vec<Tag>,
87}
88
89#[derive(Debug, Clone, Default, Serialize, Deserialize)]
91#[serde(rename_all = "PascalCase")]
92pub struct CreatePolicyVersionInput {
93 pub policy_arn: String,
94 pub policy_document: String,
95 #[serde(skip_serializing_if = "Option::is_none")]
96 pub set_as_default: Option<bool>,
97}
98
99#[derive(Debug, Clone, Default, Serialize, Deserialize)]
101#[serde(rename_all = "PascalCase")]
102pub struct CreateRoleInput {
103 pub assume_role_policy_document: String,
104 #[serde(skip_serializing_if = "Option::is_none")]
105 pub description: Option<String>,
106 #[serde(skip_serializing_if = "Option::is_none")]
107 pub max_session_duration: Option<i32>,
108 #[serde(skip_serializing_if = "Option::is_none")]
109 pub path: Option<String>,
110 #[serde(skip_serializing_if = "Option::is_none")]
111 pub permissions_boundary: Option<String>,
112 pub role_name: String,
113 #[serde(default, skip_serializing_if = "Vec::is_empty")]
114 pub tags: Vec<Tag>,
115}
116
117#[derive(Debug, Clone, Default, Serialize, Deserialize)]
119#[serde(rename_all = "PascalCase")]
120pub struct CreateServiceLinkedRoleInput {
121 #[serde(rename = "AWSServiceName")]
122 pub aws_service_name: String,
123 #[serde(skip_serializing_if = "Option::is_none")]
124 pub custom_suffix: Option<String>,
125 #[serde(skip_serializing_if = "Option::is_none")]
126 pub description: Option<String>,
127}
128
129#[derive(Debug, Clone, Default, Serialize, Deserialize)]
131#[serde(rename_all = "PascalCase")]
132pub struct CreateUserInput {
133 #[serde(skip_serializing_if = "Option::is_none")]
134 pub path: Option<String>,
135 #[serde(skip_serializing_if = "Option::is_none")]
136 pub permissions_boundary: Option<String>,
137 #[serde(default, skip_serializing_if = "Vec::is_empty")]
138 pub tags: Vec<Tag>,
139 pub user_name: String,
140}
141
142#[derive(Debug, Clone, Default, Serialize, Deserialize)]
144#[serde(rename_all = "PascalCase")]
145pub struct DeleteAccessKeyInput {
146 pub access_key_id: String,
147 #[serde(skip_serializing_if = "Option::is_none")]
148 pub user_name: Option<String>,
149}
150
151#[derive(Debug, Clone, Default, Serialize, Deserialize)]
153#[serde(rename_all = "PascalCase")]
154pub struct DeleteGroupInput {
155 pub group_name: String,
156}
157
158#[derive(Debug, Clone, Default, Serialize, Deserialize)]
160#[serde(rename_all = "PascalCase")]
161pub struct DeleteGroupPolicyInput {
162 pub group_name: String,
163 pub policy_name: String,
164}
165
166#[derive(Debug, Clone, Default, Serialize, Deserialize)]
168#[serde(rename_all = "PascalCase")]
169pub struct DeleteInstanceProfileInput {
170 pub instance_profile_name: String,
171}
172
173#[derive(Debug, Clone, Default, Serialize, Deserialize)]
175#[serde(rename_all = "PascalCase")]
176pub struct DeletePolicyInput {
177 pub policy_arn: String,
178}
179
180#[derive(Debug, Clone, Default, Serialize, Deserialize)]
182#[serde(rename_all = "PascalCase")]
183pub struct DeletePolicyVersionInput {
184 pub policy_arn: String,
185 pub version_id: String,
186}
187
188#[derive(Debug, Clone, Default, Serialize, Deserialize)]
190#[serde(rename_all = "PascalCase")]
191pub struct DeleteRoleInput {
192 pub role_name: String,
193}
194
195#[derive(Debug, Clone, Default, Serialize, Deserialize)]
197#[serde(rename_all = "PascalCase")]
198pub struct DeleteRolePolicyInput {
199 pub policy_name: String,
200 pub role_name: String,
201}
202
203#[derive(Debug, Clone, Default, Serialize, Deserialize)]
205#[serde(rename_all = "PascalCase")]
206pub struct DeleteServiceLinkedRoleInput {
207 pub role_name: String,
208}
209
210#[derive(Debug, Clone, Default, Serialize, Deserialize)]
212#[serde(rename_all = "PascalCase")]
213pub struct DeleteUserInput {
214 pub user_name: String,
215}
216
217#[derive(Debug, Clone, Default, Serialize, Deserialize)]
219#[serde(rename_all = "PascalCase")]
220pub struct DeleteUserPolicyInput {
221 pub policy_name: String,
222 pub user_name: String,
223}
224
225#[derive(Debug, Clone, Default, Serialize, Deserialize)]
227#[serde(rename_all = "PascalCase")]
228pub struct DetachGroupPolicyInput {
229 pub group_name: String,
230 pub policy_arn: String,
231}
232
233#[derive(Debug, Clone, Default, Serialize, Deserialize)]
235#[serde(rename_all = "PascalCase")]
236pub struct DetachRolePolicyInput {
237 pub policy_arn: String,
238 pub role_name: String,
239}
240
241#[derive(Debug, Clone, Default, Serialize, Deserialize)]
243#[serde(rename_all = "PascalCase")]
244pub struct DetachUserPolicyInput {
245 pub policy_arn: String,
246 pub user_name: String,
247}
248
249#[derive(Debug, Clone, Default, Serialize, Deserialize)]
251#[serde(rename_all = "PascalCase")]
252pub struct GetAccessKeyLastUsedInput {
253 pub access_key_id: String,
254}
255
256#[derive(Debug, Clone, Default, Serialize, Deserialize)]
258#[serde(rename_all = "PascalCase")]
259pub struct GetAccountAuthorizationDetailsInput {
260 #[serde(default, skip_serializing_if = "Vec::is_empty")]
261 pub filter: Vec<EntityType>,
262 #[serde(skip_serializing_if = "Option::is_none")]
263 pub marker: Option<String>,
264 #[serde(skip_serializing_if = "Option::is_none")]
265 pub max_items: Option<i32>,
266}
267
268#[derive(Debug, Clone, Default, Serialize, Deserialize)]
270#[serde(rename_all = "PascalCase")]
271pub struct GetGroupInput {
272 pub group_name: String,
273 #[serde(skip_serializing_if = "Option::is_none")]
274 pub marker: Option<String>,
275 #[serde(skip_serializing_if = "Option::is_none")]
276 pub max_items: Option<i32>,
277}
278
279#[derive(Debug, Clone, Default, Serialize, Deserialize)]
281#[serde(rename_all = "PascalCase")]
282pub struct GetGroupPolicyInput {
283 pub group_name: String,
284 pub policy_name: String,
285}
286
287#[derive(Debug, Clone, Default, Serialize, Deserialize)]
289#[serde(rename_all = "PascalCase")]
290pub struct GetInstanceProfileInput {
291 pub instance_profile_name: String,
292}
293
294#[derive(Debug, Clone, Default, Serialize, Deserialize)]
296#[serde(rename_all = "PascalCase")]
297pub struct GetPolicyInput {
298 pub policy_arn: String,
299}
300
301#[derive(Debug, Clone, Default, Serialize, Deserialize)]
303#[serde(rename_all = "PascalCase")]
304pub struct GetPolicyVersionInput {
305 pub policy_arn: String,
306 pub version_id: String,
307}
308
309#[derive(Debug, Clone, Default, Serialize, Deserialize)]
311#[serde(rename_all = "PascalCase")]
312pub struct GetRoleInput {
313 pub role_name: String,
314}
315
316#[derive(Debug, Clone, Default, Serialize, Deserialize)]
318#[serde(rename_all = "PascalCase")]
319pub struct GetRolePolicyInput {
320 pub policy_name: String,
321 pub role_name: String,
322}
323
324#[derive(Debug, Clone, Default, Serialize, Deserialize)]
326#[serde(rename_all = "PascalCase")]
327pub struct GetServiceLinkedRoleDeletionStatusInput {
328 pub deletion_task_id: String,
329}
330
331#[derive(Debug, Clone, Default, Serialize, Deserialize)]
333#[serde(rename_all = "PascalCase")]
334pub struct GetUserInput {
335 #[serde(skip_serializing_if = "Option::is_none")]
336 pub user_name: Option<String>,
337}
338
339#[derive(Debug, Clone, Default, Serialize, Deserialize)]
341#[serde(rename_all = "PascalCase")]
342pub struct GetUserPolicyInput {
343 pub policy_name: String,
344 pub user_name: String,
345}
346
347#[derive(Debug, Clone, Default, Serialize, Deserialize)]
349#[serde(rename_all = "PascalCase")]
350pub struct ListAccessKeysInput {
351 #[serde(skip_serializing_if = "Option::is_none")]
352 pub marker: Option<String>,
353 #[serde(skip_serializing_if = "Option::is_none")]
354 pub max_items: Option<i32>,
355 #[serde(skip_serializing_if = "Option::is_none")]
356 pub user_name: Option<String>,
357}
358
359#[derive(Debug, Clone, Default, Serialize, Deserialize)]
361#[serde(rename_all = "PascalCase")]
362pub struct ListAttachedGroupPoliciesInput {
363 pub group_name: String,
364 #[serde(skip_serializing_if = "Option::is_none")]
365 pub marker: Option<String>,
366 #[serde(skip_serializing_if = "Option::is_none")]
367 pub max_items: Option<i32>,
368 #[serde(skip_serializing_if = "Option::is_none")]
369 pub path_prefix: Option<String>,
370}
371
372#[derive(Debug, Clone, Default, Serialize, Deserialize)]
374#[serde(rename_all = "PascalCase")]
375pub struct ListAttachedRolePoliciesInput {
376 #[serde(skip_serializing_if = "Option::is_none")]
377 pub marker: Option<String>,
378 #[serde(skip_serializing_if = "Option::is_none")]
379 pub max_items: Option<i32>,
380 #[serde(skip_serializing_if = "Option::is_none")]
381 pub path_prefix: Option<String>,
382 pub role_name: String,
383}
384
385#[derive(Debug, Clone, Default, Serialize, Deserialize)]
387#[serde(rename_all = "PascalCase")]
388pub struct ListAttachedUserPoliciesInput {
389 #[serde(skip_serializing_if = "Option::is_none")]
390 pub marker: Option<String>,
391 #[serde(skip_serializing_if = "Option::is_none")]
392 pub max_items: Option<i32>,
393 #[serde(skip_serializing_if = "Option::is_none")]
394 pub path_prefix: Option<String>,
395 pub user_name: String,
396}
397
398#[derive(Debug, Clone, Default, Serialize, Deserialize)]
400#[serde(rename_all = "PascalCase")]
401pub struct ListEntitiesForPolicyInput {
402 #[serde(skip_serializing_if = "Option::is_none")]
403 pub entity_filter: Option<EntityType>,
404 #[serde(skip_serializing_if = "Option::is_none")]
405 pub marker: Option<String>,
406 #[serde(skip_serializing_if = "Option::is_none")]
407 pub max_items: Option<i32>,
408 #[serde(skip_serializing_if = "Option::is_none")]
409 pub path_prefix: Option<String>,
410 pub policy_arn: String,
411 #[serde(skip_serializing_if = "Option::is_none")]
412 pub policy_usage_filter: Option<PolicyUsageType>,
413}
414
415#[derive(Debug, Clone, Default, Serialize, Deserialize)]
417#[serde(rename_all = "PascalCase")]
418pub struct ListGroupPoliciesInput {
419 pub group_name: String,
420 #[serde(skip_serializing_if = "Option::is_none")]
421 pub marker: Option<String>,
422 #[serde(skip_serializing_if = "Option::is_none")]
423 pub max_items: Option<i32>,
424}
425
426#[derive(Debug, Clone, Default, Serialize, Deserialize)]
428#[serde(rename_all = "PascalCase")]
429pub struct ListGroupsForUserInput {
430 #[serde(skip_serializing_if = "Option::is_none")]
431 pub marker: Option<String>,
432 #[serde(skip_serializing_if = "Option::is_none")]
433 pub max_items: Option<i32>,
434 pub user_name: String,
435}
436
437#[derive(Debug, Clone, Default, Serialize, Deserialize)]
439#[serde(rename_all = "PascalCase")]
440pub struct ListGroupsInput {
441 #[serde(skip_serializing_if = "Option::is_none")]
442 pub marker: Option<String>,
443 #[serde(skip_serializing_if = "Option::is_none")]
444 pub max_items: Option<i32>,
445 #[serde(skip_serializing_if = "Option::is_none")]
446 pub path_prefix: Option<String>,
447}
448
449#[derive(Debug, Clone, Default, Serialize, Deserialize)]
451#[serde(rename_all = "PascalCase")]
452pub struct ListInstanceProfilesForRoleInput {
453 #[serde(skip_serializing_if = "Option::is_none")]
454 pub marker: Option<String>,
455 #[serde(skip_serializing_if = "Option::is_none")]
456 pub max_items: Option<i32>,
457 pub role_name: String,
458}
459
460#[derive(Debug, Clone, Default, Serialize, Deserialize)]
462#[serde(rename_all = "PascalCase")]
463pub struct ListInstanceProfilesInput {
464 #[serde(skip_serializing_if = "Option::is_none")]
465 pub marker: Option<String>,
466 #[serde(skip_serializing_if = "Option::is_none")]
467 pub max_items: Option<i32>,
468 #[serde(skip_serializing_if = "Option::is_none")]
469 pub path_prefix: Option<String>,
470}
471
472#[derive(Debug, Clone, Default, Serialize, Deserialize)]
474#[serde(rename_all = "PascalCase")]
475pub struct ListPoliciesInput {
476 #[serde(skip_serializing_if = "Option::is_none")]
477 pub marker: Option<String>,
478 #[serde(skip_serializing_if = "Option::is_none")]
479 pub max_items: Option<i32>,
480 #[serde(skip_serializing_if = "Option::is_none")]
481 pub only_attached: Option<bool>,
482 #[serde(skip_serializing_if = "Option::is_none")]
483 pub path_prefix: Option<String>,
484 #[serde(skip_serializing_if = "Option::is_none")]
485 pub policy_usage_filter: Option<PolicyUsageType>,
486 #[serde(skip_serializing_if = "Option::is_none")]
487 pub scope: Option<policyScopeType>,
488}
489
490#[derive(Debug, Clone, Default, Serialize, Deserialize)]
492#[serde(rename_all = "PascalCase")]
493pub struct ListPolicyVersionsInput {
494 #[serde(skip_serializing_if = "Option::is_none")]
495 pub marker: Option<String>,
496 #[serde(skip_serializing_if = "Option::is_none")]
497 pub max_items: Option<i32>,
498 pub policy_arn: String,
499}
500
501#[derive(Debug, Clone, Default, Serialize, Deserialize)]
503#[serde(rename_all = "PascalCase")]
504pub struct ListRolePoliciesInput {
505 #[serde(skip_serializing_if = "Option::is_none")]
506 pub marker: Option<String>,
507 #[serde(skip_serializing_if = "Option::is_none")]
508 pub max_items: Option<i32>,
509 pub role_name: String,
510}
511
512#[derive(Debug, Clone, Default, Serialize, Deserialize)]
514#[serde(rename_all = "PascalCase")]
515pub struct ListRoleTagsInput {
516 #[serde(skip_serializing_if = "Option::is_none")]
517 pub marker: Option<String>,
518 #[serde(skip_serializing_if = "Option::is_none")]
519 pub max_items: Option<i32>,
520 pub role_name: String,
521}
522
523#[derive(Debug, Clone, Default, Serialize, Deserialize)]
525#[serde(rename_all = "PascalCase")]
526pub struct ListRolesInput {
527 #[serde(skip_serializing_if = "Option::is_none")]
528 pub marker: Option<String>,
529 #[serde(skip_serializing_if = "Option::is_none")]
530 pub max_items: Option<i32>,
531 #[serde(skip_serializing_if = "Option::is_none")]
532 pub path_prefix: Option<String>,
533}
534
535#[derive(Debug, Clone, Default, Serialize, Deserialize)]
537#[serde(rename_all = "PascalCase")]
538pub struct ListUserPoliciesInput {
539 #[serde(skip_serializing_if = "Option::is_none")]
540 pub marker: Option<String>,
541 #[serde(skip_serializing_if = "Option::is_none")]
542 pub max_items: Option<i32>,
543 pub user_name: String,
544}
545
546#[derive(Debug, Clone, Default, Serialize, Deserialize)]
548#[serde(rename_all = "PascalCase")]
549pub struct ListUserTagsInput {
550 #[serde(skip_serializing_if = "Option::is_none")]
551 pub marker: Option<String>,
552 #[serde(skip_serializing_if = "Option::is_none")]
553 pub max_items: Option<i32>,
554 pub user_name: String,
555}
556
557#[derive(Debug, Clone, Default, Serialize, Deserialize)]
559#[serde(rename_all = "PascalCase")]
560pub struct ListUsersInput {
561 #[serde(skip_serializing_if = "Option::is_none")]
562 pub marker: Option<String>,
563 #[serde(skip_serializing_if = "Option::is_none")]
564 pub max_items: Option<i32>,
565 #[serde(skip_serializing_if = "Option::is_none")]
566 pub path_prefix: Option<String>,
567}
568
569#[derive(Debug, Clone, Default, Serialize, Deserialize)]
571#[serde(rename_all = "PascalCase")]
572pub struct PutGroupPolicyInput {
573 pub group_name: String,
574 pub policy_document: String,
575 pub policy_name: String,
576}
577
578#[derive(Debug, Clone, Default, Serialize, Deserialize)]
580#[serde(rename_all = "PascalCase")]
581pub struct PutRolePolicyInput {
582 pub policy_document: String,
583 pub policy_name: String,
584 pub role_name: String,
585}
586
587#[derive(Debug, Clone, Default, Serialize, Deserialize)]
589#[serde(rename_all = "PascalCase")]
590pub struct PutUserPolicyInput {
591 pub policy_document: String,
592 pub policy_name: String,
593 pub user_name: String,
594}
595
596#[derive(Debug, Clone, Default, Serialize, Deserialize)]
598#[serde(rename_all = "PascalCase")]
599pub struct RemoveRoleFromInstanceProfileInput {
600 pub instance_profile_name: String,
601 pub role_name: String,
602}
603
604#[derive(Debug, Clone, Default, Serialize, Deserialize)]
606#[serde(rename_all = "PascalCase")]
607pub struct RemoveUserFromGroupInput {
608 pub group_name: String,
609 pub user_name: String,
610}
611
612#[derive(Debug, Clone, Default, Serialize, Deserialize)]
614#[serde(rename_all = "PascalCase")]
615pub struct SetDefaultPolicyVersionInput {
616 pub policy_arn: String,
617 pub version_id: String,
618}
619
620#[derive(Debug, Clone, Default, Serialize, Deserialize)]
622#[serde(rename_all = "PascalCase")]
623pub struct SimulateCustomPolicyInput {
624 #[serde(default, skip_serializing_if = "Vec::is_empty")]
625 pub action_names: Vec<String>,
626 #[serde(skip_serializing_if = "Option::is_none")]
627 pub caller_arn: Option<String>,
628 #[serde(default, skip_serializing_if = "Vec::is_empty")]
629 pub context_entries: Vec<ContextEntry>,
630 #[serde(skip_serializing_if = "Option::is_none")]
631 pub marker: Option<String>,
632 #[serde(skip_serializing_if = "Option::is_none")]
633 pub max_items: Option<i32>,
634 #[serde(default, skip_serializing_if = "Vec::is_empty")]
635 pub permissions_boundary_policy_input_list: Vec<String>,
636 #[serde(default, skip_serializing_if = "Vec::is_empty")]
637 pub policy_input_list: Vec<String>,
638 #[serde(default, skip_serializing_if = "Vec::is_empty")]
639 pub resource_arns: Vec<String>,
640 #[serde(skip_serializing_if = "Option::is_none")]
641 pub resource_handling_option: Option<String>,
642 #[serde(skip_serializing_if = "Option::is_none")]
643 pub resource_owner: Option<String>,
644 #[serde(skip_serializing_if = "Option::is_none")]
645 pub resource_policy: Option<String>,
646}
647
648#[derive(Debug, Clone, Default, Serialize, Deserialize)]
650#[serde(rename_all = "PascalCase")]
651pub struct SimulatePrincipalPolicyInput {
652 #[serde(default, skip_serializing_if = "Vec::is_empty")]
653 pub action_names: Vec<String>,
654 #[serde(skip_serializing_if = "Option::is_none")]
655 pub caller_arn: Option<String>,
656 #[serde(default, skip_serializing_if = "Vec::is_empty")]
657 pub context_entries: Vec<ContextEntry>,
658 #[serde(skip_serializing_if = "Option::is_none")]
659 pub marker: Option<String>,
660 #[serde(skip_serializing_if = "Option::is_none")]
661 pub max_items: Option<i32>,
662 #[serde(default, skip_serializing_if = "Vec::is_empty")]
663 pub permissions_boundary_policy_input_list: Vec<String>,
664 #[serde(default, skip_serializing_if = "Vec::is_empty")]
665 pub policy_input_list: Vec<String>,
666 pub policy_source_arn: String,
667 #[serde(default, skip_serializing_if = "Vec::is_empty")]
668 pub resource_arns: Vec<String>,
669 #[serde(skip_serializing_if = "Option::is_none")]
670 pub resource_handling_option: Option<String>,
671 #[serde(skip_serializing_if = "Option::is_none")]
672 pub resource_owner: Option<String>,
673 #[serde(skip_serializing_if = "Option::is_none")]
674 pub resource_policy: Option<String>,
675}
676
677#[derive(Debug, Clone, Default, Serialize, Deserialize)]
679#[serde(rename_all = "PascalCase")]
680pub struct TagRoleInput {
681 pub role_name: String,
682 #[serde(default, skip_serializing_if = "Vec::is_empty")]
683 pub tags: Vec<Tag>,
684}
685
686#[derive(Debug, Clone, Default, Serialize, Deserialize)]
688#[serde(rename_all = "PascalCase")]
689pub struct TagUserInput {
690 #[serde(default, skip_serializing_if = "Vec::is_empty")]
691 pub tags: Vec<Tag>,
692 pub user_name: String,
693}
694
695#[derive(Debug, Clone, Default, Serialize, Deserialize)]
697#[serde(rename_all = "PascalCase")]
698pub struct UntagRoleInput {
699 pub role_name: String,
700 #[serde(default, skip_serializing_if = "Vec::is_empty")]
701 pub tag_keys: Vec<String>,
702}
703
704#[derive(Debug, Clone, Default, Serialize, Deserialize)]
706#[serde(rename_all = "PascalCase")]
707pub struct UntagUserInput {
708 #[serde(default, skip_serializing_if = "Vec::is_empty")]
709 pub tag_keys: Vec<String>,
710 pub user_name: String,
711}
712
713#[derive(Debug, Clone, Default, Serialize, Deserialize)]
715#[serde(rename_all = "PascalCase")]
716pub struct UpdateAccessKeyInput {
717 pub access_key_id: String,
718 pub status: statusType,
719 #[serde(skip_serializing_if = "Option::is_none")]
720 pub user_name: Option<String>,
721}
722
723#[derive(Debug, Clone, Default, Serialize, Deserialize)]
725#[serde(rename_all = "PascalCase")]
726pub struct UpdateAssumeRolePolicyInput {
727 pub policy_document: String,
728 pub role_name: String,
729}
730
731#[derive(Debug, Clone, Default, Serialize, Deserialize)]
733#[serde(rename_all = "PascalCase")]
734pub struct UpdateGroupInput {
735 pub group_name: String,
736 #[serde(skip_serializing_if = "Option::is_none")]
737 pub new_group_name: Option<String>,
738 #[serde(skip_serializing_if = "Option::is_none")]
739 pub new_path: Option<String>,
740}
741
742#[derive(Debug, Clone, Default, Serialize, Deserialize)]
744#[serde(rename_all = "PascalCase")]
745pub struct UpdateRoleInput {
746 #[serde(skip_serializing_if = "Option::is_none")]
747 pub description: Option<String>,
748 #[serde(skip_serializing_if = "Option::is_none")]
749 pub max_session_duration: Option<i32>,
750 pub role_name: String,
751}
752
753#[derive(Debug, Clone, Default, Serialize, Deserialize)]
755#[serde(rename_all = "PascalCase")]
756pub struct UpdateUserInput {
757 #[serde(skip_serializing_if = "Option::is_none")]
758 pub new_path: Option<String>,
759 #[serde(skip_serializing_if = "Option::is_none")]
760 pub new_user_name: Option<String>,
761 pub user_name: String,
762}