Skip to main content

rustack_ssm_model/
types.rs

1//! Shared SSM types used across input, output, and internal representations.
2//!
3//! All types follow the SSM JSON wire format with `PascalCase` field names.
4
5use serde::{Deserialize, Serialize};
6
7// ---------------------------------------------------------------------------
8// Enums
9// ---------------------------------------------------------------------------
10
11/// The type of a parameter.
12#[derive(Debug, Clone, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
13pub enum ParameterType {
14    /// A plain string value.
15    #[default]
16    String,
17    /// A comma-separated list of strings.
18    StringList,
19    /// An encrypted string value.
20    SecureString,
21}
22
23impl ParameterType {
24    /// Returns the wire-format string representation.
25    #[must_use]
26    pub fn as_str(&self) -> &'static str {
27        match self {
28            Self::String => "String",
29            Self::StringList => "StringList",
30            Self::SecureString => "SecureString",
31        }
32    }
33}
34
35impl std::fmt::Display for ParameterType {
36    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
37        f.write_str(self.as_str())
38    }
39}
40
41/// The tier of a parameter, which affects storage limits.
42#[derive(Debug, Clone, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
43pub enum ParameterTier {
44    /// Standard tier (4 KB value limit).
45    #[default]
46    Standard,
47    /// Advanced tier (8 KB value limit, additional features).
48    Advanced,
49    /// Intelligent-Tiering (automatically selects tier).
50    #[serde(rename = "Intelligent-Tiering")]
51    IntelligentTiering,
52}
53
54impl ParameterTier {
55    /// Returns the wire-format string representation.
56    #[must_use]
57    pub fn as_str(&self) -> &'static str {
58        match self {
59            Self::Standard => "Standard",
60            Self::Advanced => "Advanced",
61            Self::IntelligentTiering => "Intelligent-Tiering",
62        }
63    }
64}
65
66impl std::fmt::Display for ParameterTier {
67    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
68        f.write_str(self.as_str())
69    }
70}
71
72// ---------------------------------------------------------------------------
73// Shared types
74// ---------------------------------------------------------------------------
75
76/// A tag associated with a resource.
77#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
78#[serde(rename_all = "PascalCase")]
79pub struct Tag {
80    /// The tag key.
81    pub key: String,
82    /// The tag value.
83    pub value: String,
84}
85
86/// A parameter returned in API responses.
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(rename_all = "PascalCase")]
89pub struct Parameter {
90    /// The parameter name.
91    #[serde(skip_serializing_if = "Option::is_none")]
92    pub name: Option<String>,
93
94    /// The parameter type.
95    #[serde(rename = "Type", skip_serializing_if = "Option::is_none")]
96    pub parameter_type: Option<String>,
97
98    /// The parameter value.
99    #[serde(skip_serializing_if = "Option::is_none")]
100    pub value: Option<String>,
101
102    /// The parameter version.
103    #[serde(skip_serializing_if = "Option::is_none")]
104    pub version: Option<i64>,
105
106    /// The date the parameter was last changed or updated.
107    #[serde(skip_serializing_if = "Option::is_none")]
108    pub last_modified_date: Option<f64>,
109
110    /// The Amazon Resource Name (ARN) of the parameter.
111    #[serde(rename = "ARN", skip_serializing_if = "Option::is_none")]
112    pub arn: Option<String>,
113
114    /// The data type of the parameter (e.g., `"text"`, `"aws:ec2:image"`).
115    #[serde(skip_serializing_if = "Option::is_none")]
116    pub data_type: Option<String>,
117}
118
119/// A filter for `GetParametersByPath` and `DescribeParameters`.
120#[derive(Debug, Clone, Serialize, Deserialize)]
121#[serde(rename_all = "PascalCase")]
122pub struct ParameterStringFilter {
123    /// The filter key (e.g., `"Type"`, `"KeyId"`, `"Path"`, `"Name"`).
124    pub key: String,
125
126    /// The filter comparison option (e.g., `"Equals"`, `"BeginsWith"`).
127    #[serde(skip_serializing_if = "Option::is_none")]
128    pub option: Option<String>,
129
130    /// The filter values.
131    #[serde(default, skip_serializing_if = "Vec::is_empty")]
132    pub values: Vec<String>,
133}
134
135/// Metadata about a parameter (returned by `DescribeParameters`).
136///
137/// This is similar to `Parameter` but does NOT include the value.
138#[derive(Debug, Clone, Serialize, Deserialize)]
139#[serde(rename_all = "PascalCase")]
140pub struct ParameterMetadata {
141    /// The parameter name.
142    #[serde(skip_serializing_if = "Option::is_none")]
143    pub name: Option<String>,
144
145    /// The parameter type.
146    #[serde(rename = "Type", skip_serializing_if = "Option::is_none")]
147    pub parameter_type: Option<String>,
148
149    /// The KMS key ID for SecureString parameters.
150    #[serde(skip_serializing_if = "Option::is_none")]
151    pub key_id: Option<String>,
152
153    /// The date the parameter was last changed.
154    #[serde(skip_serializing_if = "Option::is_none")]
155    pub last_modified_date: Option<f64>,
156
157    /// The ARN of the user who last modified the parameter.
158    #[serde(skip_serializing_if = "Option::is_none")]
159    pub last_modified_user: Option<String>,
160
161    /// A description of the parameter.
162    #[serde(skip_serializing_if = "Option::is_none")]
163    pub description: Option<String>,
164
165    /// The allowed pattern for the parameter value.
166    #[serde(skip_serializing_if = "Option::is_none")]
167    pub allowed_pattern: Option<String>,
168
169    /// The parameter version.
170    #[serde(skip_serializing_if = "Option::is_none")]
171    pub version: Option<i64>,
172
173    /// The parameter tier.
174    #[serde(skip_serializing_if = "Option::is_none")]
175    pub tier: Option<String>,
176
177    /// Policies associated with the parameter.
178    #[serde(default, skip_serializing_if = "Vec::is_empty")]
179    pub policies: Vec<ParameterInlinePolicy>,
180
181    /// The data type of the parameter.
182    #[serde(skip_serializing_if = "Option::is_none")]
183    pub data_type: Option<String>,
184}
185
186/// A version history entry for a parameter (returned by `GetParameterHistory`).
187#[derive(Debug, Clone, Serialize, Deserialize)]
188#[serde(rename_all = "PascalCase")]
189pub struct ParameterHistory {
190    /// The parameter name.
191    #[serde(skip_serializing_if = "Option::is_none")]
192    pub name: Option<String>,
193
194    /// The parameter type.
195    #[serde(rename = "Type", skip_serializing_if = "Option::is_none")]
196    pub parameter_type: Option<String>,
197
198    /// The KMS key ID for SecureString parameters.
199    #[serde(skip_serializing_if = "Option::is_none")]
200    pub key_id: Option<String>,
201
202    /// The date this version was last modified.
203    #[serde(skip_serializing_if = "Option::is_none")]
204    pub last_modified_date: Option<f64>,
205
206    /// The ARN of the user who last modified this version.
207    #[serde(skip_serializing_if = "Option::is_none")]
208    pub last_modified_user: Option<String>,
209
210    /// A description of the parameter at this version.
211    #[serde(skip_serializing_if = "Option::is_none")]
212    pub description: Option<String>,
213
214    /// The parameter value at this version.
215    #[serde(skip_serializing_if = "Option::is_none")]
216    pub value: Option<String>,
217
218    /// The allowed pattern for the parameter value.
219    #[serde(skip_serializing_if = "Option::is_none")]
220    pub allowed_pattern: Option<String>,
221
222    /// The version number.
223    #[serde(skip_serializing_if = "Option::is_none")]
224    pub version: Option<i64>,
225
226    /// Labels attached to this version.
227    #[serde(default, skip_serializing_if = "Vec::is_empty")]
228    pub labels: Vec<String>,
229
230    /// The parameter tier.
231    #[serde(skip_serializing_if = "Option::is_none")]
232    pub tier: Option<String>,
233
234    /// Policies associated with the parameter.
235    #[serde(default, skip_serializing_if = "Vec::is_empty")]
236    pub policies: Vec<ParameterInlinePolicy>,
237
238    /// The data type of the parameter.
239    #[serde(skip_serializing_if = "Option::is_none")]
240    pub data_type: Option<String>,
241}
242
243/// An inline policy attached to a parameter.
244#[derive(Debug, Clone, Serialize, Deserialize)]
245#[serde(rename_all = "PascalCase")]
246pub struct ParameterInlinePolicy {
247    /// The JSON policy text.
248    #[serde(skip_serializing_if = "Option::is_none")]
249    pub policy_text: Option<String>,
250
251    /// The policy type.
252    #[serde(skip_serializing_if = "Option::is_none")]
253    pub policy_type: Option<String>,
254
255    /// The policy status.
256    #[serde(skip_serializing_if = "Option::is_none")]
257    pub policy_status: Option<String>,
258}