oci_rust_sdk/core/models/
volume_backup.rs1use chrono::{DateTime, Utc};
2use serde::{Deserialize, Serialize};
3use std::collections::HashMap;
4
5#[allow(unused_imports)]
6use super::*;
7#[derive(Debug, Clone, Serialize, Deserialize)]
9#[serde(rename_all = "camelCase")]
10pub struct VolumeBackup {
11 pub compartment_id: String,
13
14 pub display_name: String,
16
17 pub id: String,
19
20 pub lifecycle_state: VolumeBackupLifecycleState,
22
23 pub time_created: DateTime<Utc>,
25
26 #[serde(rename = "type")]
28 pub r#type: VolumeBackupType,
29
30 #[serde(skip_serializing_if = "Option::is_none")]
32 pub defined_tags: Option<HashMap<String, HashMap<String, serde_json::Value>>>,
33
34 #[serde(skip_serializing_if = "Option::is_none")]
36 pub system_tags: Option<HashMap<String, HashMap<String, serde_json::Value>>>,
37
38 #[serde(skip_serializing_if = "Option::is_none")]
40 pub expiration_time: Option<DateTime<Utc>>,
41
42 #[serde(skip_serializing_if = "Option::is_none")]
44 pub freeform_tags: Option<HashMap<String, String>>,
45
46 #[serde(skip_serializing_if = "Option::is_none")]
48 pub kms_key_id: Option<String>,
49
50 #[serde(skip_serializing_if = "Option::is_none")]
52 pub size_in_gbs: Option<i64>,
53
54 #[serde(skip_serializing_if = "Option::is_none")]
56 pub size_in_mbs: Option<i64>,
57
58 #[serde(skip_serializing_if = "Option::is_none")]
60 pub source_type: Option<VolumeBackupSourceType>,
61
62 #[serde(skip_serializing_if = "Option::is_none")]
64 pub source_volume_backup_id: Option<String>,
65
66 #[serde(skip_serializing_if = "Option::is_none")]
68 pub time_request_received: Option<DateTime<Utc>>,
69
70 #[serde(skip_serializing_if = "Option::is_none")]
72 pub unique_size_in_gbs: Option<i64>,
73
74 #[serde(skip_serializing_if = "Option::is_none")]
76 pub unique_size_in_mbs: Option<i64>,
77
78 #[serde(skip_serializing_if = "Option::is_none")]
80 pub volume_id: Option<String>,
81}
82
83pub struct VolumeBackupRequired {
85 pub compartment_id: String,
87
88 pub display_name: String,
90
91 pub id: String,
93
94 pub lifecycle_state: VolumeBackupLifecycleState,
96
97 pub time_created: DateTime<Utc>,
99
100 pub r#type: VolumeBackupType,
102}
103
104impl VolumeBackup {
105 pub fn new(required: VolumeBackupRequired) -> Self {
107 Self {
108 compartment_id: required.compartment_id,
109
110 display_name: required.display_name,
111
112 id: required.id,
113
114 lifecycle_state: required.lifecycle_state,
115
116 time_created: required.time_created,
117
118 r#type: required.r#type,
119
120 defined_tags: None,
121
122 system_tags: None,
123
124 expiration_time: None,
125
126 freeform_tags: None,
127
128 kms_key_id: None,
129
130 size_in_gbs: None,
131
132 size_in_mbs: None,
133
134 source_type: None,
135
136 source_volume_backup_id: None,
137
138 time_request_received: None,
139
140 unique_size_in_gbs: None,
141
142 unique_size_in_mbs: None,
143
144 volume_id: None,
145 }
146 }
147
148 pub fn set_compartment_id(mut self, value: String) -> Self {
150 self.compartment_id = value;
151 self
152 }
153
154 pub fn set_defined_tags(
156 mut self,
157 value: Option<HashMap<String, HashMap<String, serde_json::Value>>>,
158 ) -> Self {
159 self.defined_tags = value;
160 self
161 }
162
163 pub fn set_system_tags(
165 mut self,
166 value: Option<HashMap<String, HashMap<String, serde_json::Value>>>,
167 ) -> Self {
168 self.system_tags = value;
169 self
170 }
171
172 pub fn set_display_name(mut self, value: String) -> Self {
174 self.display_name = value;
175 self
176 }
177
178 pub fn set_expiration_time(mut self, value: Option<DateTime<Utc>>) -> Self {
180 self.expiration_time = value;
181 self
182 }
183
184 pub fn set_freeform_tags(mut self, value: Option<HashMap<String, String>>) -> Self {
186 self.freeform_tags = value;
187 self
188 }
189
190 pub fn set_id(mut self, value: String) -> Self {
192 self.id = value;
193 self
194 }
195
196 pub fn set_kms_key_id(mut self, value: Option<String>) -> Self {
198 self.kms_key_id = value;
199 self
200 }
201
202 pub fn set_lifecycle_state(mut self, value: VolumeBackupLifecycleState) -> Self {
204 self.lifecycle_state = value;
205 self
206 }
207
208 pub fn set_size_in_gbs(mut self, value: Option<i64>) -> Self {
210 self.size_in_gbs = value;
211 self
212 }
213
214 pub fn set_size_in_mbs(mut self, value: Option<i64>) -> Self {
216 self.size_in_mbs = value;
217 self
218 }
219
220 pub fn set_source_type(mut self, value: Option<VolumeBackupSourceType>) -> Self {
222 self.source_type = value;
223 self
224 }
225
226 pub fn set_source_volume_backup_id(mut self, value: Option<String>) -> Self {
228 self.source_volume_backup_id = value;
229 self
230 }
231
232 pub fn set_time_created(mut self, value: DateTime<Utc>) -> Self {
234 self.time_created = value;
235 self
236 }
237
238 pub fn set_time_request_received(mut self, value: Option<DateTime<Utc>>) -> Self {
240 self.time_request_received = value;
241 self
242 }
243
244 pub fn set_type(mut self, value: VolumeBackupType) -> Self {
246 self.r#type = value;
247 self
248 }
249
250 pub fn set_unique_size_in_gbs(mut self, value: Option<i64>) -> Self {
252 self.unique_size_in_gbs = value;
253 self
254 }
255
256 pub fn set_unique_size_in_mbs(mut self, value: Option<i64>) -> Self {
258 self.unique_size_in_mbs = value;
259 self
260 }
261
262 pub fn set_volume_id(mut self, value: Option<String>) -> Self {
264 self.volume_id = value;
265 self
266 }
267
268 pub fn with_defined_tags(
270 mut self,
271 value: HashMap<String, HashMap<String, serde_json::Value>>,
272 ) -> Self {
273 self.defined_tags = Some(value);
274 self
275 }
276
277 pub fn with_system_tags(
279 mut self,
280 value: HashMap<String, HashMap<String, serde_json::Value>>,
281 ) -> Self {
282 self.system_tags = Some(value);
283 self
284 }
285
286 pub fn with_expiration_time(mut self, value: DateTime<Utc>) -> Self {
288 self.expiration_time = Some(value);
289 self
290 }
291
292 pub fn with_freeform_tags(mut self, value: HashMap<String, String>) -> Self {
294 self.freeform_tags = Some(value);
295 self
296 }
297
298 pub fn with_kms_key_id(mut self, value: impl Into<String>) -> Self {
300 self.kms_key_id = Some(value.into());
301 self
302 }
303
304 pub fn with_size_in_gbs(mut self, value: i64) -> Self {
306 self.size_in_gbs = Some(value);
307 self
308 }
309
310 pub fn with_size_in_mbs(mut self, value: i64) -> Self {
312 self.size_in_mbs = Some(value);
313 self
314 }
315
316 pub fn with_source_type(mut self, value: VolumeBackupSourceType) -> Self {
318 self.source_type = Some(value);
319 self
320 }
321
322 pub fn with_source_volume_backup_id(mut self, value: impl Into<String>) -> Self {
324 self.source_volume_backup_id = Some(value.into());
325 self
326 }
327
328 pub fn with_time_request_received(mut self, value: DateTime<Utc>) -> Self {
330 self.time_request_received = Some(value);
331 self
332 }
333
334 pub fn with_unique_size_in_gbs(mut self, value: i64) -> Self {
336 self.unique_size_in_gbs = Some(value);
337 self
338 }
339
340 pub fn with_unique_size_in_mbs(mut self, value: i64) -> Self {
342 self.unique_size_in_mbs = Some(value);
343 self
344 }
345
346 pub fn with_volume_id(mut self, value: impl Into<String>) -> Self {
348 self.volume_id = Some(value.into());
349 self
350 }
351}