1use serde::{Deserialize, Serialize};
4
5use crate::types::{
6 AccessKey, AccessKeyLastUsed, AccessKeyMetadata, AttachedPolicy, DeletionTaskFailureReasonType,
7 DeletionTaskStatusType, EvaluationResult, Group, GroupDetail, InstanceProfile,
8 ManagedPolicyDetail, Policy, PolicyGroup, PolicyRole, PolicyUser, PolicyVersion, Role,
9 RoleDetail, Tag, User, UserDetail,
10};
11
12#[derive(Debug, Clone, Default, Serialize, Deserialize)]
14#[serde(rename_all = "PascalCase")]
15pub struct CreateAccessKeyResponse {
16 pub access_key: AccessKey,
17}
18
19#[derive(Debug, Clone, Default, Serialize, Deserialize)]
21#[serde(rename_all = "PascalCase")]
22pub struct CreateGroupResponse {
23 pub group: Group,
24}
25
26#[derive(Debug, Clone, Default, Serialize, Deserialize)]
28#[serde(rename_all = "PascalCase")]
29pub struct CreateInstanceProfileResponse {
30 pub instance_profile: InstanceProfile,
31}
32
33#[derive(Debug, Clone, Default, Serialize, Deserialize)]
35#[serde(rename_all = "PascalCase")]
36pub struct CreatePolicyResponse {
37 #[serde(skip_serializing_if = "Option::is_none")]
38 pub policy: Option<Policy>,
39}
40
41#[derive(Debug, Clone, Default, Serialize, Deserialize)]
43#[serde(rename_all = "PascalCase")]
44pub struct CreatePolicyVersionResponse {
45 #[serde(skip_serializing_if = "Option::is_none")]
46 pub policy_version: Option<PolicyVersion>,
47}
48
49#[derive(Debug, Clone, Default, Serialize, Deserialize)]
51#[serde(rename_all = "PascalCase")]
52pub struct CreateRoleResponse {
53 pub role: Role,
54}
55
56#[derive(Debug, Clone, Default, Serialize, Deserialize)]
58#[serde(rename_all = "PascalCase")]
59pub struct CreateServiceLinkedRoleResponse {
60 #[serde(skip_serializing_if = "Option::is_none")]
61 pub role: Option<Role>,
62}
63
64#[derive(Debug, Clone, Default, Serialize, Deserialize)]
66#[serde(rename_all = "PascalCase")]
67pub struct CreateUserResponse {
68 #[serde(skip_serializing_if = "Option::is_none")]
69 pub user: Option<User>,
70}
71
72#[derive(Debug, Clone, Default, Serialize, Deserialize)]
74#[serde(rename_all = "PascalCase")]
75pub struct DeleteServiceLinkedRoleResponse {
76 pub deletion_task_id: String,
77}
78
79#[derive(Debug, Clone, Default, Serialize, Deserialize)]
81#[serde(rename_all = "PascalCase")]
82pub struct GetAccessKeyLastUsedResponse {
83 #[serde(skip_serializing_if = "Option::is_none")]
84 pub access_key_last_used: Option<AccessKeyLastUsed>,
85 #[serde(skip_serializing_if = "Option::is_none")]
86 pub user_name: Option<String>,
87}
88
89#[derive(Debug, Clone, Default, Serialize, Deserialize)]
91#[serde(rename_all = "PascalCase")]
92pub struct GetAccountAuthorizationDetailsResponse {
93 #[serde(default, skip_serializing_if = "Vec::is_empty")]
94 pub group_detail_list: Vec<GroupDetail>,
95 #[serde(skip_serializing_if = "Option::is_none")]
96 pub is_truncated: Option<bool>,
97 #[serde(skip_serializing_if = "Option::is_none")]
98 pub marker: Option<String>,
99 #[serde(default, skip_serializing_if = "Vec::is_empty")]
100 pub policies: Vec<ManagedPolicyDetail>,
101 #[serde(default, skip_serializing_if = "Vec::is_empty")]
102 pub role_detail_list: Vec<RoleDetail>,
103 #[serde(default, skip_serializing_if = "Vec::is_empty")]
104 pub user_detail_list: Vec<UserDetail>,
105}
106
107#[derive(Debug, Clone, Default, Serialize, Deserialize)]
109#[serde(rename_all = "PascalCase")]
110pub struct GetGroupPolicyResponse {
111 pub group_name: String,
112 pub policy_document: String,
113 pub policy_name: String,
114}
115
116#[derive(Debug, Clone, Default, Serialize, Deserialize)]
118#[serde(rename_all = "PascalCase")]
119pub struct GetGroupResponse {
120 pub group: Group,
121 #[serde(skip_serializing_if = "Option::is_none")]
122 pub is_truncated: Option<bool>,
123 #[serde(skip_serializing_if = "Option::is_none")]
124 pub marker: Option<String>,
125 #[serde(default, skip_serializing_if = "Vec::is_empty")]
126 pub users: Vec<User>,
127}
128
129#[derive(Debug, Clone, Default, Serialize, Deserialize)]
131#[serde(rename_all = "PascalCase")]
132pub struct GetInstanceProfileResponse {
133 pub instance_profile: InstanceProfile,
134}
135
136#[derive(Debug, Clone, Default, Serialize, Deserialize)]
138#[serde(rename_all = "PascalCase")]
139pub struct GetPolicyResponse {
140 #[serde(skip_serializing_if = "Option::is_none")]
141 pub policy: Option<Policy>,
142}
143
144#[derive(Debug, Clone, Default, Serialize, Deserialize)]
146#[serde(rename_all = "PascalCase")]
147pub struct GetPolicyVersionResponse {
148 #[serde(skip_serializing_if = "Option::is_none")]
149 pub policy_version: Option<PolicyVersion>,
150}
151
152#[derive(Debug, Clone, Default, Serialize, Deserialize)]
154#[serde(rename_all = "PascalCase")]
155pub struct GetRolePolicyResponse {
156 pub policy_document: String,
157 pub policy_name: String,
158 pub role_name: String,
159}
160
161#[derive(Debug, Clone, Default, Serialize, Deserialize)]
163#[serde(rename_all = "PascalCase")]
164pub struct GetRoleResponse {
165 pub role: Role,
166}
167
168#[derive(Debug, Clone, Default, Serialize, Deserialize)]
170#[serde(rename_all = "PascalCase")]
171pub struct GetServiceLinkedRoleDeletionStatusResponse {
172 #[serde(skip_serializing_if = "Option::is_none")]
173 pub reason: Option<DeletionTaskFailureReasonType>,
174 pub status: DeletionTaskStatusType,
175}
176
177#[derive(Debug, Clone, Default, Serialize, Deserialize)]
179#[serde(rename_all = "PascalCase")]
180pub struct GetUserPolicyResponse {
181 pub policy_document: String,
182 pub policy_name: String,
183 pub user_name: String,
184}
185
186#[derive(Debug, Clone, Default, Serialize, Deserialize)]
188#[serde(rename_all = "PascalCase")]
189pub struct GetUserResponse {
190 pub user: User,
191}
192
193#[derive(Debug, Clone, Default, Serialize, Deserialize)]
195#[serde(rename_all = "PascalCase")]
196pub struct ListAccessKeysResponse {
197 #[serde(default, skip_serializing_if = "Vec::is_empty")]
198 pub access_key_metadata: Vec<AccessKeyMetadata>,
199 #[serde(skip_serializing_if = "Option::is_none")]
200 pub is_truncated: Option<bool>,
201 #[serde(skip_serializing_if = "Option::is_none")]
202 pub marker: Option<String>,
203}
204
205#[derive(Debug, Clone, Default, Serialize, Deserialize)]
207#[serde(rename_all = "PascalCase")]
208pub struct ListAttachedGroupPoliciesResponse {
209 #[serde(default, skip_serializing_if = "Vec::is_empty")]
210 pub attached_policies: Vec<AttachedPolicy>,
211 #[serde(skip_serializing_if = "Option::is_none")]
212 pub is_truncated: Option<bool>,
213 #[serde(skip_serializing_if = "Option::is_none")]
214 pub marker: Option<String>,
215}
216
217#[derive(Debug, Clone, Default, Serialize, Deserialize)]
219#[serde(rename_all = "PascalCase")]
220pub struct ListAttachedRolePoliciesResponse {
221 #[serde(default, skip_serializing_if = "Vec::is_empty")]
222 pub attached_policies: Vec<AttachedPolicy>,
223 #[serde(skip_serializing_if = "Option::is_none")]
224 pub is_truncated: Option<bool>,
225 #[serde(skip_serializing_if = "Option::is_none")]
226 pub marker: Option<String>,
227}
228
229#[derive(Debug, Clone, Default, Serialize, Deserialize)]
231#[serde(rename_all = "PascalCase")]
232pub struct ListAttachedUserPoliciesResponse {
233 #[serde(default, skip_serializing_if = "Vec::is_empty")]
234 pub attached_policies: Vec<AttachedPolicy>,
235 #[serde(skip_serializing_if = "Option::is_none")]
236 pub is_truncated: Option<bool>,
237 #[serde(skip_serializing_if = "Option::is_none")]
238 pub marker: Option<String>,
239}
240
241#[derive(Debug, Clone, Default, Serialize, Deserialize)]
243#[serde(rename_all = "PascalCase")]
244pub struct ListEntitiesForPolicyResponse {
245 #[serde(skip_serializing_if = "Option::is_none")]
246 pub is_truncated: Option<bool>,
247 #[serde(skip_serializing_if = "Option::is_none")]
248 pub marker: Option<String>,
249 #[serde(default, skip_serializing_if = "Vec::is_empty")]
250 pub policy_groups: Vec<PolicyGroup>,
251 #[serde(default, skip_serializing_if = "Vec::is_empty")]
252 pub policy_roles: Vec<PolicyRole>,
253 #[serde(default, skip_serializing_if = "Vec::is_empty")]
254 pub policy_users: Vec<PolicyUser>,
255}
256
257#[derive(Debug, Clone, Default, Serialize, Deserialize)]
259#[serde(rename_all = "PascalCase")]
260pub struct ListGroupPoliciesResponse {
261 #[serde(skip_serializing_if = "Option::is_none")]
262 pub is_truncated: Option<bool>,
263 #[serde(skip_serializing_if = "Option::is_none")]
264 pub marker: Option<String>,
265 #[serde(default, skip_serializing_if = "Vec::is_empty")]
266 pub policy_names: Vec<String>,
267}
268
269#[derive(Debug, Clone, Default, Serialize, Deserialize)]
271#[serde(rename_all = "PascalCase")]
272pub struct ListGroupsForUserResponse {
273 #[serde(default, skip_serializing_if = "Vec::is_empty")]
274 pub groups: Vec<Group>,
275 #[serde(skip_serializing_if = "Option::is_none")]
276 pub is_truncated: Option<bool>,
277 #[serde(skip_serializing_if = "Option::is_none")]
278 pub marker: Option<String>,
279}
280
281#[derive(Debug, Clone, Default, Serialize, Deserialize)]
283#[serde(rename_all = "PascalCase")]
284pub struct ListGroupsResponse {
285 #[serde(default, skip_serializing_if = "Vec::is_empty")]
286 pub groups: Vec<Group>,
287 #[serde(skip_serializing_if = "Option::is_none")]
288 pub is_truncated: Option<bool>,
289 #[serde(skip_serializing_if = "Option::is_none")]
290 pub marker: Option<String>,
291}
292
293#[derive(Debug, Clone, Default, Serialize, Deserialize)]
295#[serde(rename_all = "PascalCase")]
296pub struct ListInstanceProfilesForRoleResponse {
297 #[serde(default, skip_serializing_if = "Vec::is_empty")]
298 pub instance_profiles: Vec<InstanceProfile>,
299 #[serde(skip_serializing_if = "Option::is_none")]
300 pub is_truncated: Option<bool>,
301 #[serde(skip_serializing_if = "Option::is_none")]
302 pub marker: Option<String>,
303}
304
305#[derive(Debug, Clone, Default, Serialize, Deserialize)]
307#[serde(rename_all = "PascalCase")]
308pub struct ListInstanceProfilesResponse {
309 #[serde(default, skip_serializing_if = "Vec::is_empty")]
310 pub instance_profiles: Vec<InstanceProfile>,
311 #[serde(skip_serializing_if = "Option::is_none")]
312 pub is_truncated: Option<bool>,
313 #[serde(skip_serializing_if = "Option::is_none")]
314 pub marker: Option<String>,
315}
316
317#[derive(Debug, Clone, Default, Serialize, Deserialize)]
319#[serde(rename_all = "PascalCase")]
320pub struct ListPoliciesResponse {
321 #[serde(skip_serializing_if = "Option::is_none")]
322 pub is_truncated: Option<bool>,
323 #[serde(skip_serializing_if = "Option::is_none")]
324 pub marker: Option<String>,
325 #[serde(default, skip_serializing_if = "Vec::is_empty")]
326 pub policies: Vec<Policy>,
327}
328
329#[derive(Debug, Clone, Default, Serialize, Deserialize)]
331#[serde(rename_all = "PascalCase")]
332pub struct ListPolicyVersionsResponse {
333 #[serde(skip_serializing_if = "Option::is_none")]
334 pub is_truncated: Option<bool>,
335 #[serde(skip_serializing_if = "Option::is_none")]
336 pub marker: Option<String>,
337 #[serde(default, skip_serializing_if = "Vec::is_empty")]
338 pub versions: Vec<PolicyVersion>,
339}
340
341#[derive(Debug, Clone, Default, Serialize, Deserialize)]
343#[serde(rename_all = "PascalCase")]
344pub struct ListRolePoliciesResponse {
345 #[serde(skip_serializing_if = "Option::is_none")]
346 pub is_truncated: Option<bool>,
347 #[serde(skip_serializing_if = "Option::is_none")]
348 pub marker: Option<String>,
349 #[serde(default, skip_serializing_if = "Vec::is_empty")]
350 pub policy_names: Vec<String>,
351}
352
353#[derive(Debug, Clone, Default, Serialize, Deserialize)]
355#[serde(rename_all = "PascalCase")]
356pub struct ListRoleTagsResponse {
357 #[serde(skip_serializing_if = "Option::is_none")]
358 pub is_truncated: Option<bool>,
359 #[serde(skip_serializing_if = "Option::is_none")]
360 pub marker: Option<String>,
361 #[serde(default, skip_serializing_if = "Vec::is_empty")]
362 pub tags: Vec<Tag>,
363}
364
365#[derive(Debug, Clone, Default, Serialize, Deserialize)]
367#[serde(rename_all = "PascalCase")]
368pub struct ListRolesResponse {
369 #[serde(skip_serializing_if = "Option::is_none")]
370 pub is_truncated: Option<bool>,
371 #[serde(skip_serializing_if = "Option::is_none")]
372 pub marker: Option<String>,
373 #[serde(default, skip_serializing_if = "Vec::is_empty")]
374 pub roles: Vec<Role>,
375}
376
377#[derive(Debug, Clone, Default, Serialize, Deserialize)]
379#[serde(rename_all = "PascalCase")]
380pub struct ListUserPoliciesResponse {
381 #[serde(skip_serializing_if = "Option::is_none")]
382 pub is_truncated: Option<bool>,
383 #[serde(skip_serializing_if = "Option::is_none")]
384 pub marker: Option<String>,
385 #[serde(default, skip_serializing_if = "Vec::is_empty")]
386 pub policy_names: Vec<String>,
387}
388
389#[derive(Debug, Clone, Default, Serialize, Deserialize)]
391#[serde(rename_all = "PascalCase")]
392pub struct ListUserTagsResponse {
393 #[serde(skip_serializing_if = "Option::is_none")]
394 pub is_truncated: Option<bool>,
395 #[serde(skip_serializing_if = "Option::is_none")]
396 pub marker: Option<String>,
397 #[serde(default, skip_serializing_if = "Vec::is_empty")]
398 pub tags: Vec<Tag>,
399}
400
401#[derive(Debug, Clone, Default, Serialize, Deserialize)]
403#[serde(rename_all = "PascalCase")]
404pub struct ListUsersResponse {
405 #[serde(skip_serializing_if = "Option::is_none")]
406 pub is_truncated: Option<bool>,
407 #[serde(skip_serializing_if = "Option::is_none")]
408 pub marker: Option<String>,
409 #[serde(default, skip_serializing_if = "Vec::is_empty")]
410 pub users: Vec<User>,
411}
412
413#[derive(Debug, Clone, Default, Serialize, Deserialize)]
415#[serde(rename_all = "PascalCase")]
416pub struct SimulatePolicyResponse {
417 #[serde(default, skip_serializing_if = "Vec::is_empty")]
418 pub evaluation_results: Vec<EvaluationResult>,
419 #[serde(skip_serializing_if = "Option::is_none")]
420 pub is_truncated: Option<bool>,
421 #[serde(skip_serializing_if = "Option::is_none")]
422 pub marker: Option<String>,
423}
424
425#[derive(Debug, Clone, Default, Serialize, Deserialize)]
427#[serde(rename_all = "PascalCase")]
428pub struct UpdateRoleResponse {}