Skip to main content

rustack_iam_model/
output.rs

1//! Auto-generated from AWS IAM Smithy model. DO NOT EDIT.
2
3use 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/// IAM CreateAccessKeyResponse.
13#[derive(Debug, Clone, Default, Serialize, Deserialize)]
14#[serde(rename_all = "PascalCase")]
15pub struct CreateAccessKeyResponse {
16    pub access_key: AccessKey,
17}
18
19/// IAM CreateGroupResponse.
20#[derive(Debug, Clone, Default, Serialize, Deserialize)]
21#[serde(rename_all = "PascalCase")]
22pub struct CreateGroupResponse {
23    pub group: Group,
24}
25
26/// IAM CreateInstanceProfileResponse.
27#[derive(Debug, Clone, Default, Serialize, Deserialize)]
28#[serde(rename_all = "PascalCase")]
29pub struct CreateInstanceProfileResponse {
30    pub instance_profile: InstanceProfile,
31}
32
33/// IAM CreatePolicyResponse.
34#[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/// IAM CreatePolicyVersionResponse.
42#[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/// IAM CreateRoleResponse.
50#[derive(Debug, Clone, Default, Serialize, Deserialize)]
51#[serde(rename_all = "PascalCase")]
52pub struct CreateRoleResponse {
53    pub role: Role,
54}
55
56/// IAM CreateServiceLinkedRoleResponse.
57#[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/// IAM CreateUserResponse.
65#[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/// IAM DeleteServiceLinkedRoleResponse.
73#[derive(Debug, Clone, Default, Serialize, Deserialize)]
74#[serde(rename_all = "PascalCase")]
75pub struct DeleteServiceLinkedRoleResponse {
76    pub deletion_task_id: String,
77}
78
79/// IAM GetAccessKeyLastUsedResponse.
80#[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/// IAM GetAccountAuthorizationDetailsResponse.
90#[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/// IAM GetGroupPolicyResponse.
108#[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/// IAM GetGroupResponse.
117#[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/// IAM GetInstanceProfileResponse.
130#[derive(Debug, Clone, Default, Serialize, Deserialize)]
131#[serde(rename_all = "PascalCase")]
132pub struct GetInstanceProfileResponse {
133    pub instance_profile: InstanceProfile,
134}
135
136/// IAM GetPolicyResponse.
137#[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/// IAM GetPolicyVersionResponse.
145#[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/// IAM GetRolePolicyResponse.
153#[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/// IAM GetRoleResponse.
162#[derive(Debug, Clone, Default, Serialize, Deserialize)]
163#[serde(rename_all = "PascalCase")]
164pub struct GetRoleResponse {
165    pub role: Role,
166}
167
168/// IAM GetServiceLinkedRoleDeletionStatusResponse.
169#[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/// IAM GetUserPolicyResponse.
178#[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/// IAM GetUserResponse.
187#[derive(Debug, Clone, Default, Serialize, Deserialize)]
188#[serde(rename_all = "PascalCase")]
189pub struct GetUserResponse {
190    pub user: User,
191}
192
193/// IAM ListAccessKeysResponse.
194#[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/// IAM ListAttachedGroupPoliciesResponse.
206#[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/// IAM ListAttachedRolePoliciesResponse.
218#[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/// IAM ListAttachedUserPoliciesResponse.
230#[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/// IAM ListEntitiesForPolicyResponse.
242#[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/// IAM ListGroupPoliciesResponse.
258#[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/// IAM ListGroupsForUserResponse.
270#[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/// IAM ListGroupsResponse.
282#[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/// IAM ListInstanceProfilesForRoleResponse.
294#[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/// IAM ListInstanceProfilesResponse.
306#[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/// IAM ListPoliciesResponse.
318#[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/// IAM ListPolicyVersionsResponse.
330#[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/// IAM ListRolePoliciesResponse.
342#[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/// IAM ListRoleTagsResponse.
354#[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/// IAM ListRolesResponse.
366#[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/// IAM ListUserPoliciesResponse.
378#[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/// IAM ListUserTagsResponse.
390#[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/// IAM ListUsersResponse.
402#[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/// IAM SimulatePolicyResponse.
414#[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/// IAM UpdateRoleResponse.
426#[derive(Debug, Clone, Default, Serialize, Deserialize)]
427#[serde(rename_all = "PascalCase")]
428pub struct UpdateRoleResponse {}