rustack_iam_model/
types.rs

1//! Auto-generated from AWS IAM Smithy model. DO NOT EDIT.
2
3use std::collections::HashMap;
4
5use serde::{Deserialize, Serialize};
6
7/// IAM ContextKeyTypeEnum enum.
8#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
9pub enum ContextKeyTypeEnum {
10    /// Default variant.
11    #[default]
12    #[serde(rename = "binary")]
13    Binary,
14    #[serde(rename = "binaryList")]
15    BinaryList,
16    #[serde(rename = "boolean")]
17    Boolean,
18    #[serde(rename = "booleanList")]
19    BooleanList,
20    #[serde(rename = "date")]
21    Date,
22    #[serde(rename = "dateList")]
23    DateList,
24    #[serde(rename = "ip")]
25    Ip,
26    #[serde(rename = "ipList")]
27    IpList,
28    #[serde(rename = "numeric")]
29    Numeric,
30    #[serde(rename = "numericList")]
31    NumericList,
32    #[serde(rename = "string")]
33    String,
34    #[serde(rename = "stringList")]
35    StringList,
36}
37
38impl ContextKeyTypeEnum {
39    /// Returns the string value of this enum variant.
40    #[must_use]
41    pub fn as_str(&self) -> &'static str {
42        match self {
43            Self::Binary => "binary",
44            Self::BinaryList => "binaryList",
45            Self::Boolean => "boolean",
46            Self::BooleanList => "booleanList",
47            Self::Date => "date",
48            Self::DateList => "dateList",
49            Self::Ip => "ip",
50            Self::IpList => "ipList",
51            Self::Numeric => "numeric",
52            Self::NumericList => "numericList",
53            Self::String => "string",
54            Self::StringList => "stringList",
55        }
56    }
57}
58
59impl std::fmt::Display for ContextKeyTypeEnum {
60    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
61        f.write_str(self.as_str())
62    }
63}
64
65impl From<&str> for ContextKeyTypeEnum {
66    fn from(s: &str) -> Self {
67        match s {
68            "binary" => Self::Binary,
69            "binaryList" => Self::BinaryList,
70            "boolean" => Self::Boolean,
71            "booleanList" => Self::BooleanList,
72            "date" => Self::Date,
73            "dateList" => Self::DateList,
74            "ip" => Self::Ip,
75            "ipList" => Self::IpList,
76            "numeric" => Self::Numeric,
77            "numericList" => Self::NumericList,
78            "string" => Self::String,
79            "stringList" => Self::StringList,
80            _ => Self::default(),
81        }
82    }
83}
84
85/// IAM DeletionTaskStatusType enum.
86#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
87pub enum DeletionTaskStatusType {
88    /// Default variant.
89    #[default]
90    #[serde(rename = "FAILED")]
91    Failed,
92    #[serde(rename = "IN_PROGRESS")]
93    InProgress,
94    #[serde(rename = "NOT_STARTED")]
95    NotStarted,
96    #[serde(rename = "SUCCEEDED")]
97    Succeeded,
98}
99
100impl DeletionTaskStatusType {
101    /// Returns the string value of this enum variant.
102    #[must_use]
103    pub fn as_str(&self) -> &'static str {
104        match self {
105            Self::Failed => "FAILED",
106            Self::InProgress => "IN_PROGRESS",
107            Self::NotStarted => "NOT_STARTED",
108            Self::Succeeded => "SUCCEEDED",
109        }
110    }
111}
112
113impl std::fmt::Display for DeletionTaskStatusType {
114    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
115        f.write_str(self.as_str())
116    }
117}
118
119impl From<&str> for DeletionTaskStatusType {
120    fn from(s: &str) -> Self {
121        match s {
122            "FAILED" => Self::Failed,
123            "IN_PROGRESS" => Self::InProgress,
124            "NOT_STARTED" => Self::NotStarted,
125            "SUCCEEDED" => Self::Succeeded,
126            _ => Self::default(),
127        }
128    }
129}
130
131/// IAM EntityType enum.
132#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
133pub enum EntityType {
134    /// Default variant.
135    #[default]
136    #[serde(rename = "AWSManagedPolicy")]
137    AwsManagedPolicy,
138    Group,
139    LocalManagedPolicy,
140    Role,
141    User,
142}
143
144impl EntityType {
145    /// Returns the string value of this enum variant.
146    #[must_use]
147    pub fn as_str(&self) -> &'static str {
148        match self {
149            Self::AwsManagedPolicy => "AWSManagedPolicy",
150            Self::Group => "Group",
151            Self::LocalManagedPolicy => "LocalManagedPolicy",
152            Self::Role => "Role",
153            Self::User => "User",
154        }
155    }
156}
157
158impl std::fmt::Display for EntityType {
159    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
160        f.write_str(self.as_str())
161    }
162}
163
164impl From<&str> for EntityType {
165    fn from(s: &str) -> Self {
166        match s {
167            "AWSManagedPolicy" => Self::AwsManagedPolicy,
168            "Group" => Self::Group,
169            "LocalManagedPolicy" => Self::LocalManagedPolicy,
170            "Role" => Self::Role,
171            "User" => Self::User,
172            _ => Self::default(),
173        }
174    }
175}
176
177/// IAM PermissionsBoundaryAttachmentType enum.
178#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
179pub enum PermissionsBoundaryAttachmentType {
180    /// Default variant.
181    #[default]
182    #[serde(rename = "PermissionsBoundaryPolicy")]
183    Policy,
184}
185
186impl PermissionsBoundaryAttachmentType {
187    /// Returns the string value of this enum variant.
188    #[must_use]
189    pub fn as_str(&self) -> &'static str {
190        match self {
191            Self::Policy => "PermissionsBoundaryPolicy",
192        }
193    }
194}
195
196impl std::fmt::Display for PermissionsBoundaryAttachmentType {
197    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
198        f.write_str(self.as_str())
199    }
200}
201
202impl From<&str> for PermissionsBoundaryAttachmentType {
203    fn from(s: &str) -> Self {
204        match s {
205            "PermissionsBoundaryPolicy" => Self::Policy,
206            _ => Self::default(),
207        }
208    }
209}
210
211/// IAM PolicyEvaluationDecisionType enum.
212#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
213pub enum PolicyEvaluationDecisionType {
214    /// Default variant.
215    #[default]
216    #[serde(rename = "allowed")]
217    Allowed,
218    #[serde(rename = "explicitDeny")]
219    ExplicitDeny,
220    #[serde(rename = "implicitDeny")]
221    ImplicitDeny,
222}
223
224impl PolicyEvaluationDecisionType {
225    /// Returns the string value of this enum variant.
226    #[must_use]
227    pub fn as_str(&self) -> &'static str {
228        match self {
229            Self::Allowed => "allowed",
230            Self::ExplicitDeny => "explicitDeny",
231            Self::ImplicitDeny => "implicitDeny",
232        }
233    }
234}
235
236impl std::fmt::Display for PolicyEvaluationDecisionType {
237    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
238        f.write_str(self.as_str())
239    }
240}
241
242impl From<&str> for PolicyEvaluationDecisionType {
243    fn from(s: &str) -> Self {
244        match s {
245            "allowed" => Self::Allowed,
246            "explicitDeny" => Self::ExplicitDeny,
247            "implicitDeny" => Self::ImplicitDeny,
248            _ => Self::default(),
249        }
250    }
251}
252
253/// IAM PolicySourceType enum.
254#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
255pub enum PolicySourceType {
256    /// Default variant.
257    #[default]
258    #[serde(rename = "aws-managed")]
259    AwsManaged,
260    #[serde(rename = "group")]
261    Group,
262    #[serde(rename = "none")]
263    None,
264    #[serde(rename = "resource")]
265    Resource,
266    #[serde(rename = "role")]
267    Role,
268    #[serde(rename = "user")]
269    User,
270    #[serde(rename = "user-managed")]
271    UserManaged,
272}
273
274impl PolicySourceType {
275    /// Returns the string value of this enum variant.
276    #[must_use]
277    pub fn as_str(&self) -> &'static str {
278        match self {
279            Self::AwsManaged => "aws-managed",
280            Self::Group => "group",
281            Self::None => "none",
282            Self::Resource => "resource",
283            Self::Role => "role",
284            Self::User => "user",
285            Self::UserManaged => "user-managed",
286        }
287    }
288}
289
290impl std::fmt::Display for PolicySourceType {
291    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
292        f.write_str(self.as_str())
293    }
294}
295
296impl From<&str> for PolicySourceType {
297    fn from(s: &str) -> Self {
298        match s {
299            "aws-managed" => Self::AwsManaged,
300            "group" => Self::Group,
301            "none" => Self::None,
302            "resource" => Self::Resource,
303            "role" => Self::Role,
304            "user" => Self::User,
305            "user-managed" => Self::UserManaged,
306            _ => Self::default(),
307        }
308    }
309}
310
311/// IAM PolicyUsageType enum.
312#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
313pub enum PolicyUsageType {
314    /// Default variant.
315    #[default]
316    PermissionsBoundary,
317    PermissionsPolicy,
318}
319
320impl PolicyUsageType {
321    /// Returns the string value of this enum variant.
322    #[must_use]
323    pub fn as_str(&self) -> &'static str {
324        match self {
325            Self::PermissionsBoundary => "PermissionsBoundary",
326            Self::PermissionsPolicy => "PermissionsPolicy",
327        }
328    }
329}
330
331impl std::fmt::Display for PolicyUsageType {
332    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
333        f.write_str(self.as_str())
334    }
335}
336
337impl From<&str> for PolicyUsageType {
338    fn from(s: &str) -> Self {
339        match s {
340            "PermissionsBoundary" => Self::PermissionsBoundary,
341            "PermissionsPolicy" => Self::PermissionsPolicy,
342            _ => Self::default(),
343        }
344    }
345}
346
347/// IAM policyScopeType enum.
348#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
349#[allow(non_camel_case_types)]
350pub enum policyScopeType {
351    /// Default variant.
352    #[default]
353    All,
354    #[serde(rename = "AWS")]
355    Aws,
356    Local,
357}
358
359impl policyScopeType {
360    /// Returns the string value of this enum variant.
361    #[must_use]
362    pub fn as_str(&self) -> &'static str {
363        match self {
364            Self::All => "All",
365            Self::Aws => "AWS",
366            Self::Local => "Local",
367        }
368    }
369}
370
371impl std::fmt::Display for policyScopeType {
372    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
373        f.write_str(self.as_str())
374    }
375}
376
377impl From<&str> for policyScopeType {
378    fn from(s: &str) -> Self {
379        match s {
380            "All" => Self::All,
381            "AWS" => Self::Aws,
382            "Local" => Self::Local,
383            _ => Self::default(),
384        }
385    }
386}
387
388/// IAM statusType enum.
389#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
390#[allow(non_camel_case_types)]
391pub enum statusType {
392    /// Default variant.
393    #[default]
394    Active,
395    Expired,
396    Inactive,
397}
398
399impl statusType {
400    /// Returns the string value of this enum variant.
401    #[must_use]
402    pub fn as_str(&self) -> &'static str {
403        match self {
404            Self::Active => "Active",
405            Self::Expired => "Expired",
406            Self::Inactive => "Inactive",
407        }
408    }
409}
410
411impl std::fmt::Display for statusType {
412    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
413        f.write_str(self.as_str())
414    }
415}
416
417impl From<&str> for statusType {
418    fn from(s: &str) -> Self {
419        match s {
420            "Active" => Self::Active,
421            "Expired" => Self::Expired,
422            "Inactive" => Self::Inactive,
423            _ => Self::default(),
424        }
425    }
426}
427
428/// IAM AccessKey.
429#[derive(Debug, Clone, Default, Serialize, Deserialize)]
430#[serde(rename_all = "PascalCase")]
431pub struct AccessKey {
432    pub access_key_id: String,
433    #[serde(skip_serializing_if = "Option::is_none")]
434    pub create_date: Option<chrono::DateTime<chrono::Utc>>,
435    pub secret_access_key: String,
436    pub status: statusType,
437    pub user_name: String,
438}
439
440/// IAM AccessKeyLastUsed.
441#[derive(Debug, Clone, Default, Serialize, Deserialize)]
442#[serde(rename_all = "PascalCase")]
443pub struct AccessKeyLastUsed {
444    #[serde(skip_serializing_if = "Option::is_none")]
445    pub last_used_date: Option<chrono::DateTime<chrono::Utc>>,
446    pub region: String,
447    pub service_name: String,
448}
449
450/// IAM AccessKeyMetadata.
451#[derive(Debug, Clone, Default, Serialize, Deserialize)]
452#[serde(rename_all = "PascalCase")]
453pub struct AccessKeyMetadata {
454    #[serde(skip_serializing_if = "Option::is_none")]
455    pub access_key_id: Option<String>,
456    #[serde(skip_serializing_if = "Option::is_none")]
457    pub create_date: Option<chrono::DateTime<chrono::Utc>>,
458    #[serde(skip_serializing_if = "Option::is_none")]
459    pub status: Option<statusType>,
460    #[serde(skip_serializing_if = "Option::is_none")]
461    pub user_name: Option<String>,
462}
463
464/// IAM AttachedPermissionsBoundary.
465#[derive(Debug, Clone, Default, Serialize, Deserialize)]
466#[serde(rename_all = "PascalCase")]
467pub struct AttachedPermissionsBoundary {
468    #[serde(skip_serializing_if = "Option::is_none")]
469    pub permissions_boundary_arn: Option<String>,
470    #[serde(skip_serializing_if = "Option::is_none")]
471    pub permissions_boundary_type: Option<PermissionsBoundaryAttachmentType>,
472}
473
474/// IAM AttachedPolicy.
475#[derive(Debug, Clone, Default, Serialize, Deserialize)]
476#[serde(rename_all = "PascalCase")]
477pub struct AttachedPolicy {
478    #[serde(skip_serializing_if = "Option::is_none")]
479    pub policy_arn: Option<String>,
480    #[serde(skip_serializing_if = "Option::is_none")]
481    pub policy_name: Option<String>,
482}
483
484/// IAM ContextEntry.
485#[derive(Debug, Clone, Default, Serialize, Deserialize)]
486#[serde(rename_all = "PascalCase")]
487pub struct ContextEntry {
488    #[serde(skip_serializing_if = "Option::is_none")]
489    pub context_key_name: Option<String>,
490    #[serde(skip_serializing_if = "Option::is_none")]
491    pub context_key_type: Option<ContextKeyTypeEnum>,
492    #[serde(default, skip_serializing_if = "Vec::is_empty")]
493    pub context_key_values: Vec<String>,
494}
495
496/// IAM DeletionTaskFailureReasonType.
497#[derive(Debug, Clone, Default, Serialize, Deserialize)]
498#[serde(rename_all = "PascalCase")]
499pub struct DeletionTaskFailureReasonType {
500    #[serde(skip_serializing_if = "Option::is_none")]
501    pub reason: Option<String>,
502    #[serde(default, skip_serializing_if = "Vec::is_empty")]
503    pub role_usage_list: Vec<RoleUsageType>,
504}
505
506/// IAM EvaluationResult.
507#[derive(Debug, Clone, Default, Serialize, Deserialize)]
508#[serde(rename_all = "PascalCase")]
509pub struct EvaluationResult {
510    pub eval_action_name: String,
511    pub eval_decision: PolicyEvaluationDecisionType,
512    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
513    pub eval_decision_details: HashMap<String, PolicyEvaluationDecisionType>,
514    #[serde(skip_serializing_if = "Option::is_none")]
515    pub eval_resource_name: Option<String>,
516    #[serde(default, skip_serializing_if = "Vec::is_empty")]
517    pub matched_statements: Vec<Statement>,
518    #[serde(default, skip_serializing_if = "Vec::is_empty")]
519    pub missing_context_values: Vec<String>,
520    #[serde(skip_serializing_if = "Option::is_none")]
521    pub organizations_decision_detail: Option<OrganizationsDecisionDetail>,
522    #[serde(skip_serializing_if = "Option::is_none")]
523    pub permissions_boundary_decision_detail: Option<PermissionsBoundaryDecisionDetail>,
524    #[serde(default, skip_serializing_if = "Vec::is_empty")]
525    pub resource_specific_results: Vec<ResourceSpecificResult>,
526}
527
528/// IAM Group.
529#[derive(Debug, Clone, Default, Serialize, Deserialize)]
530#[serde(rename_all = "PascalCase")]
531pub struct Group {
532    pub arn: String,
533    pub create_date: chrono::DateTime<chrono::Utc>,
534    pub group_id: String,
535    pub group_name: String,
536    pub path: String,
537}
538
539/// IAM GroupDetail.
540#[derive(Debug, Clone, Default, Serialize, Deserialize)]
541#[serde(rename_all = "PascalCase")]
542pub struct GroupDetail {
543    #[serde(skip_serializing_if = "Option::is_none")]
544    pub arn: Option<String>,
545    #[serde(default, skip_serializing_if = "Vec::is_empty")]
546    pub attached_managed_policies: Vec<AttachedPolicy>,
547    #[serde(skip_serializing_if = "Option::is_none")]
548    pub create_date: Option<chrono::DateTime<chrono::Utc>>,
549    #[serde(skip_serializing_if = "Option::is_none")]
550    pub group_id: Option<String>,
551    #[serde(skip_serializing_if = "Option::is_none")]
552    pub group_name: Option<String>,
553    #[serde(default, skip_serializing_if = "Vec::is_empty")]
554    pub group_policy_list: Vec<PolicyDetail>,
555    #[serde(skip_serializing_if = "Option::is_none")]
556    pub path: Option<String>,
557}
558
559/// IAM InstanceProfile.
560#[derive(Debug, Clone, Default, Serialize, Deserialize)]
561#[serde(rename_all = "PascalCase")]
562pub struct InstanceProfile {
563    pub arn: String,
564    pub create_date: chrono::DateTime<chrono::Utc>,
565    pub instance_profile_id: String,
566    pub instance_profile_name: String,
567    pub path: String,
568    #[serde(default, skip_serializing_if = "Vec::is_empty")]
569    pub roles: Vec<Role>,
570    #[serde(default, skip_serializing_if = "Vec::is_empty")]
571    pub tags: Vec<Tag>,
572}
573
574/// IAM ManagedPolicyDetail.
575#[derive(Debug, Clone, Default, Serialize, Deserialize)]
576#[serde(rename_all = "PascalCase")]
577pub struct ManagedPolicyDetail {
578    #[serde(skip_serializing_if = "Option::is_none")]
579    pub arn: Option<String>,
580    #[serde(skip_serializing_if = "Option::is_none")]
581    pub attachment_count: Option<i32>,
582    #[serde(skip_serializing_if = "Option::is_none")]
583    pub create_date: Option<chrono::DateTime<chrono::Utc>>,
584    #[serde(skip_serializing_if = "Option::is_none")]
585    pub default_version_id: Option<String>,
586    #[serde(skip_serializing_if = "Option::is_none")]
587    pub description: Option<String>,
588    #[serde(skip_serializing_if = "Option::is_none")]
589    pub is_attachable: Option<bool>,
590    #[serde(skip_serializing_if = "Option::is_none")]
591    pub path: Option<String>,
592    #[serde(skip_serializing_if = "Option::is_none")]
593    pub permissions_boundary_usage_count: Option<i32>,
594    #[serde(skip_serializing_if = "Option::is_none")]
595    pub policy_id: Option<String>,
596    #[serde(skip_serializing_if = "Option::is_none")]
597    pub policy_name: Option<String>,
598    #[serde(default, skip_serializing_if = "Vec::is_empty")]
599    pub policy_version_list: Vec<PolicyVersion>,
600    #[serde(skip_serializing_if = "Option::is_none")]
601    pub update_date: Option<chrono::DateTime<chrono::Utc>>,
602}
603
604/// IAM OrganizationsDecisionDetail.
605#[derive(Debug, Clone, Default, Serialize, Deserialize)]
606#[serde(rename_all = "PascalCase")]
607pub struct OrganizationsDecisionDetail {
608    #[serde(skip_serializing_if = "Option::is_none")]
609    pub allowed_by_organizations: Option<bool>,
610}
611
612/// IAM PermissionsBoundaryDecisionDetail.
613#[derive(Debug, Clone, Default, Serialize, Deserialize)]
614#[serde(rename_all = "PascalCase")]
615pub struct PermissionsBoundaryDecisionDetail {
616    #[serde(skip_serializing_if = "Option::is_none")]
617    pub allowed_by_permissions_boundary: Option<bool>,
618}
619
620/// IAM Policy.
621#[derive(Debug, Clone, Default, Serialize, Deserialize)]
622#[serde(rename_all = "PascalCase")]
623pub struct Policy {
624    #[serde(skip_serializing_if = "Option::is_none")]
625    pub arn: Option<String>,
626    #[serde(skip_serializing_if = "Option::is_none")]
627    pub attachment_count: Option<i32>,
628    #[serde(skip_serializing_if = "Option::is_none")]
629    pub create_date: Option<chrono::DateTime<chrono::Utc>>,
630    #[serde(skip_serializing_if = "Option::is_none")]
631    pub default_version_id: Option<String>,
632    #[serde(skip_serializing_if = "Option::is_none")]
633    pub description: Option<String>,
634    #[serde(skip_serializing_if = "Option::is_none")]
635    pub is_attachable: Option<bool>,
636    #[serde(skip_serializing_if = "Option::is_none")]
637    pub path: Option<String>,
638    #[serde(skip_serializing_if = "Option::is_none")]
639    pub permissions_boundary_usage_count: Option<i32>,
640    #[serde(skip_serializing_if = "Option::is_none")]
641    pub policy_id: Option<String>,
642    #[serde(skip_serializing_if = "Option::is_none")]
643    pub policy_name: Option<String>,
644    #[serde(default, skip_serializing_if = "Vec::is_empty")]
645    pub tags: Vec<Tag>,
646    #[serde(skip_serializing_if = "Option::is_none")]
647    pub update_date: Option<chrono::DateTime<chrono::Utc>>,
648}
649
650/// IAM PolicyDetail.
651#[derive(Debug, Clone, Default, Serialize, Deserialize)]
652#[serde(rename_all = "PascalCase")]
653pub struct PolicyDetail {
654    #[serde(skip_serializing_if = "Option::is_none")]
655    pub policy_document: Option<String>,
656    #[serde(skip_serializing_if = "Option::is_none")]
657    pub policy_name: Option<String>,
658}
659
660/// IAM PolicyGroup.
661#[derive(Debug, Clone, Default, Serialize, Deserialize)]
662#[serde(rename_all = "PascalCase")]
663pub struct PolicyGroup {
664    #[serde(skip_serializing_if = "Option::is_none")]
665    pub group_id: Option<String>,
666    #[serde(skip_serializing_if = "Option::is_none")]
667    pub group_name: Option<String>,
668}
669
670/// IAM PolicyRole.
671#[derive(Debug, Clone, Default, Serialize, Deserialize)]
672#[serde(rename_all = "PascalCase")]
673pub struct PolicyRole {
674    #[serde(skip_serializing_if = "Option::is_none")]
675    pub role_id: Option<String>,
676    #[serde(skip_serializing_if = "Option::is_none")]
677    pub role_name: Option<String>,
678}
679
680/// IAM PolicyUser.
681#[derive(Debug, Clone, Default, Serialize, Deserialize)]
682#[serde(rename_all = "PascalCase")]
683pub struct PolicyUser {
684    #[serde(skip_serializing_if = "Option::is_none")]
685    pub user_id: Option<String>,
686    #[serde(skip_serializing_if = "Option::is_none")]
687    pub user_name: Option<String>,
688}
689
690/// IAM PolicyVersion.
691#[derive(Debug, Clone, Default, Serialize, Deserialize)]
692#[serde(rename_all = "PascalCase")]
693pub struct PolicyVersion {
694    #[serde(skip_serializing_if = "Option::is_none")]
695    pub create_date: Option<chrono::DateTime<chrono::Utc>>,
696    #[serde(skip_serializing_if = "Option::is_none")]
697    pub document: Option<String>,
698    #[serde(skip_serializing_if = "Option::is_none")]
699    pub is_default_version: Option<bool>,
700    #[serde(skip_serializing_if = "Option::is_none")]
701    pub version_id: Option<String>,
702}
703
704/// IAM Position.
705#[derive(Debug, Clone, Default, Serialize, Deserialize)]
706#[serde(rename_all = "PascalCase")]
707pub struct Position {
708    #[serde(skip_serializing_if = "Option::is_none")]
709    pub column: Option<i32>,
710    #[serde(skip_serializing_if = "Option::is_none")]
711    pub line: Option<i32>,
712}
713
714/// IAM ResourceSpecificResult.
715#[derive(Debug, Clone, Default, Serialize, Deserialize)]
716#[serde(rename_all = "PascalCase")]
717pub struct ResourceSpecificResult {
718    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
719    pub eval_decision_details: HashMap<String, PolicyEvaluationDecisionType>,
720    pub eval_resource_decision: PolicyEvaluationDecisionType,
721    pub eval_resource_name: String,
722    #[serde(default, skip_serializing_if = "Vec::is_empty")]
723    pub matched_statements: Vec<Statement>,
724    #[serde(default, skip_serializing_if = "Vec::is_empty")]
725    pub missing_context_values: Vec<String>,
726    #[serde(skip_serializing_if = "Option::is_none")]
727    pub permissions_boundary_decision_detail: Option<PermissionsBoundaryDecisionDetail>,
728}
729
730/// IAM Role.
731#[derive(Debug, Clone, Default, Serialize, Deserialize)]
732#[serde(rename_all = "PascalCase")]
733pub struct Role {
734    pub arn: String,
735    #[serde(skip_serializing_if = "Option::is_none")]
736    pub assume_role_policy_document: Option<String>,
737    pub create_date: chrono::DateTime<chrono::Utc>,
738    #[serde(skip_serializing_if = "Option::is_none")]
739    pub description: Option<String>,
740    #[serde(skip_serializing_if = "Option::is_none")]
741    pub max_session_duration: Option<i32>,
742    pub path: String,
743    #[serde(skip_serializing_if = "Option::is_none")]
744    pub permissions_boundary: Option<AttachedPermissionsBoundary>,
745    pub role_id: String,
746    #[serde(skip_serializing_if = "Option::is_none")]
747    pub role_last_used: Option<RoleLastUsed>,
748    pub role_name: String,
749    #[serde(default, skip_serializing_if = "Vec::is_empty")]
750    pub tags: Vec<Tag>,
751}
752
753/// IAM RoleDetail.
754#[derive(Debug, Clone, Default, Serialize, Deserialize)]
755#[serde(rename_all = "PascalCase")]
756pub struct RoleDetail {
757    #[serde(skip_serializing_if = "Option::is_none")]
758    pub arn: Option<String>,
759    #[serde(skip_serializing_if = "Option::is_none")]
760    pub assume_role_policy_document: Option<String>,
761    #[serde(default, skip_serializing_if = "Vec::is_empty")]
762    pub attached_managed_policies: Vec<AttachedPolicy>,
763    #[serde(skip_serializing_if = "Option::is_none")]
764    pub create_date: Option<chrono::DateTime<chrono::Utc>>,
765    #[serde(default, skip_serializing_if = "Vec::is_empty")]
766    pub instance_profile_list: Vec<InstanceProfile>,
767    #[serde(skip_serializing_if = "Option::is_none")]
768    pub path: Option<String>,
769    #[serde(skip_serializing_if = "Option::is_none")]
770    pub permissions_boundary: Option<AttachedPermissionsBoundary>,
771    #[serde(skip_serializing_if = "Option::is_none")]
772    pub role_id: Option<String>,
773    #[serde(skip_serializing_if = "Option::is_none")]
774    pub role_last_used: Option<RoleLastUsed>,
775    #[serde(skip_serializing_if = "Option::is_none")]
776    pub role_name: Option<String>,
777    #[serde(default, skip_serializing_if = "Vec::is_empty")]
778    pub role_policy_list: Vec<PolicyDetail>,
779    #[serde(default, skip_serializing_if = "Vec::is_empty")]
780    pub tags: Vec<Tag>,
781}
782
783/// IAM RoleLastUsed.
784#[derive(Debug, Clone, Default, Serialize, Deserialize)]
785#[serde(rename_all = "PascalCase")]
786pub struct RoleLastUsed {
787    #[serde(skip_serializing_if = "Option::is_none")]
788    pub last_used_date: Option<chrono::DateTime<chrono::Utc>>,
789    #[serde(skip_serializing_if = "Option::is_none")]
790    pub region: Option<String>,
791}
792
793/// IAM RoleUsageType.
794#[derive(Debug, Clone, Default, Serialize, Deserialize)]
795#[serde(rename_all = "PascalCase")]
796pub struct RoleUsageType {
797    #[serde(skip_serializing_if = "Option::is_none")]
798    pub region: Option<String>,
799    #[serde(default, skip_serializing_if = "Vec::is_empty")]
800    pub resources: Vec<String>,
801}
802
803/// IAM Statement.
804#[derive(Debug, Clone, Default, Serialize, Deserialize)]
805#[serde(rename_all = "PascalCase")]
806pub struct Statement {
807    #[serde(skip_serializing_if = "Option::is_none")]
808    pub end_position: Option<Position>,
809    #[serde(skip_serializing_if = "Option::is_none")]
810    pub source_policy_id: Option<String>,
811    #[serde(skip_serializing_if = "Option::is_none")]
812    pub source_policy_type: Option<PolicySourceType>,
813    #[serde(skip_serializing_if = "Option::is_none")]
814    pub start_position: Option<Position>,
815}
816
817/// IAM Tag.
818#[derive(Debug, Clone, Default, Serialize, Deserialize)]
819#[serde(rename_all = "PascalCase")]
820pub struct Tag {
821    pub key: String,
822    pub value: String,
823}
824
825/// IAM User.
826#[derive(Debug, Clone, Default, Serialize, Deserialize)]
827#[serde(rename_all = "PascalCase")]
828pub struct User {
829    pub arn: String,
830    pub create_date: chrono::DateTime<chrono::Utc>,
831    #[serde(skip_serializing_if = "Option::is_none")]
832    pub password_last_used: Option<chrono::DateTime<chrono::Utc>>,
833    pub path: String,
834    #[serde(skip_serializing_if = "Option::is_none")]
835    pub permissions_boundary: Option<AttachedPermissionsBoundary>,
836    #[serde(default, skip_serializing_if = "Vec::is_empty")]
837    pub tags: Vec<Tag>,
838    pub user_id: String,
839    pub user_name: String,
840}
841
842/// IAM UserDetail.
843#[derive(Debug, Clone, Default, Serialize, Deserialize)]
844#[serde(rename_all = "PascalCase")]
845pub struct UserDetail {
846    #[serde(skip_serializing_if = "Option::is_none")]
847    pub arn: Option<String>,
848    #[serde(default, skip_serializing_if = "Vec::is_empty")]
849    pub attached_managed_policies: Vec<AttachedPolicy>,
850    #[serde(skip_serializing_if = "Option::is_none")]
851    pub create_date: Option<chrono::DateTime<chrono::Utc>>,
852    #[serde(default, skip_serializing_if = "Vec::is_empty")]
853    pub group_list: Vec<String>,
854    #[serde(skip_serializing_if = "Option::is_none")]
855    pub path: Option<String>,
856    #[serde(skip_serializing_if = "Option::is_none")]
857    pub permissions_boundary: Option<AttachedPermissionsBoundary>,
858    #[serde(default, skip_serializing_if = "Vec::is_empty")]
859    pub tags: Vec<Tag>,
860    #[serde(skip_serializing_if = "Option::is_none")]
861    pub user_id: Option<String>,
862    #[serde(skip_serializing_if = "Option::is_none")]
863    pub user_name: Option<String>,
864    #[serde(default, skip_serializing_if = "Vec::is_empty")]
865    pub user_policy_list: Vec<PolicyDetail>,
866}
rustack_iam_model/types.rs

rustack_iam_model/
types.rs
